@rudderhq/cli 0.2.0-canary.2 → 0.2.0-canary.20

package/dist/index.js

@@ -122,7 +122,7 @@ var init_constants = __esm({
       "routing_suggestion",
       "system_event"
     ];
-    CHAT_MESSAGE_STATUSES = ["completed", "stopped", "failed"];
+    CHAT_MESSAGE_STATUSES = ["streaming", "completed", "stopped", "failed", "interrupted"];
     CHAT_CONTEXT_ENTITY_TYPES = ["issue", "project", "agent"];
     GOAL_LEVELS = ["organization", "team", "agent", "task"];
     GOAL_STATUSES = ["planned", "active", "achieved", "cancelled"];
@@ -495,302 +495,170 @@ var init_budget = __esm({
   }
 });
 
-// ../packages/shared/src/validators/secret.ts
-import { z as z3 } from "zod";
-var envBindingPlainSchema, envBindingSecretRefSchema, envBindingSchema, envConfigSchema, createSecretSchema, rotateSecretSchema, updateSecretSchema;
-var init_secret = __esm({
-  "../packages/shared/src/validators/secret.ts"() {
-    "use strict";
-    init_constants();
-    envBindingPlainSchema = z3.object({
-      type: z3.literal("plain"),
-      value: z3.string()
-    });
-    envBindingSecretRefSchema = z3.object({
-      type: z3.literal("secret_ref"),
-      secretId: z3.string().uuid(),
-      version: z3.union([z3.literal("latest"), z3.number().int().positive()]).optional()
-    });
-    envBindingSchema = z3.union([
-      z3.string(),
-      envBindingPlainSchema,
-      envBindingSecretRefSchema
-    ]);
-    envConfigSchema = z3.record(envBindingSchema);
-    createSecretSchema = z3.object({
-      name: z3.string().min(1),
-      provider: z3.enum(SECRET_PROVIDERS).optional(),
-      value: z3.string().min(1),
-      description: z3.string().optional().nullable(),
-      externalRef: z3.string().optional().nullable()
-    });
-    rotateSecretSchema = z3.object({
-      value: z3.string().min(1),
-      externalRef: z3.string().optional().nullable()
-    });
-    updateSecretSchema = z3.object({
-      name: z3.string().min(1).optional(),
-      description: z3.string().optional().nullable(),
-      externalRef: z3.string().optional().nullable()
-    });
-  }
-});
-
-// ../packages/shared/src/validators/model-fallbacks.ts
-import { z as z4 } from "zod";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateModelFallbacksConfig(value, ctx, pathPrefix) {
-  const fallbackModels = value.modelFallbacks;
-  if (fallbackModels === void 0) return;
-  if (!Array.isArray(fallbackModels)) {
-    ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
-      message: "modelFallbacks must be an array",
-      path: [...pathPrefix, "modelFallbacks"]
-    });
-    return;
-  }
-  fallbackModels.forEach((fallback, index66) => {
-    if (typeof fallback === "string") {
-      if (fallback.trim().length === 0) {
-        ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
-          message: "modelFallbacks string entries must be non-empty",
-          path: [...pathPrefix, "modelFallbacks", index66]
-        });
-      }
-      return;
-    }
-    if (!isRecord(fallback)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must be strings or runtime/model objects",
-        path: [...pathPrefix, "modelFallbacks", index66]
-      });
-      return;
-    }
-    if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
-      });
-    } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include a valid agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
-      });
-    }
-    if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entries must include model",
-        path: [...pathPrefix, "modelFallbacks", index66, "model"]
-      });
-    }
-    if (fallback.config !== void 0 && !isRecord(fallback.config)) {
-      ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
-        message: "modelFallbacks entry config must be an object",
-        path: [...pathPrefix, "modelFallbacks", index66, "config"]
-      });
-    } else if (isRecord(fallback.config) && fallback.config.env !== void 0) {
-      const parsed = envConfigSchema.safeParse(fallback.config.env);
-      if (!parsed.success) {
-        ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
-          message: "modelFallbacks entry config.env must be a map of valid env bindings",
-          path: [...pathPrefix, "modelFallbacks", index66, "config", "env"]
-        });
-      }
-    }
-  });
-}
-var agentRuntimeTypes;
-var init_model_fallbacks = __esm({
-  "../packages/shared/src/validators/model-fallbacks.ts"() {
-    "use strict";
-    init_constants();
-    init_secret();
-    agentRuntimeTypes = new Set(AGENT_RUNTIME_TYPES);
-  }
-});
-
 // ../packages/shared/src/validators/organization.ts
-import { z as z5 } from "zod";
-var logoAssetIdSchema, brandColorSchema, defaultChatRuntimeConfigSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
+import { z as z3 } from "zod";
+var logoAssetIdSchema, brandColorSchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema;
 var init_organization = __esm({
   "../packages/shared/src/validators/organization.ts"() {
     "use strict";
     init_constants();
-    init_model_fallbacks();
-    logoAssetIdSchema = z5.string().uuid().nullable().optional();
-    brandColorSchema = z5.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
-    defaultChatRuntimeConfigSchema = z5.record(z5.unknown()).superRefine((value, ctx) => {
-      validateModelFallbacksConfig(value, ctx, []);
-    });
-    createOrganizationSchema = z5.object({
-      name: z5.string().min(1),
-      description: z5.string().optional().nullable(),
-      budgetMonthlyCents: z5.number().int().nonnegative().optional().default(0),
-      defaultChatIssueCreationMode: z5.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
-      defaultChatAgentRuntimeType: z5.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
+    logoAssetIdSchema = z3.string().uuid().nullable().optional();
+    brandColorSchema = z3.string().regex(/^#[0-9a-fA-F]{6}$/).nullable().optional();
+    createOrganizationSchema = z3.object({
+      name: z3.string().min(1),
+      description: z3.string().optional().nullable(),
+      budgetMonthlyCents: z3.number().int().nonnegative().optional().default(0),
+      defaultChatIssueCreationMode: z3.enum(CHAT_ISSUE_CREATION_MODES).optional().default("manual_approval"),
       brandColor: brandColorSchema,
-      requireBoardApprovalForNewAgents: z5.boolean().optional()
+      requireBoardApprovalForNewAgents: z3.boolean().optional()
     });
     updateOrganizationSchema = createOrganizationSchema.partial().extend({
-      status: z5.enum(ORGANIZATION_STATUSES).optional(),
-      spentMonthlyCents: z5.number().int().nonnegative().optional(),
-      requireBoardApprovalForNewAgents: z5.boolean().optional(),
-      defaultChatIssueCreationMode: z5.enum(CHAT_ISSUE_CREATION_MODES).optional(),
-      defaultChatAgentRuntimeType: z5.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      defaultChatAgentRuntimeConfig: defaultChatRuntimeConfigSchema.optional().nullable(),
+      status: z3.enum(ORGANIZATION_STATUSES).optional(),
+      spentMonthlyCents: z3.number().int().nonnegative().optional(),
+      requireBoardApprovalForNewAgents: z3.boolean().optional(),
+      defaultChatIssueCreationMode: z3.enum(CHAT_ISSUE_CREATION_MODES).optional(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     });
-    updateOrganizationBrandingSchema = z5.object({
-      name: z5.string().min(1).optional(),
-      description: z5.string().nullable().optional(),
+    updateOrganizationBrandingSchema = z3.object({
+      name: z3.string().min(1).optional(),
+      description: z3.string().nullable().optional(),
       brandColor: brandColorSchema,
       logoAssetId: logoAssetIdSchema
     }).strict().refine(
       (value) => value.name !== void 0 || value.description !== void 0 || value.brandColor !== void 0 || value.logoAssetId !== void 0,
       "At least one branding field must be provided"
     );
-    updateOrganizationWorkspaceFileSchema = z5.object({
-      content: z5.string()
+    updateOrganizationWorkspaceFileSchema = z3.object({
+      content: z3.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/resource.ts
-import { z as z6 } from "zod";
+import { z as z4 } from "zod";
 var organizationResourceKindSchema, projectResourceAttachmentRoleSchema, createOrganizationResourceSchema, updateOrganizationResourceSchema, projectResourceAttachmentInputSchema, updateProjectResourceAttachmentSchema, createProjectInlineResourceSchema;
 var init_resource = __esm({
   "../packages/shared/src/validators/resource.ts"() {
     "use strict";
     init_constants();
-    organizationResourceKindSchema = z6.enum(ORGANIZATION_RESOURCE_KINDS);
-    projectResourceAttachmentRoleSchema = z6.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
-    createOrganizationResourceSchema = z6.object({
-      name: z6.string().min(1),
+    organizationResourceKindSchema = z4.enum(ORGANIZATION_RESOURCE_KINDS);
+    projectResourceAttachmentRoleSchema = z4.enum(PROJECT_RESOURCE_ATTACHMENT_ROLES);
+    createOrganizationResourceSchema = z4.object({
+      name: z4.string().min(1),
       kind: organizationResourceKindSchema,
-      locator: z6.string().min(1),
-      description: z6.string().optional().nullable(),
-      metadata: z6.record(z6.unknown()).optional().nullable()
+      locator: z4.string().min(1),
+      description: z4.string().optional().nullable(),
+      metadata: z4.record(z4.unknown()).optional().nullable()
     });
-    updateOrganizationResourceSchema = z6.object({
-      name: z6.string().min(1).optional(),
+    updateOrganizationResourceSchema = z4.object({
+      name: z4.string().min(1).optional(),
       kind: organizationResourceKindSchema.optional(),
-      locator: z6.string().min(1).optional(),
-      description: z6.string().optional().nullable(),
-      metadata: z6.record(z6.unknown()).optional().nullable()
+      locator: z4.string().min(1).optional(),
+      description: z4.string().optional().nullable(),
+      metadata: z4.record(z4.unknown()).optional().nullable()
     }).strict();
-    projectResourceAttachmentInputSchema = z6.object({
-      resourceId: z6.string().uuid(),
+    projectResourceAttachmentInputSchema = z4.object({
+      resourceId: z4.string().uuid(),
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
-    updateProjectResourceAttachmentSchema = z6.object({
+    updateProjectResourceAttachmentSchema = z4.object({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
     createProjectInlineResourceSchema = createOrganizationResourceSchema.extend({
       role: projectResourceAttachmentRoleSchema.optional(),
-      note: z6.string().optional().nullable(),
-      sortOrder: z6.number().int().nonnegative().optional()
+      note: z4.string().optional().nullable(),
+      sortOrder: z4.number().int().nonnegative().optional()
     }).strict();
   }
 });
 
 // ../packages/shared/src/validators/chat.ts
-import { z as z7 } from "zod";
+import { z as z5 } from "zod";
 var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, createChatContextLinkSchema, createChatConversationSchema, setChatProjectContextSchema, updateChatConversationSchema, addChatMessageSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema;
 var init_chat = __esm({
   "../packages/shared/src/validators/chat.ts"() {
     "use strict";
     init_constants();
-    chatConversationStatusSchema = z7.enum(CHAT_CONVERSATION_STATUSES);
-    chatIssueCreationModeSchema = z7.enum(CHAT_ISSUE_CREATION_MODES);
-    chatMessageRoleSchema = z7.enum(CHAT_MESSAGE_ROLES);
-    chatMessageKindSchema = z7.enum(CHAT_MESSAGE_KINDS);
-    chatMessageStatusSchema = z7.enum(CHAT_MESSAGE_STATUSES);
-    chatContextEntityTypeSchema = z7.enum(CHAT_CONTEXT_ENTITY_TYPES);
-    createChatContextLinkSchema = z7.object({
+    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: z7.string().min(1),
-      metadata: z7.record(z7.unknown()).optional().nullable()
+      entityId: z5.string().min(1),
+      metadata: z5.record(z5.unknown()).optional().nullable()
     });
-    createChatConversationSchema = z7.object({
-      title: z7.string().trim().min(1).max(200).optional(),
-      summary: z7.string().trim().max(5e3).optional().nullable(),
-      preferredAgentId: z7.string().uuid().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: z7.boolean().optional(),
-      contextLinks: z7.array(createChatContextLinkSchema).optional().default([])
+      planMode: z5.boolean().optional(),
+      contextLinks: z5.array(createChatContextLinkSchema).optional().default([])
     });
-    setChatProjectContextSchema = z7.object({
-      projectId: z7.string().uuid().optional().nullable()
+    setChatProjectContextSchema = z5.object({
+      projectId: z5.string().uuid().optional().nullable()
     });
     updateChatConversationSchema = createChatConversationSchema.partial().extend({
       status: chatConversationStatusSchema.optional(),
-      routedAgentId: z7.string().uuid().optional().nullable(),
-      primaryIssueId: z7.string().uuid().optional().nullable(),
-      resolvedAt: z7.string().datetime().optional().nullable()
+      routedAgentId: z5.string().uuid().optional().nullable(),
+      primaryIssueId: z5.string().uuid().optional().nullable(),
+      resolvedAt: z5.string().datetime().optional().nullable()
     });
-    addChatMessageSchema = z7.object({
-      body: z7.string().trim().min(1).max(2e4),
-      editUserMessageId: z7.string().uuid().optional().nullable()
+    addChatMessageSchema = z5.object({
+      body: z5.string().trim().min(1).max(2e4),
+      editUserMessageId: z5.string().uuid().optional().nullable()
     });
-    createChatAttachmentMetadataSchema = z7.object({
-      messageId: z7.string().uuid()
+    createChatAttachmentMetadataSchema = z5.object({
+      messageId: z5.string().uuid()
     });
-    chatIssueProposalSchema = z7.object({
-      title: z7.string().trim().min(1).max(200),
-      description: z7.string().trim().min(1).max(2e4),
-      priority: z7.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
-      projectId: z7.string().uuid().optional().nullable(),
-      goalId: z7.string().uuid().optional().nullable(),
-      parentId: z7.string().uuid().optional().nullable(),
-      assigneeAgentId: z7.string().uuid().optional().nullable(),
-      assigneeUserId: z7.string().trim().optional().nullable()
+    chatIssueProposalSchema = z5.object({
+      title: z5.string().trim().min(1).max(200),
+      description: z5.string().trim().min(1).max(2e4),
+      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()
     });
-    convertChatToIssueSchema = z7.object({
-      messageId: z7.string().uuid().optional().nullable(),
+    convertChatToIssueSchema = z5.object({
+      messageId: z5.string().uuid().optional().nullable(),
       proposal: chatIssueProposalSchema.optional()
     });
-    chatOperationProposalSchema = z7.object({
-      targetType: z7.enum(["organization", "agent"]),
-      targetId: z7.string().min(1),
-      summary: z7.string().trim().min(1).max(500),
-      patch: z7.record(z7.unknown())
+    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 = z7.object({
-      action: z7.enum(["approve", "reject", "requestRevision"]),
-      decisionNote: z7.string().trim().max(5e3).optional().nullable()
+    resolveChatOperationProposalSchema = z5.object({
+      action: z5.enum(["approve", "reject", "requestRevision"]),
+      decisionNote: z5.string().trim().max(5e3).optional().nullable()
     });
-    updateChatConversationUserStateSchema = z7.object({
-      pinned: z7.boolean().optional()
+    updateChatConversationUserStateSchema = z5.object({
+      pinned: z5.boolean().optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-skill.ts
-import { z as z8 } from "zod";
+import { z as z6 } from "zod";
 var organizationSkillSourceTypeSchema, organizationSkillTrustLevelSchema, organizationSkillCompatibilitySchema, organizationSkillSourceBadgeSchema, organizationSkillFileInventoryEntrySchema, organizationSkillSchema, organizationSkillListItemSchema, organizationSkillUsageAgentSchema, organizationSkillDetailSchema, organizationSkillUpdateStatusSchema, organizationSkillImportSchema, organizationSkillProjectScanRequestSchema, organizationSkillProjectScanSkippedSchema, organizationSkillProjectScanConflictSchema, organizationSkillProjectScanResultSchema, organizationSkillLocalScanRequestSchema, organizationSkillLocalScanSkippedSchema, organizationSkillLocalScanConflictSchema, organizationSkillLocalScanResultSchema, organizationSkillCreateSchema, organizationSkillFileDetailSchema, organizationSkillFileUpdateSchema;
 var init_organization_skill = __esm({
   "../packages/shared/src/validators/organization-skill.ts"() {
     "use strict";
-    organizationSkillSourceTypeSchema = z8.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
-    organizationSkillTrustLevelSchema = z8.enum(["markdown_only", "assets", "scripts_executables"]);
-    organizationSkillCompatibilitySchema = z8.enum(["compatible", "unknown", "invalid"]);
-    organizationSkillSourceBadgeSchema = z8.enum([
+    organizationSkillSourceTypeSchema = z6.enum(["local_path", "github", "url", "catalog", "skills_sh"]);
+    organizationSkillTrustLevelSchema = z6.enum(["markdown_only", "assets", "scripts_executables"]);
+    organizationSkillCompatibilitySchema = z6.enum(["compatible", "unknown", "invalid"]);
+    organizationSkillSourceBadgeSchema = z6.enum([
       "rudder",
       "community",
       "github",
@@ -799,157 +667,157 @@ var init_organization_skill = __esm({
       "catalog",
       "skills_sh"
     ]);
-    organizationSkillFileInventoryEntrySchema = z8.object({
-      path: z8.string().min(1),
-      kind: z8.enum(["skill", "markdown", "reference", "script", "asset", "other"])
+    organizationSkillFileInventoryEntrySchema = z6.object({
+      path: z6.string().min(1),
+      kind: z6.enum(["skill", "markdown", "reference", "script", "asset", "other"])
     });
-    organizationSkillSchema = z8.object({
-      id: z8.string().uuid(),
-      orgId: z8.string().uuid(),
-      key: z8.string().min(1),
-      slug: z8.string().min(1),
-      name: z8.string().min(1),
-      description: z8.string().nullable(),
-      markdown: z8.string(),
+    organizationSkillSchema = z6.object({
+      id: z6.string().uuid(),
+      orgId: z6.string().uuid(),
+      key: z6.string().min(1),
+      slug: z6.string().min(1),
+      name: z6.string().min(1),
+      description: z6.string().nullable(),
+      markdown: z6.string(),
       sourceType: organizationSkillSourceTypeSchema,
-      sourceLocator: z8.string().nullable(),
-      sourceRef: z8.string().nullable(),
+      sourceLocator: z6.string().nullable(),
+      sourceRef: z6.string().nullable(),
       trustLevel: organizationSkillTrustLevelSchema,
       compatibility: organizationSkillCompatibilitySchema,
-      fileInventory: z8.array(organizationSkillFileInventoryEntrySchema).default([]),
-      metadata: z8.record(z8.unknown()).nullable(),
-      createdAt: z8.coerce.date(),
-      updatedAt: z8.coerce.date()
+      fileInventory: z6.array(organizationSkillFileInventoryEntrySchema).default([]),
+      metadata: z6.record(z6.unknown()).nullable(),
+      createdAt: z6.coerce.date(),
+      updatedAt: z6.coerce.date()
     });
     organizationSkillListItemSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z8.number().int().nonnegative(),
-      editable: z8.boolean(),
-      editableReason: z8.string().nullable(),
-      sourceLabel: z8.string().nullable(),
+      attachedAgentCount: z6.number().int().nonnegative(),
+      editable: z6.boolean(),
+      editableReason: z6.string().nullable(),
+      sourceLabel: z6.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z8.string().nullable(),
-      workspaceEditPath: z8.string().nullable()
+      sourcePath: z6.string().nullable(),
+      workspaceEditPath: z6.string().nullable()
     });
-    organizationSkillUsageAgentSchema = z8.object({
-      id: z8.string().uuid(),
-      name: z8.string().min(1),
-      urlKey: z8.string().min(1),
-      agentRuntimeType: z8.string().min(1),
-      desired: z8.boolean(),
-      actualState: z8.string().nullable()
+    organizationSkillUsageAgentSchema = z6.object({
+      id: z6.string().uuid(),
+      name: z6.string().min(1),
+      urlKey: z6.string().min(1),
+      agentRuntimeType: z6.string().min(1),
+      desired: z6.boolean(),
+      actualState: z6.string().nullable()
     });
     organizationSkillDetailSchema = organizationSkillSchema.extend({
-      attachedAgentCount: z8.number().int().nonnegative(),
-      usedByAgents: z8.array(organizationSkillUsageAgentSchema).default([]),
-      editable: z8.boolean(),
-      editableReason: z8.string().nullable(),
-      sourceLabel: z8.string().nullable(),
+      attachedAgentCount: z6.number().int().nonnegative(),
+      usedByAgents: z6.array(organizationSkillUsageAgentSchema).default([]),
+      editable: z6.boolean(),
+      editableReason: z6.string().nullable(),
+      sourceLabel: z6.string().nullable(),
       sourceBadge: organizationSkillSourceBadgeSchema,
-      sourcePath: z8.string().nullable(),
-      workspaceEditPath: z8.string().nullable()
+      sourcePath: z6.string().nullable(),
+      workspaceEditPath: z6.string().nullable()
     });
-    organizationSkillUpdateStatusSchema = z8.object({
-      supported: z8.boolean(),
-      reason: z8.string().nullable(),
-      trackingRef: z8.string().nullable(),
-      currentRef: z8.string().nullable(),
-      latestRef: z8.string().nullable(),
-      hasUpdate: z8.boolean()
+    organizationSkillUpdateStatusSchema = z6.object({
+      supported: z6.boolean(),
+      reason: z6.string().nullable(),
+      trackingRef: z6.string().nullable(),
+      currentRef: z6.string().nullable(),
+      latestRef: z6.string().nullable(),
+      hasUpdate: z6.boolean()
     });
-    organizationSkillImportSchema = z8.object({
-      source: z8.string().min(1)
+    organizationSkillImportSchema = z6.object({
+      source: z6.string().min(1)
     });
-    organizationSkillProjectScanRequestSchema = z8.object({
-      projectIds: z8.array(z8.string().uuid()).optional(),
-      workspaceIds: z8.array(z8.string().uuid()).optional()
+    organizationSkillProjectScanRequestSchema = z6.object({
+      projectIds: z6.array(z6.string().uuid()).optional(),
+      workspaceIds: z6.array(z6.string().uuid()).optional()
     });
-    organizationSkillProjectScanSkippedSchema = z8.object({
-      projectId: z8.string().uuid(),
-      projectName: z8.string().min(1),
-      workspaceId: z8.string().uuid().nullable(),
-      workspaceName: z8.string().nullable(),
-      path: z8.string().nullable(),
-      reason: z8.string().min(1)
+    organizationSkillProjectScanSkippedSchema = z6.object({
+      projectId: z6.string().uuid(),
+      projectName: z6.string().min(1),
+      workspaceId: z6.string().uuid().nullable(),
+      workspaceName: z6.string().nullable(),
+      path: z6.string().nullable(),
+      reason: z6.string().min(1)
     });
-    organizationSkillProjectScanConflictSchema = z8.object({
-      slug: z8.string().min(1),
-      key: z8.string().min(1),
-      projectId: z8.string().uuid(),
-      projectName: z8.string().min(1),
-      workspaceId: z8.string().uuid(),
-      workspaceName: z8.string().min(1),
-      path: z8.string().min(1),
-      existingSkillId: z8.string().uuid(),
-      existingSkillKey: z8.string().min(1),
-      existingSourceLocator: z8.string().nullable(),
-      reason: z8.string().min(1)
+    organizationSkillProjectScanConflictSchema = z6.object({
+      slug: z6.string().min(1),
+      key: z6.string().min(1),
+      projectId: z6.string().uuid(),
+      projectName: z6.string().min(1),
+      workspaceId: z6.string().uuid(),
+      workspaceName: z6.string().min(1),
+      path: z6.string().min(1),
+      existingSkillId: z6.string().uuid(),
+      existingSkillKey: z6.string().min(1),
+      existingSourceLocator: z6.string().nullable(),
+      reason: z6.string().min(1)
     });
-    organizationSkillProjectScanResultSchema = z8.object({
-      scannedProjects: z8.number().int().nonnegative(),
-      scannedWorkspaces: z8.number().int().nonnegative(),
-      discovered: z8.number().int().nonnegative(),
-      imported: z8.array(organizationSkillSchema),
-      updated: z8.array(organizationSkillSchema),
-      skipped: z8.array(organizationSkillProjectScanSkippedSchema),
-      conflicts: z8.array(organizationSkillProjectScanConflictSchema),
-      warnings: z8.array(z8.string())
+    organizationSkillProjectScanResultSchema = z6.object({
+      scannedProjects: z6.number().int().nonnegative(),
+      scannedWorkspaces: z6.number().int().nonnegative(),
+      discovered: z6.number().int().nonnegative(),
+      imported: z6.array(organizationSkillSchema),
+      updated: z6.array(organizationSkillSchema),
+      skipped: z6.array(organizationSkillProjectScanSkippedSchema),
+      conflicts: z6.array(organizationSkillProjectScanConflictSchema),
+      warnings: z6.array(z6.string())
     });
-    organizationSkillLocalScanRequestSchema = z8.object({
-      roots: z8.array(z8.string().min(1)).optional()
+    organizationSkillLocalScanRequestSchema = z6.object({
+      roots: z6.array(z6.string().min(1)).optional()
     });
-    organizationSkillLocalScanSkippedSchema = z8.object({
-      root: z8.string().min(1),
-      path: z8.string().nullable(),
-      reason: z8.string().min(1)
+    organizationSkillLocalScanSkippedSchema = z6.object({
+      root: z6.string().min(1),
+      path: z6.string().nullable(),
+      reason: z6.string().min(1)
     });
-    organizationSkillLocalScanConflictSchema = z8.object({
-      root: z8.string().min(1),
-      path: z8.string().min(1),
-      slug: z8.string().min(1),
-      key: z8.string().min(1),
-      existingSkillId: z8.string().uuid(),
-      existingSkillKey: z8.string().min(1),
-      existingSourceLocator: z8.string().nullable(),
-      reason: z8.string().min(1)
+    organizationSkillLocalScanConflictSchema = z6.object({
+      root: z6.string().min(1),
+      path: z6.string().min(1),
+      slug: z6.string().min(1),
+      key: z6.string().min(1),
+      existingSkillId: z6.string().uuid(),
+      existingSkillKey: z6.string().min(1),
+      existingSourceLocator: z6.string().nullable(),
+      reason: z6.string().min(1)
     });
-    organizationSkillLocalScanResultSchema = z8.object({
-      scannedRoots: z8.number().int().nonnegative(),
-      discovered: z8.number().int().nonnegative(),
-      imported: z8.array(organizationSkillSchema),
-      updated: z8.array(organizationSkillSchema),
-      skipped: z8.array(organizationSkillLocalScanSkippedSchema),
-      conflicts: z8.array(organizationSkillLocalScanConflictSchema),
-      warnings: z8.array(z8.string())
+    organizationSkillLocalScanResultSchema = z6.object({
+      scannedRoots: z6.number().int().nonnegative(),
+      discovered: z6.number().int().nonnegative(),
+      imported: z6.array(organizationSkillSchema),
+      updated: z6.array(organizationSkillSchema),
+      skipped: z6.array(organizationSkillLocalScanSkippedSchema),
+      conflicts: z6.array(organizationSkillLocalScanConflictSchema),
+      warnings: z6.array(z6.string())
     });
-    organizationSkillCreateSchema = z8.object({
-      name: z8.string().min(1),
-      slug: z8.string().min(1).nullable().optional(),
-      description: z8.string().nullable().optional(),
-      markdown: z8.string().nullable().optional()
+    organizationSkillCreateSchema = z6.object({
+      name: z6.string().min(1),
+      slug: z6.string().min(1).nullable().optional(),
+      description: z6.string().nullable().optional(),
+      markdown: z6.string().nullable().optional()
     });
-    organizationSkillFileDetailSchema = z8.object({
-      skillId: z8.string().uuid(),
-      path: z8.string().min(1),
-      kind: z8.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
-      content: z8.string(),
-      language: z8.string().nullable(),
-      markdown: z8.boolean(),
-      editable: z8.boolean()
+    organizationSkillFileDetailSchema = z6.object({
+      skillId: z6.string().uuid(),
+      path: z6.string().min(1),
+      kind: z6.enum(["skill", "markdown", "reference", "script", "asset", "other"]),
+      content: z6.string(),
+      language: z6.string().nullable(),
+      markdown: z6.boolean(),
+      editable: z6.boolean()
     });
-    organizationSkillFileUpdateSchema = z8.object({
-      path: z8.string().min(1),
-      content: z8.string()
+    organizationSkillFileUpdateSchema = z6.object({
+      path: z6.string().min(1),
+      content: z6.string()
     });
   }
 });
 
 // ../packages/shared/src/validators/adapter-skills.ts
-import { z as z9 } from "zod";
+import { z as z7 } from "zod";
 var agentSkillStateSchema, agentSkillOriginSchema, agentSkillSourceClassSchema, agentSkillSyncModeSchema, agentSkillEntrySchema, agentSkillSnapshotSchema, agentSkillSyncSchema;
 var init_adapter_skills = __esm({
   "../packages/shared/src/validators/adapter-skills.ts"() {
     "use strict";
-    agentSkillStateSchema = z9.enum([
+    agentSkillStateSchema = z7.enum([
       "available",
       "configured",
       "installed",
@@ -957,274 +825,398 @@ var init_adapter_skills = __esm({
       "stale",
       "external"
     ]);
-    agentSkillOriginSchema = z9.preprocess((value) => {
+    agentSkillOriginSchema = z7.preprocess((value) => {
       if (value === "company_managed") return "organization_managed";
       return value;
-    }, z9.enum([
+    }, z7.enum([
       "organization_managed",
       "user_installed",
       "external_unknown"
     ]));
-    agentSkillSourceClassSchema = z9.enum([
+    agentSkillSourceClassSchema = z7.enum([
       "bundled",
       "organization",
       "agent_home",
       "global",
       "adapter_home"
     ]);
-    agentSkillSyncModeSchema = z9.enum([
+    agentSkillSyncModeSchema = z7.enum([
       "unsupported",
       "persistent",
       "ephemeral"
     ]);
-    agentSkillEntrySchema = z9.object({
-      key: z9.string().min(1),
-      selectionKey: z9.string().min(1),
-      runtimeName: z9.string().min(1).nullable(),
-      description: z9.string().nullable().optional(),
-      desired: z9.boolean(),
-      configurable: z9.boolean(),
-      alwaysEnabled: z9.boolean(),
-      managed: z9.boolean(),
+    agentSkillEntrySchema = z7.object({
+      key: z7.string().min(1),
+      selectionKey: z7.string().min(1),
+      runtimeName: z7.string().min(1).nullable(),
+      description: z7.string().nullable().optional(),
+      desired: z7.boolean(),
+      configurable: z7.boolean(),
+      alwaysEnabled: z7.boolean(),
+      managed: z7.boolean(),
       state: agentSkillStateSchema,
       sourceClass: agentSkillSourceClassSchema,
       origin: agentSkillOriginSchema.optional(),
-      originLabel: z9.string().nullable().optional(),
-      locationLabel: z9.string().nullable().optional(),
-      readOnly: z9.boolean().optional(),
-      sourcePath: z9.string().nullable().optional(),
-      targetPath: z9.string().nullable().optional(),
-      workspaceEditPath: z9.string().nullable().optional(),
-      detail: z9.string().nullable().optional()
+      originLabel: z7.string().nullable().optional(),
+      locationLabel: z7.string().nullable().optional(),
+      readOnly: z7.boolean().optional(),
+      sourcePath: z7.string().nullable().optional(),
+      targetPath: z7.string().nullable().optional(),
+      workspaceEditPath: z7.string().nullable().optional(),
+      detail: z7.string().nullable().optional()
     });
-    agentSkillSnapshotSchema = z9.object({
-      agentRuntimeType: z9.string().min(1),
-      supported: z9.boolean(),
+    agentSkillSnapshotSchema = z7.object({
+      agentRuntimeType: z7.string().min(1),
+      supported: z7.boolean(),
       mode: agentSkillSyncModeSchema,
-      desiredSkills: z9.array(z9.string().min(1)),
-      entries: z9.array(agentSkillEntrySchema),
-      warnings: z9.array(z9.string())
+      desiredSkills: z7.array(z7.string().min(1)),
+      entries: z7.array(agentSkillEntrySchema),
+      warnings: z7.array(z7.string())
     });
-    agentSkillSyncSchema = z9.object({
-      desiredSkills: z9.array(z9.string().min(1))
+    agentSkillSyncSchema = z7.object({
+      desiredSkills: z7.array(z7.string().min(1))
     });
   }
 });
 
 // ../packages/shared/src/validators/organization-portability.ts
-import { z as z10 } from "zod";
+import { z as z8 } from "zod";
 var portabilityIncludeSchema, portabilityEnvInputSchema, portabilityFileEntrySchema, portabilityOrganizationManifestEntrySchema, portabilitySidebarOrderSchema, portabilityAgentManifestEntrySchema, portabilitySkillManifestEntrySchema, portabilityProjectManifestEntrySchema, portabilityIssueAutomationTriggerManifestEntrySchema, portabilityIssueAutomationManifestEntrySchema, portabilityIssueManifestEntrySchema, portabilityManifestSchema, portabilitySourceSchema, portabilityTargetSchema, portabilityAgentSelectionSchema, portabilityCollisionStrategySchema, organizationPortabilityExportSchema, organizationPortabilityPreviewSchema, portabilityAdapterOverrideSchema, organizationPortabilityImportSchema;
 var init_organization_portability = __esm({
   "../packages/shared/src/validators/organization-portability.ts"() {
     "use strict";
-    portabilityIncludeSchema = z10.object({
-      organization: z10.boolean().optional(),
-      agents: z10.boolean().optional(),
-      projects: z10.boolean().optional(),
-      issues: z10.boolean().optional(),
-      skills: z10.boolean().optional()
+    portabilityIncludeSchema = z8.object({
+      organization: z8.boolean().optional(),
+      agents: z8.boolean().optional(),
+      projects: z8.boolean().optional(),
+      issues: z8.boolean().optional(),
+      skills: z8.boolean().optional()
     }).partial();
-    portabilityEnvInputSchema = z10.object({
-      key: z10.string().min(1),
-      description: z10.string().nullable(),
-      agentSlug: z10.string().min(1).nullable(),
-      kind: z10.enum(["secret", "plain"]),
-      requirement: z10.enum(["required", "optional"]),
-      defaultValue: z10.string().nullable(),
-      portability: z10.enum(["portable", "system_dependent"])
+    portabilityEnvInputSchema = z8.object({
+      key: z8.string().min(1),
+      description: z8.string().nullable(),
+      agentSlug: z8.string().min(1).nullable(),
+      kind: z8.enum(["secret", "plain"]),
+      requirement: z8.enum(["required", "optional"]),
+      defaultValue: z8.string().nullable(),
+      portability: z8.enum(["portable", "system_dependent"])
     });
-    portabilityFileEntrySchema = z10.union([
-      z10.string(),
-      z10.object({
-        encoding: z10.literal("base64"),
-        data: z10.string(),
-        contentType: z10.string().min(1).optional().nullable()
+    portabilityFileEntrySchema = z8.union([
+      z8.string(),
+      z8.object({
+        encoding: z8.literal("base64"),
+        data: z8.string(),
+        contentType: z8.string().min(1).optional().nullable()
       })
     ]);
-    portabilityOrganizationManifestEntrySchema = z10.object({
-      path: z10.string().min(1),
-      name: z10.string().min(1),
-      description: z10.string().nullable(),
-      brandColor: z10.string().nullable(),
-      logoPath: z10.string().nullable(),
-      requireBoardApprovalForNewAgents: z10.boolean()
+    portabilityOrganizationManifestEntrySchema = z8.object({
+      path: z8.string().min(1),
+      name: z8.string().min(1),
+      description: z8.string().nullable(),
+      brandColor: z8.string().nullable(),
+      logoPath: z8.string().nullable(),
+      requireBoardApprovalForNewAgents: z8.boolean()
     });
-    portabilitySidebarOrderSchema = z10.object({
-      agents: z10.array(z10.string().min(1)).default([]),
-      projects: z10.array(z10.string().min(1)).default([])
+    portabilitySidebarOrderSchema = z8.object({
+      agents: z8.array(z8.string().min(1)).default([]),
+      projects: z8.array(z8.string().min(1)).default([])
     });
-    portabilityAgentManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      skills: z10.array(z10.string().min(1)).default([]),
-      role: z10.string().min(1),
-      title: z10.string().nullable(),
-      icon: z10.string().nullable(),
-      capabilities: z10.string().nullable(),
-      reportsToSlug: z10.string().min(1).nullable(),
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()),
-      runtimeConfig: z10.record(z10.unknown()),
-      permissions: z10.record(z10.unknown()),
-      budgetMonthlyCents: z10.number().int().nonnegative(),
-      metadata: z10.record(z10.unknown()).nullable()
+    portabilityAgentManifestEntrySchema = z8.object({
+      slug: z8.string().min(1),
+      name: z8.string().min(1),
+      path: z8.string().min(1),
+      skills: z8.array(z8.string().min(1)).default([]),
+      role: z8.string().min(1),
+      title: z8.string().nullable(),
+      icon: z8.string().nullable(),
+      capabilities: z8.string().nullable(),
+      reportsToSlug: z8.string().min(1).nullable(),
+      agentRuntimeType: z8.string().min(1),
+      agentRuntimeConfig: z8.record(z8.unknown()),
+      runtimeConfig: z8.record(z8.unknown()),
+      permissions: z8.record(z8.unknown()),
+      budgetMonthlyCents: z8.number().int().nonnegative(),
+      metadata: z8.record(z8.unknown()).nullable()
     });
-    portabilitySkillManifestEntrySchema = z10.object({
-      key: z10.string().min(1),
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      sourceType: z10.string().min(1),
-      sourceLocator: z10.string().nullable(),
-      sourceRef: z10.string().nullable(),
-      trustLevel: z10.string().nullable(),
-      compatibility: z10.string().nullable(),
-      metadata: z10.record(z10.unknown()).nullable(),
-      fileInventory: z10.array(z10.object({
-        path: z10.string().min(1),
-        kind: z10.string().min(1)
+    portabilitySkillManifestEntrySchema = z8.object({
+      key: z8.string().min(1),
+      slug: z8.string().min(1),
+      name: z8.string().min(1),
+      path: z8.string().min(1),
+      description: z8.string().nullable(),
+      sourceType: z8.string().min(1),
+      sourceLocator: z8.string().nullable(),
+      sourceRef: z8.string().nullable(),
+      trustLevel: z8.string().nullable(),
+      compatibility: z8.string().nullable(),
+      metadata: z8.record(z8.unknown()).nullable(),
+      fileInventory: z8.array(z8.object({
+        path: z8.string().min(1),
+        kind: z8.string().min(1)
       })).default([])
     });
-    portabilityProjectManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      name: z10.string().min(1),
-      path: z10.string().min(1),
-      description: z10.string().nullable(),
-      ownerAgentSlug: z10.string().min(1).nullable(),
-      leadAgentSlug: z10.string().min(1).nullable(),
-      targetDate: z10.string().nullable(),
-      color: z10.string().nullable(),
-      status: z10.string().nullable(),
-      executionWorkspacePolicy: z10.record(z10.unknown()).nullable(),
-      workspaces: z10.array(z10.object({
-        key: z10.string().min(1),
-        name: z10.string().min(1),
-        sourceType: z10.string().nullable(),
-        repoUrl: z10.string().nullable(),
-        repoRef: z10.string().nullable(),
-        defaultRef: z10.string().nullable(),
-        visibility: z10.string().nullable(),
-        setupCommand: z10.string().nullable(),
-        cleanupCommand: z10.string().nullable(),
-        metadata: z10.record(z10.unknown()).nullable(),
-        isPrimary: z10.boolean()
+    portabilityProjectManifestEntrySchema = z8.object({
+      slug: z8.string().min(1),
+      name: z8.string().min(1),
+      path: z8.string().min(1),
+      description: z8.string().nullable(),
+      ownerAgentSlug: z8.string().min(1).nullable(),
+      leadAgentSlug: z8.string().min(1).nullable(),
+      targetDate: z8.string().nullable(),
+      color: z8.string().nullable(),
+      status: z8.string().nullable(),
+      executionWorkspacePolicy: z8.record(z8.unknown()).nullable(),
+      workspaces: z8.array(z8.object({
+        key: z8.string().min(1),
+        name: z8.string().min(1),
+        sourceType: z8.string().nullable(),
+        repoUrl: z8.string().nullable(),
+        repoRef: z8.string().nullable(),
+        defaultRef: z8.string().nullable(),
+        visibility: z8.string().nullable(),
+        setupCommand: z8.string().nullable(),
+        cleanupCommand: z8.string().nullable(),
+        metadata: z8.record(z8.unknown()).nullable(),
+        isPrimary: z8.boolean()
       })).default([]),
-      metadata: z10.record(z10.unknown()).nullable()
+      metadata: z8.record(z8.unknown()).nullable()
     });
-    portabilityIssueAutomationTriggerManifestEntrySchema = z10.object({
-      kind: z10.string().min(1),
-      label: z10.string().nullable(),
-      enabled: z10.boolean(),
-      cronExpression: z10.string().nullable(),
-      timezone: z10.string().nullable(),
-      signingMode: z10.string().nullable(),
-      replayWindowSec: z10.number().int().nullable()
+    portabilityIssueAutomationTriggerManifestEntrySchema = z8.object({
+      kind: z8.string().min(1),
+      label: z8.string().nullable(),
+      enabled: z8.boolean(),
+      cronExpression: z8.string().nullable(),
+      timezone: z8.string().nullable(),
+      signingMode: z8.string().nullable(),
+      replayWindowSec: z8.number().int().nullable()
     });
-    portabilityIssueAutomationManifestEntrySchema = z10.object({
-      concurrencyPolicy: z10.string().nullable(),
-      catchUpPolicy: z10.string().nullable(),
-      triggers: z10.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
+    portabilityIssueAutomationManifestEntrySchema = z8.object({
+      concurrencyPolicy: z8.string().nullable(),
+      catchUpPolicy: z8.string().nullable(),
+      triggers: z8.array(portabilityIssueAutomationTriggerManifestEntrySchema).default([])
     });
-    portabilityIssueManifestEntrySchema = z10.object({
-      slug: z10.string().min(1),
-      identifier: z10.string().min(1).nullable(),
-      title: z10.string().min(1),
-      path: z10.string().min(1),
-      projectSlug: z10.string().min(1).nullable(),
-      projectWorkspaceKey: z10.string().min(1).nullable(),
-      assigneeAgentSlug: z10.string().min(1).nullable(),
-      description: z10.string().nullable(),
-      recurring: z10.boolean().default(false),
+    portabilityIssueManifestEntrySchema = z8.object({
+      slug: z8.string().min(1),
+      identifier: z8.string().min(1).nullable(),
+      title: z8.string().min(1),
+      path: z8.string().min(1),
+      projectSlug: z8.string().min(1).nullable(),
+      projectWorkspaceKey: z8.string().min(1).nullable(),
+      assigneeAgentSlug: z8.string().min(1).nullable(),
+      description: z8.string().nullable(),
+      recurring: z8.boolean().default(false),
       automation: portabilityIssueAutomationManifestEntrySchema.nullable(),
-      legacyRecurrence: z10.record(z10.unknown()).nullable(),
-      status: z10.string().nullable(),
-      priority: z10.string().nullable(),
-      labelIds: z10.array(z10.string().min(1)).default([]),
-      billingCode: z10.string().nullable(),
-      executionWorkspaceSettings: z10.record(z10.unknown()).nullable(),
-      assigneeAgentRuntimeOverrides: z10.record(z10.unknown()).nullable(),
-      metadata: z10.record(z10.unknown()).nullable()
+      legacyRecurrence: z8.record(z8.unknown()).nullable(),
+      status: z8.string().nullable(),
+      priority: z8.string().nullable(),
+      labelIds: z8.array(z8.string().min(1)).default([]),
+      billingCode: z8.string().nullable(),
+      executionWorkspaceSettings: z8.record(z8.unknown()).nullable(),
+      assigneeAgentRuntimeOverrides: z8.record(z8.unknown()).nullable(),
+      metadata: z8.record(z8.unknown()).nullable()
     });
-    portabilityManifestSchema = z10.object({
-      schemaVersion: z10.number().int().positive(),
-      generatedAt: z10.string().datetime(),
-      source: z10.object({
-        orgId: z10.string().uuid(),
-        organizationName: z10.string().min(1)
+    portabilityManifestSchema = z8.object({
+      schemaVersion: z8.number().int().positive(),
+      generatedAt: z8.string().datetime(),
+      source: z8.object({
+        orgId: z8.string().uuid(),
+        organizationName: z8.string().min(1)
       }).nullable(),
-      includes: z10.object({
-        organization: z10.boolean(),
-        agents: z10.boolean(),
-        projects: z10.boolean(),
-        issues: z10.boolean(),
-        skills: z10.boolean()
+      includes: z8.object({
+        organization: z8.boolean(),
+        agents: z8.boolean(),
+        projects: z8.boolean(),
+        issues: z8.boolean(),
+        skills: z8.boolean()
       }),
       organization: portabilityOrganizationManifestEntrySchema.nullable(),
       sidebar: portabilitySidebarOrderSchema.nullable(),
-      agents: z10.array(portabilityAgentManifestEntrySchema),
-      skills: z10.array(portabilitySkillManifestEntrySchema).default([]),
-      projects: z10.array(portabilityProjectManifestEntrySchema).default([]),
-      issues: z10.array(portabilityIssueManifestEntrySchema).default([]),
-      envInputs: z10.array(portabilityEnvInputSchema).default([])
+      agents: z8.array(portabilityAgentManifestEntrySchema),
+      skills: z8.array(portabilitySkillManifestEntrySchema).default([]),
+      projects: z8.array(portabilityProjectManifestEntrySchema).default([]),
+      issues: z8.array(portabilityIssueManifestEntrySchema).default([]),
+      envInputs: z8.array(portabilityEnvInputSchema).default([])
     });
-    portabilitySourceSchema = z10.discriminatedUnion("type", [
-      z10.object({
-        type: z10.literal("inline"),
-        rootPath: z10.string().min(1).optional().nullable(),
-        files: z10.record(portabilityFileEntrySchema)
+    portabilitySourceSchema = z8.discriminatedUnion("type", [
+      z8.object({
+        type: z8.literal("inline"),
+        rootPath: z8.string().min(1).optional().nullable(),
+        files: z8.record(portabilityFileEntrySchema)
       }),
-      z10.object({
-        type: z10.literal("github"),
-        url: z10.string().url()
+      z8.object({
+        type: z8.literal("github"),
+        url: z8.string().url()
       })
     ]);
-    portabilityTargetSchema = z10.discriminatedUnion("mode", [
-      z10.object({
-        mode: z10.literal("new_organization"),
-        newOrganizationName: z10.string().min(1).optional().nullable()
+    portabilityTargetSchema = z8.discriminatedUnion("mode", [
+      z8.object({
+        mode: z8.literal("new_organization"),
+        newOrganizationName: z8.string().min(1).optional().nullable()
       }),
-      z10.object({
-        mode: z10.literal("existing_organization"),
-        orgId: z10.string().uuid()
+      z8.object({
+        mode: z8.literal("existing_organization"),
+        orgId: z8.string().uuid()
       })
     ]);
-    portabilityAgentSelectionSchema = z10.union([
-      z10.literal("all"),
-      z10.array(z10.string().min(1))
+    portabilityAgentSelectionSchema = z8.union([
+      z8.literal("all"),
+      z8.array(z8.string().min(1))
     ]);
-    portabilityCollisionStrategySchema = z10.enum(["rename", "skip", "replace"]);
-    organizationPortabilityExportSchema = z10.object({
+    portabilityCollisionStrategySchema = z8.enum(["rename", "skip", "replace"]);
+    organizationPortabilityExportSchema = z8.object({
       include: portabilityIncludeSchema.optional(),
-      agents: z10.array(z10.string().min(1)).optional(),
-      skills: z10.array(z10.string().min(1)).optional(),
-      projects: z10.array(z10.string().min(1)).optional(),
-      issues: z10.array(z10.string().min(1)).optional(),
-      projectIssues: z10.array(z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional(),
-      expandReferencedSkills: z10.boolean().optional(),
+      agents: z8.array(z8.string().min(1)).optional(),
+      skills: z8.array(z8.string().min(1)).optional(),
+      projects: z8.array(z8.string().min(1)).optional(),
+      issues: z8.array(z8.string().min(1)).optional(),
+      projectIssues: z8.array(z8.string().min(1)).optional(),
+      selectedFiles: z8.array(z8.string().min(1)).optional(),
+      expandReferencedSkills: z8.boolean().optional(),
       sidebarOrder: portabilitySidebarOrderSchema.partial().optional()
     });
-    organizationPortabilityPreviewSchema = z10.object({
+    organizationPortabilityPreviewSchema = z8.object({
       source: portabilitySourceSchema,
       include: portabilityIncludeSchema.optional(),
       target: portabilityTargetSchema,
       agents: portabilityAgentSelectionSchema.optional(),
       collisionStrategy: portabilityCollisionStrategySchema.optional(),
-      nameOverrides: z10.record(z10.string().min(1), z10.string().min(1)).optional(),
-      selectedFiles: z10.array(z10.string().min(1)).optional()
+      nameOverrides: z8.record(z8.string().min(1), z8.string().min(1)).optional(),
+      selectedFiles: z8.array(z8.string().min(1)).optional()
     });
-    portabilityAdapterOverrideSchema = z10.object({
-      agentRuntimeType: z10.string().min(1),
-      agentRuntimeConfig: z10.record(z10.unknown()).optional()
+    portabilityAdapterOverrideSchema = z8.object({
+      agentRuntimeType: z8.string().min(1),
+      agentRuntimeConfig: z8.record(z8.unknown()).optional()
     });
     organizationPortabilityImportSchema = organizationPortabilityPreviewSchema.extend({
-      agentRuntimeOverrides: z10.record(z10.string().min(1), portabilityAdapterOverrideSchema).optional()
+      agentRuntimeOverrides: z8.record(z8.string().min(1), portabilityAdapterOverrideSchema).optional()
     });
   }
 });
 
+// ../packages/shared/src/validators/secret.ts
+import { z as z9 } from "zod";
+var envBindingPlainSchema, envBindingSecretRefSchema, envBindingSchema, envConfigSchema, createSecretSchema, rotateSecretSchema, updateSecretSchema;
+var init_secret = __esm({
+  "../packages/shared/src/validators/secret.ts"() {
+    "use strict";
+    init_constants();
+    envBindingPlainSchema = z9.object({
+      type: z9.literal("plain"),
+      value: z9.string()
+    });
+    envBindingSecretRefSchema = z9.object({
+      type: z9.literal("secret_ref"),
+      secretId: z9.string().uuid(),
+      version: z9.union([z9.literal("latest"), z9.number().int().positive()]).optional()
+    });
+    envBindingSchema = z9.union([
+      z9.string(),
+      envBindingPlainSchema,
+      envBindingSecretRefSchema
+    ]);
+    envConfigSchema = z9.record(envBindingSchema);
+    createSecretSchema = z9.object({
+      name: z9.string().min(1),
+      provider: z9.enum(SECRET_PROVIDERS).optional(),
+      value: z9.string().min(1),
+      description: z9.string().optional().nullable(),
+      externalRef: z9.string().optional().nullable()
+    });
+    rotateSecretSchema = z9.object({
+      value: z9.string().min(1),
+      externalRef: z9.string().optional().nullable()
+    });
+    updateSecretSchema = z9.object({
+      name: z9.string().min(1).optional(),
+      description: z9.string().optional().nullable(),
+      externalRef: z9.string().optional().nullable()
+    });
+  }
+});
+
+// ../packages/shared/src/validators/model-fallbacks.ts
+import { z as z10 } from "zod";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateModelFallbacksConfig(value, ctx, pathPrefix) {
+  const fallbackModels = value.modelFallbacks;
+  if (fallbackModels === void 0) return;
+  if (!Array.isArray(fallbackModels)) {
+    ctx.addIssue({
+      code: z10.ZodIssueCode.custom,
+      message: "modelFallbacks must be an array",
+      path: [...pathPrefix, "modelFallbacks"]
+    });
+    return;
+  }
+  fallbackModels.forEach((fallback, index66) => {
+    if (typeof fallback === "string") {
+      if (fallback.trim().length === 0) {
+        ctx.addIssue({
+          code: z10.ZodIssueCode.custom,
+          message: "modelFallbacks string entries must be non-empty",
+          path: [...pathPrefix, "modelFallbacks", index66]
+        });
+      }
+      return;
+    }
+    if (!isRecord(fallback)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must be strings or runtime/model objects",
+        path: [...pathPrefix, "modelFallbacks", index66]
+      });
+      return;
+    }
+    if (typeof fallback.agentRuntimeType !== "string" || fallback.agentRuntimeType.trim().length === 0) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
+      });
+    } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include a valid agentRuntimeType",
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
+      });
+    }
+    if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entries must include model",
+        path: [...pathPrefix, "modelFallbacks", index66, "model"]
+      });
+    }
+    if (fallback.config !== void 0 && !isRecord(fallback.config)) {
+      ctx.addIssue({
+        code: z10.ZodIssueCode.custom,
+        message: "modelFallbacks entry config must be an object",
+        path: [...pathPrefix, "modelFallbacks", index66, "config"]
+      });
+    } else if (isRecord(fallback.config) && fallback.config.env !== void 0) {
+      const parsed = envConfigSchema.safeParse(fallback.config.env);
+      if (!parsed.success) {
+        ctx.addIssue({
+          code: z10.ZodIssueCode.custom,
+          message: "modelFallbacks entry config.env must be a map of valid env bindings",
+          path: [...pathPrefix, "modelFallbacks", index66, "config", "env"]
+        });
+      }
+    }
+  });
+}
+var agentRuntimeTypes;
+var init_model_fallbacks = __esm({
+  "../packages/shared/src/validators/model-fallbacks.ts"() {
+    "use strict";
+    init_constants();
+    init_secret();
+    agentRuntimeTypes = new Set(AGENT_RUNTIME_TYPES);
+  }
+});
+
 // ../packages/shared/src/validators/agent.ts
 import { z as z11 } from "zod";
 var agentPermissionsSchema, agentInstructionsBundleModeSchema, updateAgentInstructionsBundleSchema, upsertAgentInstructionsFileSchema, agentRuntimeConfigSchema, optionalAgentNameSchema, uploadedAgentIconSchema, customAgentIconSchema, agentIconSchema, createAgentSchema, createAgentHireSchema, updateAgentSchema, updateAgentInstructionsPathSchema, createAgentKeySchema, wakeAgentSchema, resetAgentSessionSchema, testAgentRuntimeEnvironmentSchema, updateAgentPermissionsSchema;
@@ -1321,7 +1313,7 @@ var init_agent = __esm({
       name: z11.string().min(1).default("default")
     });
     wakeAgentSchema = z11.object({
-      source: z11.enum(["timer", "assignment", "on_demand", "automation"]).optional().default("on_demand"),
+      source: z11.enum(["timer", "assignment", "review", "on_demand", "automation"]).optional().default("on_demand"),
       triggerDetail: z11.enum(["manual", "ping", "callback", "system"]).optional(),
       reason: z11.string().optional().nullable(),
       payload: z11.record(z11.unknown()).optional().nullable(),
@@ -1450,7 +1442,7 @@ var init_project = __esm({
 
 // ../packages/shared/src/validators/issue.ts
 import { z as z13 } from "zod";
-var executionWorkspaceStrategySchema2, issueExecutionWorkspaceSettingsSchema, issueAssigneeAdapterOverridesSchema, createIssueSchema, createIssueLabelSchema, updateIssueLabelSchema, updateIssueSchema, reorderIssueSchema, checkoutIssueSchema, addIssueCommentSchema, linkIssueApprovalSchema, createIssueAttachmentMetadataSchema, ISSUE_DOCUMENT_FORMATS, issueDocumentFormatSchema, issueDocumentKeySchema, upsertIssueDocumentSchema;
+var executionWorkspaceStrategySchema2, issueExecutionWorkspaceSettingsSchema, issueAssigneeAdapterOverridesSchema, createIssueSchema, createIssueLabelSchema, updateIssueLabelSchema, updateIssueSchema, reorderIssueSchema, checkoutIssueSchema, addIssueCommentSchema, linkIssueApprovalSchema, createIssueAttachmentMetadataSchema, createIssueWorkspaceAttachmentSchema, ISSUE_DOCUMENT_FORMATS, issueDocumentFormatSchema, issueDocumentKeySchema, upsertIssueDocumentSchema;
 var init_issue = __esm({
   "../packages/shared/src/validators/issue.ts"() {
     "use strict";
@@ -1483,6 +1475,8 @@ var init_issue = __esm({
       priority: z13.enum(ISSUE_PRIORITIES).optional().default("medium"),
       assigneeAgentId: z13.string().uuid().optional().nullable(),
       assigneeUserId: z13.string().optional().nullable(),
+      reviewerAgentId: z13.string().uuid().optional().nullable(),
+      reviewerUserId: z13.string().optional().nullable(),
       requestDepth: z13.number().int().nonnegative().optional().default(0),
       billingCode: z13.string().optional().nullable(),
       assigneeAgentRuntimeOverrides: issueAssigneeAdapterOverridesSchema.optional().nullable(),
@@ -1511,7 +1505,8 @@ var init_issue = __esm({
     updateIssueSchema = createIssueSchema.partial().extend({
       comment: z13.string().min(1).optional(),
       reopen: z13.boolean().optional(),
-      hiddenAt: z13.string().datetime().nullable().optional()
+      hiddenAt: z13.string().datetime().nullable().optional(),
+      reviewDecision: z13.enum(["approve", "request_changes", "needs_followup", "blocked"]).optional()
     });
     reorderIssueSchema = z13.object({
       issueId: z13.string().uuid(),
@@ -1541,6 +1536,9 @@ var init_issue = __esm({
       issueCommentId: z13.string().uuid().optional().nullable(),
       usage: z13.enum(["issue", "description_inline", "document_inline", "comment_inline", "comment_attachment"]).optional()
     });
+    createIssueWorkspaceAttachmentSchema = z13.object({
+      path: z13.string().trim().min(1).max(2048)
+    });
     ISSUE_DOCUMENT_FORMATS = ["markdown"];
     issueDocumentFormatSchema = z13.enum(ISSUE_DOCUMENT_FORMATS);
     issueDocumentKeySchema = z13.string().trim().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/, "Document key must be lowercase letters, numbers, _ or -");
@@ -3674,8 +3672,6 @@ var init_organizations = __esm({
         spentMonthlyCents: integer("spent_monthly_cents").notNull().default(0),
         requireBoardApprovalForNewAgents: boolean("require_board_approval_for_new_agents").notNull().default(true),
         defaultChatIssueCreationMode: text6("default_chat_issue_creation_mode").notNull().default("manual_approval"),
-        defaultChatAgentRuntimeType: text6("default_chat_agent_runtime_type"),
-        defaultChatAgentRuntimeConfig: jsonb("default_chat_agent_runtime_config").$type(),
         workspaceConfig: jsonb("workspace_config").$type(),
         brandColor: text6("brand_color"),
         createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
@@ -4777,6 +4773,8 @@ var init_issues = __esm({
         boardOrder: integer9("board_order").notNull().default(0),
         assigneeAgentId: uuid28("assignee_agent_id").references(() => agents.id),
         assigneeUserId: text34("assignee_user_id"),
+        reviewerAgentId: uuid28("reviewer_agent_id").references(() => agents.id),
+        reviewerUserId: text34("reviewer_user_id"),
         checkoutRunId: uuid28("checkout_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
         executionRunId: uuid28("execution_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
         executionAgentNameKey: text34("execution_agent_name_key"),
@@ -4818,6 +4816,16 @@ var init_issues = __esm({
           table.assigneeUserId,
           table.status
         ),
+        reviewerAgentStatusIdx: index25("issues_company_reviewer_agent_status_idx").on(
+          table.orgId,
+          table.reviewerAgentId,
+          table.status
+        ),
+        reviewerUserStatusIdx: index25("issues_company_reviewer_user_status_idx").on(
+          table.orgId,
+          table.reviewerUserId,
+          table.status
+        ),
         parentIdx: index25("issues_company_parent_idx").on(table.orgId, table.parentId),
         projectIdx: index25("issues_company_project_idx").on(table.orgId, table.projectId),
         originIdx: index25("issues_company_origin_idx").on(table.orgId, table.originKind, table.originId),
@@ -7688,8 +7696,8 @@ function pruneOldBackups(backupDir, retentionDays, filenamePrefix) {
   for (const name of readdirSync(backupDir)) {
     if (!name.startsWith(`${filenamePrefix}-`) || !name.endsWith(".sql")) continue;
     const fullPath = resolve2(backupDir, name);
-    const stat2 = statSync(fullPath);
-    if (stat2.mtimeMs < cutoff) {
+    const stat3 = statSync(fullPath);
+    if (stat3.mtimeMs < cutoff) {
       unlinkSync(fullPath);
       pruned++;
     }
@@ -10898,10 +10906,17 @@ async function removePathWithRetry(targetPath, attempts = 5) {
   }
   return false;
 }
-async function prepareForDesktopReplace(paths, target) {
+async function prepareForDesktopReplace(paths, target, options = {}) {
   const hasManagedExecutable = await pathExists(paths.executablePath);
   if (hasManagedExecutable) {
-    const quitResponse = await requestDesktopQuit(paths.executablePath, target);
+    let quitResponse = await requestDesktopQuit(paths.executablePath, target);
+    while (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs" && options.waitForActiveRuns) {
+      p13.log.warn(
+        `Rudder Desktop has ${quitResponse.totalRuns} active run${quitResponse.totalRuns === 1 ? "" : "s"}; waiting before replacing Desktop.`
+      );
+      await delay(options.activeRunPollIntervalMs ?? 15e3);
+      quitResponse = await requestDesktopQuit(paths.executablePath, target);
+    }
     if (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs") {
       throw new Error(
         `Rudder Desktop has ${quitResponse.totalRuns} active run${quitResponse.totalRuns === 1 ? "" : "s"}. Stop active work, then rerun start.`
@@ -11044,7 +11059,7 @@ async function startCommand(opts) {
   const installCli = opts.cli !== false;
   const installDesktop = opts.desktop !== false;
   const repo = opts.repo?.trim() || DEFAULT_DESKTOP_RELEASE_REPO;
-  const version = opts.version?.trim() || resolveCurrentCliVersion();
+  const version = opts.targetVersion?.trim() || opts.version?.trim() || resolveCurrentCliVersion();
   const dryRun = opts.dryRun === true;
   if (!installCli && !installDesktop) {
     throw new Error("Nothing to start. Remove --no-cli or --no-desktop.");
@@ -11136,7 +11151,7 @@ async function startCommand(opts) {
       await runStartPhase(
         "Replacing existing Rudder Desktop if needed...",
         "Existing Desktop install is ready for replacement.",
-        () => prepareForDesktopReplace(installPaths, target)
+        () => prepareForDesktopReplace(installPaths, target, { waitForActiveRuns: opts.waitForActiveRuns === true })
       );
       await runStartPhase(
         "Installing portable Desktop app...",
@@ -11376,8 +11391,8 @@ function printItemCompleted(item) {
     const changes = Array.isArray(item.changes) ? item.changes : [];
     const entries = changes.map((changeRaw) => asRecord(changeRaw)).filter((change) => Boolean(change)).map((change) => {
       const kind = asString(change.kind, "update");
-      const path23 = asString(change.path, "unknown");
-      return `${kind} ${path23}`;
+      const path24 = asString(change.path, "unknown");
+      return `${kind} ${path24}`;
     });
     const preview = entries.length > 0 ? entries.slice(0, 6).join(", ") : "none";
     const more = entries.length > 6 ? ` (+${entries.length - 6} more)` : "";
@@ -12558,40 +12573,46 @@ var RudderApiClient = class {
     this.runId = opts.runId?.trim() || void 0;
     this.recoverAuth = opts.recoverAuth;
   }
-  get(path23, opts) {
-    return this.request(path23, { method: "GET" }, opts);
+  get(path24, opts) {
+    return this.request(path24, { method: "GET" }, opts);
   }
-  post(path23, body, opts) {
-    return this.request(path23, {
+  post(path24, body, opts) {
+    return this.request(path24, {
       method: "POST",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  patch(path23, body, opts) {
-    return this.request(path23, {
+  postForm(path24, form, opts) {
+    return this.request(path24, {
+      method: "POST",
+      body: form
+    }, opts);
+  }
+  patch(path24, body, opts) {
+    return this.request(path24, {
       method: "PATCH",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  put(path23, body, opts) {
-    return this.request(path23, {
+  put(path24, body, opts) {
+    return this.request(path24, {
       method: "PUT",
       body: body === void 0 ? void 0 : JSON.stringify(body)
     }, opts);
   }
-  delete(path23, opts) {
-    return this.request(path23, { method: "DELETE" }, opts);
+  delete(path24, opts) {
+    return this.request(path24, { method: "DELETE" }, opts);
   }
   setApiKey(apiKey) {
     this.apiKey = apiKey?.trim() || void 0;
   }
-  async request(path23, init, opts, hasRetriedAuth = false) {
-    const url = buildUrl(this.apiBase, path23);
+  async request(path24, init, opts, hasRetriedAuth = false) {
+    const url = buildUrl(this.apiBase, path24);
     const headers = {
       accept: "application/json",
       ...toStringRecord(init.headers)
     };
-    if (init.body !== void 0) {
+    if (typeof init.body === "string") {
       headers["content-type"] = headers["content-type"] ?? "application/json";
     }
     if (this.apiKey) {
@@ -12611,13 +12632,13 @@ var RudderApiClient = class {
       const apiError = await toApiError(response);
       if (!hasRetriedAuth && this.recoverAuth) {
         const recoveredToken = await this.recoverAuth({
-          path: path23,
+          path: path24,
           method: String(init.method ?? "GET").toUpperCase(),
           error: apiError
         });
         if (recoveredToken) {
           this.setApiKey(recoveredToken);
-          return this.request(path23, init, opts, true);
+          return this.request(path24, init, opts, true);
         }
       }
       throw apiError;
@@ -12636,8 +12657,8 @@ function shouldAttachRunId(method) {
   const normalized = String(method ?? "GET").toUpperCase();
   return normalized !== "GET" && normalized !== "HEAD";
 }
-function buildUrl(apiBase, path23) {
-  const normalizedPath = path23.startsWith("/") ? path23 : `/${path23}`;
+function buildUrl(apiBase, path24) {
+  const normalizedPath = path24.startsWith("/") ? path24 : `/${path24}`;
   const [pathname, query] = normalizedPath.split("?");
   const url = new URL2(apiBase);
   url.pathname = `${url.pathname.replace(/\/+$/, "")}${pathname}`;
@@ -14484,6 +14505,8 @@ ${organizationUrl}`);
 
 // src/commands/client/issue.ts
 init_src();
+import { readFile as readFile5, stat as stat2 } from "node:fs/promises";
+import path16 from "node:path";
 
 // src/agent-v1-registry.ts
 var AGENT_CLI_CAPABILITIES = [
@@ -14503,7 +14526,7 @@ var AGENT_CLI_CAPABILITIES = [
     id: "agent.inbox",
     command: "rudder agent inbox",
     category: "agent",
-    description: "List the compact assigned-work inbox for the authenticated agent.",
+    description: "List the compact assignee and reviewer work inbox for the authenticated agent.",
     mutating: false,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -14669,9 +14692,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "issue.comment",
-    command: "rudder issue comment <issue> --body <text>",
+    command: "rudder issue comment <issue> --body <text> [--image <path>]",
     category: "issue",
-    description: "Add a comment to an issue.",
+    description: "Add a comment to an issue, optionally uploading images and appending Markdown image links.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -14705,9 +14728,21 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "issue.update",
-    command: "rudder issue update <issue> ...",
+    command: "rudder issue update <issue> ... [--image <path>]",
+    category: "issue",
+    description: "Apply generic issue updates when workflow commands are not enough, optionally uploading images for the update comment.",
+    mutating: true,
+    contract: "agent-v1",
+    requiresOrgId: false,
+    requiresAgentId: false,
+    requiresRunId: false,
+    attachesRunIdWhenAvailable: true
+  },
+  {
+    id: "issue.review",
+    command: "rudder issue review <issue> --decision <decision> --comment <text>",
     category: "issue",
-    description: "Apply generic issue updates when workflow commands are not enough.",
+    description: "Record a structured reviewer decision with a required comment.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -14717,9 +14752,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "issue.done",
-    command: "rudder issue done <issue> --comment <text>",
+    command: "rudder issue done <issue> --comment <text> [--image <path>]",
     category: "issue",
-    description: "Mark an issue done with a required completion comment.",
+    description: "Mark an issue done with a required completion comment, optionally uploading images.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -14729,9 +14764,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "issue.block",
-    command: "rudder issue block <issue> --comment <text>",
+    command: "rudder issue block <issue> --comment <text> [--image <path>]",
     category: "issue",
-    description: "Mark an issue blocked with a required blocker comment.",
+    description: "Mark an issue blocked with a required blocker comment, optionally uploading images.",
     mutating: true,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -15010,8 +15045,8 @@ function registerIssueCommands(program) {
         if (opts.assigneeAgentId) params.set("assigneeAgentId", opts.assigneeAgentId);
         if (opts.projectId) params.set("projectId", opts.projectId);
         const query = params.toString();
-        const path23 = `/api/orgs/${ctx.orgId}/issues${query ? `?${query}` : ""}`;
-        const rows = await ctx.api.get(path23) ?? [];
+        const path24 = `/api/orgs/${ctx.orgId}/issues${query ? `?${query}` : ""}`;
+        const rows = await ctx.api.get(path24) ?? [];
         const filtered = filterIssueRows(rows, opts.match);
         if (ctx.json) {
           printOutput(filtered, { json: true });
@@ -15092,9 +15127,10 @@ function registerIssueCommands(program) {
     { includeCompany: false }
   );
   addCommonClientOptions(
-    issue.command("update").description(getAgentCliCapabilityById("issue.update").description).argument("<issueId>", "Issue ID").option("--title <title>", "Issue title").option("--description <text>", "Issue description").option("--status <status>", "Issue status").option("--priority <priority>", "Issue priority").option("--assignee-agent-id <id>", "Assignee agent ID").option("--project-id <id>", "Project ID").option("--goal-id <id>", "Goal ID").option("--parent-id <id>", "Parent issue ID").option("--request-depth <n>", "Request depth integer").option("--billing-code <code>", "Billing code").option("--comment <text>", "Optional comment to add with update").option("--hidden-at <iso8601|null>", "Set hiddenAt timestamp or literal 'null'").action(async (issueId, opts) => {
+    issue.command("update").description(getAgentCliCapabilityById("issue.update").description).argument("<issueId>", "Issue ID").option("--title <title>", "Issue title").option("--description <text>", "Issue description").option("--status <status>", "Issue status").option("--priority <priority>", "Issue priority").option("--assignee-agent-id <id>", "Assignee agent ID").option("--project-id <id>", "Project ID").option("--goal-id <id>", "Goal ID").option("--parent-id <id>", "Parent issue ID").option("--request-depth <n>", "Request depth integer").option("--billing-code <code>", "Billing code").option("--comment <text>", "Optional comment to add with update").option("--image <path>", "Image file to upload and append to the update comment; may be repeated", collectImagePath, []).option("--hidden-at <iso8601|null>", "Set hiddenAt timestamp or literal 'null'").action(async (issueId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
+        const comment = await appendUploadedIssueImages(ctx, issueId, opts.comment, opts.image);
         const payload = updateIssueSchema.parse({
           title: opts.title,
           description: opts.description,
@@ -15106,7 +15142,7 @@ function registerIssueCommands(program) {
           parentId: opts.parentId,
           requestDepth: parseOptionalInt(opts.requestDepth),
           billingCode: opts.billingCode,
-          comment: opts.comment,
+          comment,
           hiddenAt: parseHiddenAt(opts.hiddenAt)
         });
         const updated = await ctx.api.patch(`/api/issues/${issueId}`, payload);
@@ -15117,11 +15153,12 @@ function registerIssueCommands(program) {
     })
   );
   addCommonClientOptions(
-    issue.command("comment").description(getAgentCliCapabilityById("issue.comment").description).argument("<issueId>", "Issue ID").requiredOption("--body <text>", "Comment body").option("--reopen", "Reopen if issue is done/cancelled").action(async (issueId, opts) => {
+    issue.command("comment").description(getAgentCliCapabilityById("issue.comment").description).argument("<issueId>", "Issue ID").requiredOption("--body <text>", "Comment body").option("--image <path>", "Image file to upload and append to the comment; may be repeated", collectImagePath, []).option("--reopen", "Reopen if issue is done/cancelled").action(async (issueId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
+        const body = await appendUploadedIssueImages(ctx, issueId, opts.body, opts.image);
         const payload = addIssueCommentSchema.parse({
-          body: opts.body,
+          body,
           reopen: opts.reopen
         });
         const comment = await ctx.api.post(`/api/issues/${issueId}/comments`, payload);
@@ -15132,11 +15169,15 @@ function registerIssueCommands(program) {
     })
   );
   addCommonClientOptions(
-    issue.command("done").description(getAgentCliCapabilityById("issue.done").description).argument("<issueId>", "Issue ID").requiredOption("--comment <text>", "Required completion comment").action(async (issueId, opts) => {
+    issue.command("review").description(getAgentCliCapabilityById("issue.review").description).argument("<issueId>", "Issue ID").requiredOption(
+      "--decision <decision>",
+      "Review decision: approve, request_changes, needs_followup, or blocked"
+    ).requiredOption("--comment <text>", "Required review comment").action(async (issueId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
+        const decision = parseReviewDecision(opts.decision);
         const updated = await ctx.api.patch(`/api/issues/${issueId}`, {
-          status: "done",
+          reviewDecision: decision,
           comment: opts.comment
         });
         printOutput(updated, { json: ctx.json });
@@ -15146,12 +15187,28 @@ function registerIssueCommands(program) {
     })
   );
   addCommonClientOptions(
-    issue.command("block").description(getAgentCliCapabilityById("issue.block").description).argument("<issueId>", "Issue ID").requiredOption("--comment <text>", "Required blocker comment").action(async (issueId, opts) => {
+    issue.command("done").description(getAgentCliCapabilityById("issue.done").description).argument("<issueId>", "Issue ID").requiredOption("--comment <text>", "Required completion comment").option("--image <path>", "Image file to upload and append to the completion comment; may be repeated", collectImagePath, []).action(async (issueId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
+        const comment = await appendUploadedIssueImages(ctx, issueId, opts.comment, opts.image);
+        const updated = await ctx.api.patch(`/api/issues/${issueId}`, {
+          status: "done",
+          comment
+        });
+        printOutput(updated, { json: ctx.json });
+      } catch (err) {
+        handleCommandError(err);
+      }
+    })
+  );
+  addCommonClientOptions(
+    issue.command("block").description(getAgentCliCapabilityById("issue.block").description).argument("<issueId>", "Issue ID").requiredOption("--comment <text>", "Required blocker comment").option("--image <path>", "Image file to upload and append to the blocker comment; may be repeated", collectImagePath, []).action(async (issueId, opts) => {
+      try {
+        const ctx = resolveCommandContext(opts);
+        const comment = await appendUploadedIssueImages(ctx, issueId, opts.comment, opts.image);
         const updated = await ctx.api.patch(`/api/issues/${issueId}`, {
           status: "blocked",
-          comment: opts.comment
+          comment
         });
         printOutput(updated, { json: ctx.json });
       } catch (err) {
@@ -15275,6 +15332,80 @@ function registerIssueCommands(program) {
     })
   );
 }
+function collectImagePath(value, previous) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("--image path cannot be empty");
+  }
+  return [...previous, trimmed];
+}
+async function appendUploadedIssueImages(ctx, issueId, body, imagePaths) {
+  const paths = imagePaths ?? [];
+  if (paths.length === 0) return body;
+  const issue = await ctx.api.get(`/api/issues/${issueId}`);
+  if (!issue) {
+    throw new Error("Issue not found");
+  }
+  const links = [];
+  for (const imagePath of paths) {
+    const attachment = await uploadIssueCommentImage(ctx, issue, imagePath);
+    links.push(formatAttachmentMarkdown(attachment));
+  }
+  const base = body?.trimEnd() ?? "";
+  const imageBlock = links.join("\n");
+  return base ? `${base}
+
+${imageBlock}` : imageBlock;
+}
+async function uploadIssueCommentImage(ctx, issue, imagePath) {
+  const resolvedPath = path16.resolve(process.cwd(), imagePath);
+  const stats = await stat2(resolvedPath).catch((err) => {
+    throw new Error(`Unable to read image ${imagePath}: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  if (!stats.isFile()) {
+    throw new Error(`Image path must be a file: ${imagePath}`);
+  }
+  const filename = path16.basename(resolvedPath);
+  const contentType = inferCommentImageContentType(filename);
+  const buffer = await readFile5(resolvedPath);
+  if (buffer.length <= 0) {
+    throw new Error(`Image is empty: ${imagePath}`);
+  }
+  const form = new FormData();
+  form.set("usage", "comment_inline");
+  form.set("file", new Blob([buffer], { type: contentType }), filename);
+  const attachment = await ctx.api.postForm(
+    `/api/orgs/${issue.orgId}/issues/${issue.id}/attachments`,
+    form
+  );
+  if (!attachment) {
+    throw new Error(`Image upload returned no attachment: ${imagePath}`);
+  }
+  return attachment;
+}
+function inferCommentImageContentType(filename) {
+  const ext = path16.extname(filename).toLowerCase();
+  switch (ext) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    default:
+      throw new Error(`Unsupported comment image type: ${filename}. Use PNG, JPEG, WebP, or GIF.`);
+  }
+}
+function formatAttachmentMarkdown(attachment) {
+  const alt = escapeMarkdownAltText(attachment.originalFilename ?? "image");
+  return `![${alt}](${attachment.contentPath})`;
+}
+function escapeMarkdownAltText(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll("]", "\\]");
+}
 function parseCsv(value) {
   if (!value) return [];
   return value.split(",").map((v) => v.trim()).filter(Boolean);
@@ -15292,6 +15423,13 @@ function parseHiddenAt(value) {
   if (value.trim().toLowerCase() === "null") return null;
   return value;
 }
+function parseReviewDecision(value) {
+  const normalized = value.trim();
+  if (normalized === "approve" || normalized === "request_changes" || normalized === "needs_followup" || normalized === "blocked") {
+    return normalized;
+  }
+  throw new Error("Invalid review decision. Use approve, request_changes, needs_followup, or blocked.");
+}
 function filterIssueRows(rows, match) {
   if (!match?.trim()) return rows;
   const needle = match.trim().toLowerCase();
@@ -15306,7 +15444,7 @@ init_src();
 
 // ../packages/agent-runtime-utils/src/server-utils.ts
 import { constants as fsConstants2, promises as fs12 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
 var MAX_EXCERPT_BYTES = 32 * 1024;
 var RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES = [
@@ -15354,8 +15492,8 @@ var RUDDER_AGENT_OPERATING_CONTRACT = [
 ].join("\n");
 async function resolveRudderSkillsDir(moduleDir, additionalCandidates = []) {
   const candidates = [
-    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path16.resolve(moduleDir, relativePath)),
-    ...additionalCandidates.map((candidate) => path16.resolve(candidate))
+    ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path17.resolve(moduleDir, relativePath)),
+    ...additionalCandidates.map((candidate) => path17.resolve(candidate))
   ];
   const seenRoots = /* @__PURE__ */ new Set();
   for (const root of candidates) {
@@ -15373,12 +15511,12 @@ async function removeMaintainerOnlySkillSymlinks(skillsHome, allowedSkillNames)
     const removed = [];
     for (const entry of entries) {
       if (allowed.has(entry.name)) continue;
-      const target = path16.join(skillsHome, entry.name);
+      const target = path17.join(skillsHome, entry.name);
       const existing = await fs12.lstat(target).catch(() => null);
       if (!existing?.isSymbolicLink()) continue;
       const linkedPath = await fs12.readlink(target).catch(() => null);
       if (!linkedPath) continue;
-      const resolvedLinkedPath = path16.isAbsolute(linkedPath) ? linkedPath : path16.resolve(path16.dirname(target), linkedPath);
+      const resolvedLinkedPath = path17.isAbsolute(linkedPath) ? linkedPath : path17.resolve(path17.dirname(target), linkedPath);
       if (!isMaintainerOnlySkillTarget(linkedPath) && !isMaintainerOnlySkillTarget(resolvedLinkedPath)) {
         continue;
       }
@@ -15394,18 +15532,18 @@ async function removeMaintainerOnlySkillSymlinks(skillsHome, allowedSkillNames)
 // src/commands/client/agent.ts
 import fs13 from "node:fs/promises";
 import os2 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-var __moduleDir = path17.dirname(fileURLToPath4(import.meta.url));
+var __moduleDir = path18.dirname(fileURLToPath4(import.meta.url));
 function codexSkillsHome() {
   const fromEnv = process.env.CODEX_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path17.join(os2.homedir(), ".codex");
-  return path17.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path18.join(os2.homedir(), ".codex");
+  return path18.join(base, "skills");
 }
 function claudeSkillsHome() {
   const fromEnv = process.env.CLAUDE_HOME?.trim();
-  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path17.join(os2.homedir(), ".claude");
-  return path17.join(base, "skills");
+  const base = fromEnv && fromEnv.length > 0 ? fromEnv : path18.join(os2.homedir(), ".claude");
+  return path18.join(base, "skills");
 }
 async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   const summary = {
@@ -15424,8 +15562,8 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
   );
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const source = path17.join(sourceSkillsDir, entry.name);
-    const target = path17.join(targetSkillsDir, entry.name);
+    const source = path18.join(sourceSkillsDir, entry.name);
+    const target = path18.join(targetSkillsDir, entry.name);
     const existing = await fs13.lstat(target).catch(() => null);
     if (existing) {
       if (existing.isSymbolicLink()) {
@@ -15446,7 +15584,7 @@ async function installSkillsForTarget(sourceSkillsDir, targetSkillsDir, tool) {
             continue;
           }
         }
-        const resolvedLinkedPath = path17.isAbsolute(linkedPath) ? linkedPath : path17.resolve(path17.dirname(target), linkedPath);
+        const resolvedLinkedPath = path18.isAbsolute(linkedPath) ? linkedPath : path18.resolve(path18.dirname(target), linkedPath);
         const linkedTargetExists = await fs13.stat(resolvedLinkedPath).then(() => true).catch(() => false);
         if (!linkedTargetExists) {
           await fs13.unlink(target);
@@ -15512,6 +15650,7 @@ function registerAgentCommands(program) {
             formatInlineRecord({
               identifier: row.identifier,
               id: row.id,
+              relationship: row.relationship ?? "assignee",
               status: row.status,
               priority: row.priority,
               title: row.title,
@@ -15726,7 +15865,7 @@ function registerAgentCommands(program) {
         }
         const installSummaries = [];
         if (opts.installSkills !== false) {
-          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path17.resolve(process.cwd(), "skills")]);
+          const skillsDir = await resolveRudderSkillsDir(__moduleDir, [path18.resolve(process.cwd(), "skills")]);
           if (!skillsDir) {
             throw new Error(
               "Could not locate local Rudder skills directory. Expected ./skills in the repo checkout."
@@ -15983,8 +16122,8 @@ function registerActivityCommands(program) {
         if (opts.entityType) params.set("entityType", opts.entityType);
         if (opts.entityId) params.set("entityId", opts.entityId);
         const query = params.toString();
-        const path23 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
-        const rows = await ctx.api.get(path23) ?? [];
+        const path24 = `/api/orgs/${ctx.orgId}/activity${query ? `?${query}` : ""}`;
+        const rows = await ctx.api.get(path24) ?? [];
         if (ctx.json) {
           printOutput(rows, { json: true });
           return;
@@ -16153,11 +16292,11 @@ function parseCsv4(value) {
 
 // src/config/data-dir.ts
 init_home();
-import path18 from "node:path";
+import path19 from "node:path";
 function applyDataDirOverride(options, support = {}) {
   const rawDataDir = options.dataDir?.trim();
   if (!rawDataDir) return null;
-  const resolvedDataDir = path18.resolve(expandHomePrefix(rawDataDir));
+  const resolvedDataDir = path19.resolve(expandHomePrefix(rawDataDir));
   process.env.RUDDER_HOME = resolvedDataDir;
   if (support.hasConfigOption) {
     const hasConfigOverride = Boolean(options.config?.trim()) || Boolean(process.env.RUDDER_CONFIG?.trim());
@@ -16202,7 +16341,7 @@ import {
   writeFileSync
 } from "node:fs";
 import os3 from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { createServer } from "node:net";
 import { Readable as Readable2 } from "node:stream";
@@ -16213,7 +16352,7 @@ import { and as and2, eq as eq2, inArray, sql as sql3 } from "drizzle-orm";
 // src/commands/worktree-lib.ts
 init_home();
 import { randomInt } from "node:crypto";
-import path19 from "node:path";
+import path20 from "node:path";
 var DEFAULT_WORKTREE_HOME = "~/.rudder-worktrees";
 var WORKTREE_SEED_MODES = ["minimal", "full"];
 var MINIMAL_WORKTREE_EXCLUDED_TABLES = [
@@ -16261,7 +16400,7 @@ function sanitizeWorktreeInstanceId(rawValue) {
   return normalized || "worktree";
 }
 function resolveSuggestedWorktreeName(cwd, explicitName) {
-  return nonEmpty(explicitName) ?? path19.basename(path19.resolve(cwd));
+  return nonEmpty(explicitName) ?? path20.basename(path20.resolve(cwd));
 }
 function hslComponentToHex(n) {
   return Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
@@ -16301,24 +16440,24 @@ function generateWorktreeColor() {
   return hslToHex(randomInt(0, 360), 68, 56);
 }
 function resolveWorktreeLocalPaths(opts) {
-  const cwd = path19.resolve(opts.cwd);
-  const homeDir = path19.resolve(expandHomePrefix(opts.homeDir ?? DEFAULT_WORKTREE_HOME));
-  const instanceRoot = path19.resolve(homeDir, "instances", opts.instanceId);
-  const repoConfigDir = path19.resolve(cwd, ".rudder");
+  const cwd = path20.resolve(opts.cwd);
+  const homeDir = path20.resolve(expandHomePrefix(opts.homeDir ?? DEFAULT_WORKTREE_HOME));
+  const instanceRoot = path20.resolve(homeDir, "instances", opts.instanceId);
+  const repoConfigDir = path20.resolve(cwd, ".rudder");
   return {
     cwd,
     repoConfigDir,
-    configPath: path19.resolve(repoConfigDir, "config.json"),
-    envPath: path19.resolve(repoConfigDir, ".env"),
+    configPath: path20.resolve(repoConfigDir, "config.json"),
+    envPath: path20.resolve(repoConfigDir, ".env"),
     homeDir,
     instanceId: opts.instanceId,
     instanceRoot,
-    contextPath: path19.resolve(homeDir, "context.json"),
-    embeddedPostgresDataDir: path19.resolve(instanceRoot, "db"),
-    backupDir: path19.resolve(instanceRoot, "data", "backups"),
-    logDir: path19.resolve(instanceRoot, "logs"),
-    secretsKeyFilePath: path19.resolve(instanceRoot, "secrets", "master.key"),
-    storageDir: path19.resolve(instanceRoot, "data", "storage")
+    contextPath: path20.resolve(homeDir, "context.json"),
+    embeddedPostgresDataDir: path20.resolve(instanceRoot, "db"),
+    backupDir: path20.resolve(instanceRoot, "data", "backups"),
+    logDir: path20.resolve(instanceRoot, "logs"),
+    secretsKeyFilePath: path20.resolve(instanceRoot, "secrets", "master.key"),
+    storageDir: path20.resolve(instanceRoot, "data", "storage")
   };
 }
 function rewriteLocalUrlPort(rawUrl, port) {
@@ -16842,7 +16981,7 @@ function isCurrentSourceConfigPath(sourceConfigPath) {
   if (!currentConfigPath || currentConfigPath.trim().length === 0) {
     return false;
   }
-  return path20.resolve(currentConfigPath) === path20.resolve(sourceConfigPath);
+  return path21.resolve(currentConfigPath) === path21.resolve(sourceConfigPath);
 }
 var WORKTREE_NAME_PREFIX = "rudder-";
 function resolveWorktreeMakeName(name) {
@@ -16880,9 +17019,9 @@ function normalizeStorageObjectKey(objectKey) {
   return parts.join("/");
 }
 function resolveLocalStoragePath(baseDir, objectKey) {
-  const resolved = path20.resolve(baseDir, normalizeStorageObjectKey(objectKey));
-  const root = path20.resolve(baseDir);
-  if (resolved !== root && !resolved.startsWith(`${root}${path20.sep}`)) {
+  const resolved = path21.resolve(baseDir, normalizeStorageObjectKey(objectKey));
+  const root = path21.resolve(baseDir);
+  if (resolved !== root && !resolved.startsWith(`${root}${path21.sep}`)) {
     throw new Error("Invalid object key path.");
   }
   return resolved;
@@ -16933,7 +17072,7 @@ function createConfiguredStorageFromRudderConfig(config) {
       async putObject(orgId, objectKey, body) {
         assertStorageCompanyPrefix(orgId, objectKey);
         const filePath = resolveLocalStoragePath(baseDir, objectKey);
-        await fsPromises.mkdir(path20.dirname(filePath), { recursive: true });
+        await fsPromises.mkdir(path21.dirname(filePath), { recursive: true });
         await fsPromises.writeFile(filePath, body);
       }
     };
@@ -17017,7 +17156,7 @@ async function readSourceAttachmentBody(sourceStorages, orgId, objectKey) {
   return null;
 }
 function resolveWorktreeMakeTargetPath(name) {
-  return path20.resolve(os3.homedir(), resolveWorktreeMakeName(name));
+  return path21.resolve(os3.homedir(), resolveWorktreeMakeName(name));
 }
 function extractExecSyncErrorMessage(error) {
   if (!error || typeof error !== "object") {
@@ -17123,10 +17262,10 @@ function detectGitWorkspaceInfo(cwd) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     return {
-      root: path20.resolve(root),
-      commonDir: path20.resolve(root, commonDirRaw),
-      gitDir: path20.resolve(root, gitDirRaw),
-      hooksPath: path20.resolve(root, hooksPathRaw)
+      root: path21.resolve(root),
+      commonDir: path21.resolve(root, commonDirRaw),
+      gitDir: path21.resolve(root, gitDirRaw),
+      hooksPath: path21.resolve(root, hooksPathRaw)
     };
   } catch {
     return null;
@@ -17139,8 +17278,8 @@ function copyDirectoryContents(sourceDir, targetDir) {
   mkdirSync3(targetDir, { recursive: true });
   let copied = false;
   for (const entry of entries) {
-    const sourcePath = path20.resolve(sourceDir, entry.name);
-    const targetPath = path20.resolve(targetDir, entry.name);
+    const sourcePath = path21.resolve(sourceDir, entry.name);
+    const targetPath = path21.resolve(targetDir, entry.name);
     if (entry.isDirectory()) {
       mkdirSync3(targetPath, { recursive: true });
       copyDirectoryContents(sourcePath, targetPath);
@@ -17166,7 +17305,7 @@ function copyGitHooksToWorktreeGitDir(cwd) {
   const workspace = detectGitWorkspaceInfo(cwd);
   if (!workspace) return null;
   const sourceHooksPath = workspace.hooksPath;
-  const targetHooksPath = path20.resolve(workspace.gitDir, "hooks");
+  const targetHooksPath = path21.resolve(workspace.gitDir, "hooks");
   if (sourceHooksPath === targetHooksPath) {
     return {
       sourceHooksPath,
@@ -17181,17 +17320,17 @@ function copyGitHooksToWorktreeGitDir(cwd) {
   };
 }
 function rebindWorkspaceCwd(input) {
-  const sourceRepoRoot = path20.resolve(input.sourceRepoRoot);
-  const targetRepoRoot = path20.resolve(input.targetRepoRoot);
-  const workspaceCwd = path20.resolve(input.workspaceCwd);
-  const relative = path20.relative(sourceRepoRoot, workspaceCwd);
+  const sourceRepoRoot = path21.resolve(input.sourceRepoRoot);
+  const targetRepoRoot = path21.resolve(input.targetRepoRoot);
+  const workspaceCwd = path21.resolve(input.workspaceCwd);
+  const relative = path21.relative(sourceRepoRoot, workspaceCwd);
   if (!relative || relative === "") {
     return targetRepoRoot;
   }
-  if (relative.startsWith("..") || path20.isAbsolute(relative)) {
+  if (relative.startsWith("..") || path21.isAbsolute(relative)) {
     return null;
   }
-  return path20.resolve(targetRepoRoot, relative);
+  return path21.resolve(targetRepoRoot, relative);
 }
 async function rebindSeededProjectWorkspaces(input) {
   const targetRepo = detectGitWorkspaceInfo(input.currentCwd);
@@ -17217,7 +17356,7 @@ async function rebindSeededProjectWorkspaces(input) {
         workspaceCwd
       });
       if (!reboundCwd) continue;
-      const normalizedCurrent = path20.resolve(workspaceCwd);
+      const normalizedCurrent = path21.resolve(workspaceCwd);
       if (reboundCwd === normalizedCurrent) continue;
       if (!existsSync3(reboundCwd)) continue;
       await db.update(projectWorkspaces).set({
@@ -17236,14 +17375,14 @@ async function rebindSeededProjectWorkspaces(input) {
   }
 }
 function resolveSourceConfigPath(opts) {
-  if (opts.sourceConfigPathOverride) return path20.resolve(opts.sourceConfigPathOverride);
-  if (opts.fromConfig) return path20.resolve(opts.fromConfig);
+  if (opts.sourceConfigPathOverride) return path21.resolve(opts.sourceConfigPathOverride);
+  if (opts.fromConfig) return path21.resolve(opts.fromConfig);
   if (!opts.fromDataDir && !opts.fromInstance) {
     return resolveConfigPath();
   }
-  const sourceHome = path20.resolve(expandHomePrefix(opts.fromDataDir ?? "~/.rudder"));
+  const sourceHome = path21.resolve(expandHomePrefix(opts.fromDataDir ?? "~/.rudder"));
   const sourceInstanceId = sanitizeWorktreeInstanceId(opts.fromInstance ?? "default");
-  return path20.resolve(sourceHome, "instances", sourceInstanceId, "config.json");
+  return path21.resolve(sourceHome, "instances", sourceInstanceId, "config.json");
 }
 function resolveSourceConnectionString(config, envEntries, portOverride) {
   if (config.database.mode === "postgres") {
@@ -17262,7 +17401,7 @@ function copySeededSecretsKey(input) {
   if (input.sourceConfig.secrets.provider !== "local_encrypted") {
     return;
   }
-  mkdirSync3(path20.dirname(input.targetKeyFilePath), { recursive: true });
+  mkdirSync3(path21.dirname(input.targetKeyFilePath), { recursive: true });
   const allowProcessEnvFallback = isCurrentSourceConfigPath(input.sourceConfigPath);
   const sourceInlineMasterKey = nonEmpty2(input.sourceEnvEntries.RUDDER_SECRETS_MASTER_KEY) ?? (allowProcessEnvFallback ? nonEmpty2(process.env.RUDDER_SECRETS_MASTER_KEY) : null);
   if (sourceInlineMasterKey) {
@@ -17301,7 +17440,7 @@ async function ensureEmbeddedPostgres(dataDir, preferredPort) {
       "Embedded PostgreSQL support requires dependency `embedded-postgres`. Reinstall dependencies and try again."
     );
   }
-  const postmasterPidFile = path20.resolve(dataDir, "postmaster.pid");
+  const postmasterPidFile = path21.resolve(dataDir, "postmaster.pid");
   const runningPid = readRunningPostmasterPid(postmasterPidFile);
   if (runningPid) {
     return {
@@ -17324,7 +17463,7 @@ async function ensureEmbeddedPostgres(dataDir, preferredPort) {
     onError: () => {
     }
   });
-  if (!existsSync3(path20.resolve(dataDir, "PG_VERSION"))) {
+  if (!existsSync3(path21.resolve(dataDir, "PG_VERSION"))) {
     await instance.initialise();
   }
   if (existsSync3(postmasterPidFile)) {
@@ -17365,7 +17504,7 @@ async function seedWorktreeDatabase(input) {
     );
     const backup = await runDatabaseBackup({
       connectionString: sourceConnectionString,
-      backupDir: path20.resolve(input.targetPaths.backupDir, "seed"),
+      backupDir: path21.resolve(input.targetPaths.backupDir, "seed"),
       retentionDays: 7,
       filenamePrefix: `${input.instanceId}-seed`,
       includeMigrationJournal: true,
@@ -17524,7 +17663,7 @@ async function worktreeMakeCommand(nameArg, opts) {
   if (existsSync3(targetPath)) {
     throw new Error(`Target path already exists: ${targetPath}`);
   }
-  mkdirSync3(path20.dirname(targetPath), { recursive: true });
+  mkdirSync3(path21.dirname(targetPath), { recursive: true });
   if (startPoint) {
     const [remote] = startPoint.split("/", 1);
     try {
@@ -17620,15 +17759,15 @@ function parseGitWorktreeList(cwd) {
   return entries;
 }
 function toMergeSourceChoices(cwd) {
-  const currentCwd = path20.resolve(cwd);
+  const currentCwd = path21.resolve(cwd);
   return parseGitWorktreeList(cwd).map((entry) => {
     const branchLabel = entry.branch?.replace(/^refs\/heads\//, "") ?? "(detached)";
-    const worktreePath = path20.resolve(entry.worktree);
+    const worktreePath = path21.resolve(entry.worktree);
     return {
       worktree: worktreePath,
       branch: entry.branch,
       branchLabel,
-      hasRudderConfig: existsSync3(path20.resolve(worktreePath, ".rudder", "config.json")),
+      hasRudderConfig: existsSync3(path21.resolve(worktreePath, ".rudder", "config.json")),
       isCurrent: worktreePath === currentCwd
     };
   });
@@ -17676,14 +17815,14 @@ async function worktreeCleanupCommand(nameArg, opts) {
   const sourceCwd = process.cwd();
   const targetPath = resolveWorktreeMakeTargetPath(name);
   const instanceId = sanitizeWorktreeInstanceId(opts.instance ?? name);
-  const homeDir = path20.resolve(expandHomePrefix(resolveWorktreeHome(opts.home)));
-  const instanceRoot = path20.resolve(homeDir, "instances", instanceId);
+  const homeDir = path21.resolve(expandHomePrefix(resolveWorktreeHome(opts.home)));
+  const instanceRoot = path21.resolve(homeDir, "instances", instanceId);
   const hasBranch = localBranchExists(sourceCwd, name);
   const hasTargetDir = existsSync3(targetPath);
   const hasInstanceData = existsSync3(instanceRoot);
   const worktrees = parseGitWorktreeList(sourceCwd);
   const linkedWorktree = worktrees.find(
-    (wt) => wt.branch === `refs/heads/${name}` || path20.resolve(wt.worktree) === path20.resolve(targetPath)
+    (wt) => wt.branch === `refs/heads/${name}` || path21.resolve(wt.worktree) === path21.resolve(targetPath)
   );
   if (!hasBranch && !hasTargetDir && !hasInstanceData && !linkedWorktree) {
     p17.log.info("Nothing to clean up \u2014 no branch, worktree directory, or instance data found.");
@@ -17801,7 +17940,7 @@ async function closeDb(db) {
 }
 function resolveCurrentEndpoint() {
   return {
-    rootPath: path20.resolve(process.cwd()),
+    rootPath: path21.resolve(process.cwd()),
     configPath: resolveConfigPath(),
     label: "current",
     isCurrent: true
@@ -17812,12 +17951,12 @@ function resolveAttachmentLookupStorages(input) {
     input.sourceEndpoint.configPath,
     resolveCurrentEndpoint().configPath,
     input.targetEndpoint.configPath,
-    ...toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig).map((choice) => path20.resolve(choice.worktree, ".rudder", "config.json"))
+    ...toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig).map((choice) => path21.resolve(choice.worktree, ".rudder", "config.json"))
   ];
   const seen = /* @__PURE__ */ new Set();
   const storages = [];
   for (const configPath of orderedConfigPaths) {
-    const resolved = path20.resolve(configPath);
+    const resolved = path21.resolve(configPath);
     if (seen.has(resolved) || !existsSync3(resolved)) continue;
     seen.add(resolved);
     storages.push(openConfiguredStorage(resolved));
@@ -18236,7 +18375,7 @@ function resolveEndpointFromChoice(choice) {
   }
   return {
     rootPath: choice.worktree,
-    configPath: path20.resolve(choice.worktree, ".rudder", "config.json"),
+    configPath: path21.resolve(choice.worktree, ".rudder", "config.json"),
     label: choice.branchLabel,
     isCurrent: false
   };
@@ -18252,24 +18391,24 @@ function resolveWorktreeEndpointFromSelector(selector, opts) {
     return currentEndpoint;
   }
   const choices = toMergeSourceChoices(process.cwd());
-  const directPath = path20.resolve(trimmed);
+  const directPath = path21.resolve(trimmed);
   if (existsSync3(directPath)) {
     if (allowCurrent && directPath === currentEndpoint.rootPath) {
       return currentEndpoint;
     }
-    const configPath = path20.resolve(directPath, ".rudder", "config.json");
+    const configPath = path21.resolve(directPath, ".rudder", "config.json");
     if (!existsSync3(configPath)) {
       throw new Error(`Resolved worktree path ${directPath} does not contain .rudder/config.json.`);
     }
     return {
       rootPath: directPath,
       configPath,
-      label: path20.basename(directPath),
+      label: path21.basename(directPath),
       isCurrent: false
     };
   }
   const matched = choices.find(
-    (choice) => (allowCurrent || !choice.isCurrent) && (choice.worktree === directPath || path20.basename(choice.worktree) === trimmed || choice.branchLabel === trimmed)
+    (choice) => (allowCurrent || !choice.isCurrent) && (choice.worktree === directPath || path21.basename(choice.worktree) === trimmed || choice.branchLabel === trimmed)
   );
   if (!matched) {
     throw new Error(
@@ -18282,9 +18421,9 @@ function resolveWorktreeEndpointFromSelector(selector, opts) {
   return resolveEndpointFromChoice(matched);
 }
 async function promptForSourceEndpoint(excludeWorktreePath) {
-  const excluded = excludeWorktreePath ? path20.resolve(excludeWorktreePath) : null;
+  const excluded = excludeWorktreePath ? path21.resolve(excludeWorktreePath) : null;
   const currentEndpoint = resolveCurrentEndpoint();
-  const choices = toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig || choice.isCurrent).filter((choice) => path20.resolve(choice.worktree) !== excluded).map((choice) => ({
+  const choices = toMergeSourceChoices(process.cwd()).filter((choice) => choice.hasRudderConfig || choice.isCurrent).filter((choice) => path21.resolve(choice.worktree) !== excluded).map((choice) => ({
     value: choice.isCurrent ? "__current__" : choice.worktree,
     label: choice.branchLabel,
     hint: `${choice.worktree}${choice.isCurrent ? " (current)" : ""}`
@@ -18608,7 +18747,7 @@ async function worktreeMergeHistoryCommand(sourceArg, opts) {
   }
   const targetEndpoint = opts.to ? resolveWorktreeEndpointFromSelector(opts.to, { allowCurrent: true }) : resolveCurrentEndpoint();
   const sourceEndpoint = opts.from ? resolveWorktreeEndpointFromSelector(opts.from, { allowCurrent: true }) : sourceArg ? resolveWorktreeEndpointFromSelector(sourceArg, { allowCurrent: true }) : await promptForSourceEndpoint(targetEndpoint.rootPath);
-  if (path20.resolve(sourceEndpoint.configPath) === path20.resolve(targetEndpoint.configPath)) {
+  if (path21.resolve(sourceEndpoint.configPath) === path21.resolve(targetEndpoint.configPath)) {
     throw new Error("Source and target Rudder configs are the same. Choose different --from/--to worktrees.");
   }
   const scopes = parseWorktreeMergeScopes(opts.scope);
@@ -18697,16 +18836,16 @@ function registerWorktreeCommands(program) {
 }
 
 // src/commands/client/plugin.ts
-import path21 from "node:path";
+import path22 from "node:path";
 import pc24 from "picocolors";
 function resolvePackageArg(packageArg, isLocal) {
   if (!isLocal) return packageArg;
-  if (path21.isAbsolute(packageArg)) return packageArg;
+  if (path22.isAbsolute(packageArg)) return packageArg;
   if (packageArg.startsWith("~")) {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path21.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
+    return path22.resolve(home, packageArg.slice(1).replace(/^[\\/]/, ""));
   }
-  return path21.resolve(process.cwd(), packageArg);
+  return path22.resolve(process.cwd(), packageArg);
 }
 function formatPlugin(p18) {
   const statusColor = p18.status === "ready" ? pc24.green(p18.status) : p18.status === "error" ? pc24.red(p18.status) : p18.status === "disabled" ? pc24.dim(p18.status) : pc24.yellow(p18.status);
@@ -18978,7 +19117,7 @@ function registerClientAuthCommands(auth) {
 
 // src/commands/benchmark-create-agent.ts
 import fs14 from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { LangfuseClient } from "@langfuse/client";
 
@@ -19004,6 +19143,13 @@ function formatJson(value) {
     return String(value);
   }
 }
+function formatTodoList(entry) {
+  return entry.items.map((item) => `${item.status === "completed" ? "[x]" : item.status === "in_progress" ? "[~]" : "[ ]"} ${item.text}`).join("\n");
+}
+function summarizeTodoList(entry) {
+  const completed = entry.items.filter((item) => item.status === "completed").length;
+  return `Todo list updated: ${completed}/${entry.items.length} complete`;
+}
 function isModelTranscriptEntry(entry) {
   return entry.kind === "assistant" || entry.kind === "thinking" || entry.kind === "result";
 }
@@ -19013,6 +19159,7 @@ function isPayloadTranscriptEntry(entry) {
 function detailTextForTranscriptEntry(entry) {
   if (entry.kind === "tool_call") return formatJson(entry.input);
   if (entry.kind === "tool_result") return entry.content || "";
+  if (entry.kind === "todo_list") return formatTodoList(entry);
   if (entry.kind === "result") {
     return [
       entry.text || "",
@@ -19032,6 +19179,9 @@ function previewTextForTranscriptEntry(entry, maxLength = 180) {
     const detail = detailTextForTranscriptEntry(entry);
     return truncate(firstMeaningfulLine(detail) || entry.toolName || "(empty tool result)", maxLength);
   }
+  if (entry.kind === "todo_list") {
+    return truncate(summarizeTodoList(entry), maxLength);
+  }
   if (entry.kind === "result") {
     const summary = entry.text ? firstMeaningfulLine(entry.text) : "";
     if (summary) return truncate(summary, maxLength);
@@ -19046,7 +19196,7 @@ function previewTextForTranscriptEntry(entry, maxLength = 180) {
   return "";
 }
 function isTurnScopedEntry(entry) {
-  return entry.kind === "assistant" || entry.kind === "thinking" || entry.kind === "tool_call" || entry.kind === "tool_result" || entry.kind === "result";
+  return entry.kind === "assistant" || entry.kind === "thinking" || entry.kind === "todo_list" || entry.kind === "tool_call" || entry.kind === "tool_result" || entry.kind === "result";
 }
 function isErrorTranscriptEntry(entry) {
   return entry.kind === "stderr" || entry.kind === "tool_result" && entry.isError || entry.kind === "result" && entry.isError;
@@ -19527,11 +19677,11 @@ function createAgentEvalCheckToScoreValue(check) {
 }
 
 // src/commands/benchmark-create-agent.ts
-var __moduleDir2 = path22.dirname(fileURLToPath5(import.meta.url));
-var repoRoot = path22.resolve(__moduleDir2, "../../..");
-var defaultCasesDir = path22.join(repoRoot, "benchmark", "create-agent", "cases");
-var defaultSetsDir = path22.join(repoRoot, "benchmark", "create-agent", "sets");
-var defaultArtifactsDir = path22.join(repoRoot, ".artifacts", "create-agent-benchmark");
+var __moduleDir2 = path23.dirname(fileURLToPath5(import.meta.url));
+var repoRoot = path23.resolve(__moduleDir2, "../../..");
+var defaultCasesDir = path23.join(repoRoot, "benchmark", "create-agent", "cases");
+var defaultSetsDir = path23.join(repoRoot, "benchmark", "create-agent", "sets");
+var defaultArtifactsDir = path23.join(repoRoot, ".artifacts", "create-agent-benchmark");
 var TERMINAL_RUN_STATUSES2 = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "timed_out"]);
 var DEFAULT_JUDGE_PROMPT_NAME = "judge-create-agent";
 var DEFAULT_JUDGE_MODEL = "gpt-5-mini";
@@ -19581,16 +19731,16 @@ async function readJsonFile(filePath) {
   return JSON.parse(content);
 }
 async function writeJsonFile(filePath, value) {
-  await fs14.mkdir(path22.dirname(filePath), { recursive: true });
+  await fs14.mkdir(path23.dirname(filePath), { recursive: true });
   await fs14.writeFile(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function loadCaseById(caseId, casesDir) {
-  const filePath = path22.join(casesDir, `${caseId}.json`);
+  const filePath = path23.join(casesDir, `${caseId}.json`);
   return parseCreateAgentCase(await readJsonFile(filePath));
 }
 async function loadSet(setName, setsDir) {
-  const filePath = path22.join(setsDir, `${setName}.json`);
+  const filePath = path23.join(setsDir, `${setName}.json`);
   const raw = await readJsonFile(filePath);
   if (!Array.isArray(raw) || raw.some((item) => typeof item !== "string")) {
     throw new Error(`Benchmark set ${setName} must be a JSON array of case IDs.`);
@@ -19678,13 +19828,13 @@ async function captureCreatedApprovals(api, approvals2) {
   );
 }
 function resultRunDir(artifactsDir, testCase, runId) {
-  return path22.join(artifactsDir, "runs", `${testCase.id}-${runId}`);
+  return path23.join(artifactsDir, "runs", `${testCase.id}-${runId}`);
 }
 function resultJsonPath(artifactsDir, testCase, runId) {
-  return path22.join(resultRunDir(artifactsDir, testCase, runId), "result.json");
+  return path23.join(resultRunDir(artifactsDir, testCase, runId), "result.json");
 }
 function reportMarkdownPath(artifactsDir, testCase, runId) {
-  return path22.join(resultRunDir(artifactsDir, testCase, runId), "report.md");
+  return path23.join(resultRunDir(artifactsDir, testCase, runId), "report.md");
 }
 function averageJudgeScore(judge) {
   if (!judge || judge.status !== "completed") return null;
@@ -20093,7 +20243,7 @@ async function executeBenchmarkCase(caseId, opts) {
   const jsonPath = resultJsonPath(artifactsDir, testCase, runDetail.run.id);
   const markdownPath = reportMarkdownPath(artifactsDir, testCase, runDetail.run.id);
   await writeJsonFile(jsonPath, provisionalResult);
-  await fs14.mkdir(path22.dirname(markdownPath), { recursive: true });
+  await fs14.mkdir(path23.dirname(markdownPath), { recursive: true });
   await fs14.writeFile(markdownPath, buildMarkdownReport(provisionalResult), "utf8");
   return provisionalResult;
 }
@@ -20116,7 +20266,7 @@ async function rescoreStoredResult(resultPath, opts) {
     result.langfuse.scoreSyncError = sync.scoreSyncError;
   }
   await writeJsonFile(resultPath, result);
-  await fs14.writeFile(path22.join(path22.dirname(resultPath), "report.md"), buildMarkdownReport(result), "utf8");
+  await fs14.writeFile(path23.join(path23.dirname(resultPath), "report.md"), buildMarkdownReport(result), "utf8");
   return result;
 }
 function printBenchmarkSummary(result, json = false) {
@@ -20185,7 +20335,7 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("rescore").description("Re-run deterministic scoring and optional judge for an existing result.json").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--queue-id <id>", "Langfuse annotation queue id for low-quality runs").option("--judge-model <model>", "Override the judge model").option("--no-sync-langfuse", "Skip Langfuse score sync").option("--no-judge", "Skip optional quality judge").action(async (resultPath, opts) => {
       try {
-        const result = await rescoreStoredResult(path22.resolve(resultPath), opts);
+        const result = await rescoreStoredResult(path23.resolve(resultPath), opts);
         printBenchmarkSummary(result, Boolean(opts.json));
       } catch (error) {
         handleCommandError(error);
@@ -20195,11 +20345,11 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("sync-langfuse").description("Sync one stored create-agent benchmark result to Langfuse").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--queue-id <id>", "Langfuse annotation queue id for low-quality runs").action(async (resultPath, opts) => {
       try {
-        const result = await readJsonFile(path22.resolve(resultPath));
+        const result = await readJsonFile(path23.resolve(resultPath));
         const sync = await syncResultToLangfuse(result, { queueId: asString6(opts.queueId) });
         result.langfuse.scoreSync = sync.scoreSync;
         result.langfuse.scoreSyncError = sync.scoreSyncError;
-        await writeJsonFile(path22.resolve(resultPath), result);
+        await writeJsonFile(path23.resolve(resultPath), result);
         printOutput({
           caseId: result.case.id,
           runId: result.runDetail.run.id,
@@ -20215,7 +20365,7 @@ function registerCreateAgentBenchmarkCommands(program) {
   addCommonClientOptions(
     createAgent.command("report").description("Render the markdown summary for an existing result.json").argument("<resultPath>", "Path to a stored create-agent benchmark result.json").option("--markdown", "Print report markdown instead of the parsed result summary", false).action(async (resultPath, opts) => {
       try {
-        const result = await readJsonFile(path22.resolve(resultPath));
+        const result = await readJsonFile(path23.resolve(resultPath));
         if (opts.markdown) {
           process.stdout.write(buildMarkdownReport(result));
           return;
@@ -20249,7 +20399,7 @@ function createProgram() {
     });
     loadRudderEnvFile(options.config);
   });
-  program.command("start").description("Start Rudder Desktop and prepare the matching persistent CLI").option("--no-cli", "Skip persistent CLI installation").option("--no-desktop", "Skip desktop app installation").option("--version <version>", "Rudder version to start (default: current CLI version)").option("--repo <owner/repo>", "GitHub repository that hosts desktop releases").option("--output-dir <path>", "Directory for downloaded desktop release assets").option("--desktop-install-dir <path>", "Directory for the portable Desktop install").option("--no-open", "Install Desktop without launching it").option("--no-version-check", "Skip checking npm for a newer Rudder CLI version").option("--dry-run", "Print the start actions without changing the machine", false).action(startCommand);
+  program.command("start").description("Start Rudder Desktop and prepare the matching persistent CLI").option("--no-cli", "Skip persistent CLI installation").option("--no-desktop", "Skip desktop app installation").option("--version <version>", "Rudder version to start (default: current CLI version)").option("--target-version <version>", "Rudder version to start; avoids the root CLI version flag").option("--repo <owner/repo>", "GitHub repository that hosts desktop releases").option("--output-dir <path>", "Directory for downloaded desktop release assets").option("--desktop-install-dir <path>", "Directory for the portable Desktop install").option("--no-open", "Install Desktop without launching it").option("--wait-for-active-runs", "Wait for active Rudder runs to finish before replacing Desktop", false).option("--no-version-check", "Skip checking npm for a newer Rudder CLI version").option("--dry-run", "Print the start actions without changing the machine", false).action(startCommand);
   program.command("onboard").description("Interactive first-run setup wizard").option("-c, --config <path>", "Path to config file").option("-d, --data-dir <path>", DATA_DIR_OPTION_HELP).option("-y, --yes", "Accept defaults (quickstart + start immediately)", false).option("--run", "Start Rudder immediately after saving config", false).action(onboard);
   program.command("doctor").description("Run diagnostic checks on your Rudder setup").option("-c, --config <path>", "Path to config file").option("-d, --data-dir <path>", DATA_DIR_OPTION_HELP).option("--repair", "Attempt to repair issues automatically").alias("--fix").option("-y, --yes", "Skip repair confirmation prompts").action(async (opts) => {
     await doctor(opts);