@duvoai/cli 1.45.2 → 1.46.0

package/dist/bin/duvo.js

@@ -1126,20 +1126,24 @@ var customerPortalResponseSchema = z22.object({
 var PRODUCT = {
   AUTOMATION: "automation",
   CLARITY: "clarity",
+  PULSE: "pulse",
   PLATFORM: "platform"
 };
 var PRODUCT_KEYS = [
   PRODUCT.AUTOMATION,
   PRODUCT.CLARITY,
+  PRODUCT.PULSE,
   PRODUCT.PLATFORM
 ];
 var CUSTOMER_VISIBLE_PRODUCTS = [
   PRODUCT.AUTOMATION,
-  PRODUCT.CLARITY
+  PRODUCT.CLARITY,
+  PRODUCT.PULSE
 ];
 var PRODUCT_FEATURE_COMPATIBILITY = {
   [PRODUCT.AUTOMATION]: [],
   [PRODUCT.CLARITY]: [PLAN_FEATURE.CLARITY],
+  [PRODUCT.PULSE]: [],
   [PRODUCT.PLATFORM]: []
 };
 var CAPABILITY = {
@@ -1238,7 +1242,7 @@ __name(getLimitsFromPlan, "getLimitsFromPlan");
 __name2(getLimitsFromPlan, "getLimitsFromPlan");
 var PLAN_PRESET_ENTITLEMENTS = {
   free_v1: {
-    products: [PRODUCT.AUTOMATION],
+    products: [PRODUCT.AUTOMATION, PRODUCT.PULSE],
     capabilities: [
       CAPABILITY.BROWSER_AUTOMATION,
       CAPABILITY.CUSTOM_MCP_SERVERS,
@@ -1248,7 +1252,7 @@ var PLAN_PRESET_ENTITLEMENTS = {
     limits: getLimitsFromPlan(PLAN_VERSIONS.free_v1)
   },
   pro_v1: {
-    products: [PRODUCT.AUTOMATION, PRODUCT.CLARITY],
+    products: [PRODUCT.AUTOMATION, PRODUCT.CLARITY, PRODUCT.PULSE],
     capabilities: [
       CAPABILITY.BROWSER_AUTOMATION,
       CAPABILITY.ADVANCED_INTEGRATIONS,
@@ -1264,7 +1268,12 @@ var PLAN_PRESET_ENTITLEMENTS = {
     limits: getLimitsFromPlan(PLAN_VERSIONS.pro_v1)
   },
   enterprise_v1: {
-    products: [PRODUCT.AUTOMATION, PRODUCT.CLARITY, PRODUCT.PLATFORM],
+    products: [
+      PRODUCT.AUTOMATION,
+      PRODUCT.CLARITY,
+      PRODUCT.PULSE,
+      PRODUCT.PLATFORM
+    ],
     capabilities: [
       CAPABILITY.BROWSER_AUTOMATION,
       CAPABILITY.ADVANCED_INTEGRATIONS,
@@ -1629,7 +1638,8 @@ var duvoLifecycleMessageTypeSchema = z10.union([
 ]);
 var duvoMessageTypeSchema = z10.union([
   duvoLifecycleMessageTypeSchema,
-  z10.literal("artifact_applied")
+  z10.literal("artifact_applied"),
+  z10.literal("classifier_decision")
 ]);
 var duvoBaseSystemMessageSchema = z10.object({
   id: z10.string(),
@@ -1724,6 +1734,28 @@ var duvoSystemArtifactAppliedMessageSchema = duvoArtifactAppliedBaseSystemMessag
     artifact: agentChatArtifactAppliedSchema
   })
 );
+var classifierDecisionSchema = z10.union([
+  z10.literal("allowed"),
+  z10.literal("denied"),
+  z10.literal("ask")
+]);
+var classifierDecidedBySchema = z10.union([
+  z10.literal("classifier"),
+  z10.literal("user")
+]);
+var duvoClassifierDecisionMessageSchema = z10.object({
+  id: z10.string(),
+  runtime: agentRuntimeSchema,
+  timestamp: z10.string(),
+  role: z10.literal("duvo"),
+  type: z10.literal("classifier_decision"),
+  tool_call_id: z10.string(),
+  tool_name: z10.string(),
+  decision: classifierDecisionSchema,
+  decided_by: classifierDecidedBySchema,
+  reason: z10.string().optional(),
+  human_request_id: z10.string().optional()
+});
 var agentRuntimeMessageTypeSchema = z10.union([
   agentMessageTypeSchema,
   duvoMessageTypeSchema
@@ -1735,7 +1767,8 @@ var duvoSystemMessageSchema = z10.union([
   duvoSystemAgentRunCreatedMessageSchema,
   duvoSystemBrowserSessionCreatedMessageSchema,
   duvoSystemSessionErrorMessageSchema,
-  duvoSystemArtifactAppliedMessageSchema
+  duvoSystemArtifactAppliedMessageSchema,
+  duvoClassifierDecisionMessageSchema
 ]);
 var sdkMessageSchema = z10.looseObject({
   session_id: z10.string(),
@@ -1756,7 +1789,15 @@ var toolPausedEventSchema = z10.object({
   toolInput: z10.record(z10.string(), z10.unknown()),
   category: pausableToolCategorySchema,
   behavior: z10.union([z10.literal("canUseTool"), z10.literal("interrupt")]),
-  timestamp: z10.string().optional()
+  timestamp: z10.string().optional(),
+  // Set when the pause came from the supervised-mode auto-mode classifier
+  // escalating an arbitrary tool call, rather than a registered HITL tool.
+  source: z10.literal("classifier").optional(),
+  // SDK tool_use id of the intercepted call, so the created human_request can
+  // be linked back to the tool-call card in the run UI.
+  toolCallId: z10.string().optional(),
+  // Classifier's human-readable explanation of why it escalated.
+  decisionReason: z10.string().optional()
 });
 var thinkingConfigSchema = z10.union([
   z10.object({ type: z10.literal("disabled") }),
@@ -3251,6 +3292,138 @@ Quoted guidance: ${JSON.stringify(formatted)}`;
 }
 __name(buildProcessGuidanceBlock, "buildProcessGuidanceBlock");
 __name2(buildProcessGuidanceBlock, "buildProcessGuidanceBlock");
+var TEAM_ROLE = {
+  OWNER: "team:owner",
+  SUPERADMIN: "team:superadmin",
+  ADMIN: "team:admin",
+  MANAGER: "team:manager",
+  BUILDER: "team:builder",
+  MEMBER: "team:member",
+  CLARITY_MEMBER: "team:clarity-member"
+};
+var TEAM_ROLE_CONFIG = {
+  [TEAM_ROLE.OWNER]: {
+    displayName: "Owner",
+    parentRole: null
+  },
+  [TEAM_ROLE.SUPERADMIN]: {
+    displayName: "Administrator",
+    parentRole: TEAM_ROLE.OWNER
+  },
+  [TEAM_ROLE.ADMIN]: {
+    displayName: "Manager",
+    parentRole: TEAM_ROLE.SUPERADMIN
+  },
+  [TEAM_ROLE.MANAGER]: {
+    displayName: "Manager",
+    parentRole: TEAM_ROLE.ADMIN
+  },
+  [TEAM_ROLE.BUILDER]: {
+    displayName: "Builder",
+    parentRole: TEAM_ROLE.MANAGER
+  },
+  [TEAM_ROLE.MEMBER]: {
+    displayName: "Member",
+    parentRole: TEAM_ROLE.BUILDER
+  },
+  [TEAM_ROLE.CLARITY_MEMBER]: {
+    displayName: "Clarity Member",
+    parentRole: TEAM_ROLE.MEMBER
+  }
+};
+var TEAM_ROLES = {
+  OWNER_ONLY: [TEAM_ROLE.OWNER],
+  SUPERADMIN_AND_ABOVE: [TEAM_ROLE.OWNER, TEAM_ROLE.SUPERADMIN],
+  ADMIN_AND_ABOVE: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.ADMIN
+  ],
+  MANAGER_AND_ABOVE: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.ADMIN,
+    TEAM_ROLE.MANAGER
+  ],
+  BUILDER_AND_ABOVE: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.ADMIN,
+    TEAM_ROLE.MANAGER,
+    TEAM_ROLE.BUILDER
+  ],
+  MEMBER_AND_ABOVE: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.ADMIN,
+    TEAM_ROLE.MANAGER,
+    TEAM_ROLE.BUILDER,
+    TEAM_ROLE.MEMBER
+  ],
+  ALL: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.ADMIN,
+    TEAM_ROLE.MANAGER,
+    TEAM_ROLE.BUILDER,
+    TEAM_ROLE.MEMBER,
+    TEAM_ROLE.CLARITY_MEMBER
+  ],
+  /**
+   * Team roles an SSO role mapping — or a connection's default team role — may
+   * newly grant. Excludes `team:admin`: it is deprecated and shares the display
+   * name "Manager" with `team:manager`, so offering both leaves an
+   * administrator picking between two indistinguishable options.
+   *
+   * This governs what is *newly assignable*, not what is accepted: rows already
+   * holding `team:admin` stay valid and the write schema still takes `ALL`.
+   */
+  SSO_ASSIGNABLE: [
+    TEAM_ROLE.OWNER,
+    TEAM_ROLE.SUPERADMIN,
+    TEAM_ROLE.MANAGER,
+    TEAM_ROLE.BUILDER,
+    TEAM_ROLE.MEMBER,
+    TEAM_ROLE.CLARITY_MEMBER
+  ]
+};
+function hasMinimumRole(userRole, minimumRole) {
+  if (!isValidTeamRole(userRole)) {
+    return false;
+  }
+  let current = minimumRole;
+  while (current) {
+    if (current === userRole) {
+      return true;
+    }
+    current = TEAM_ROLE_CONFIG[current].parentRole;
+  }
+  return false;
+}
+__name(hasMinimumRole, "hasMinimumRole");
+__name2(hasMinimumRole, "hasMinimumRole");
+function isValidTeamRole(role) {
+  return Object.values(TEAM_ROLE).includes(role);
+}
+__name(isValidTeamRole, "isValidTeamRole");
+__name2(isValidTeamRole, "isValidTeamRole");
+function getTeamRoleLabel(role) {
+  if (!isValidTeamRole(role)) {
+    return role;
+  }
+  if (role === TEAM_ROLE.ADMIN) {
+    return `${TEAM_ROLE_CONFIG[role].displayName} (dep. admin)`;
+  }
+  return TEAM_ROLE_CONFIG[role].displayName;
+}
+__name(getTeamRoleLabel, "getTeamRoleLabel");
+__name2(getTeamRoleLabel, "getTeamRoleLabel");
+var SSO_ASSIGNABLE_TEAM_ROLES = TEAM_ROLES.SSO_ASSIGNABLE;
+function getSsoAssignableTeamRoleOptions(current) {
+  return isValidTeamRole(current) && !SSO_ASSIGNABLE_TEAM_ROLES.includes(current) ? [...TEAM_ROLES.SSO_ASSIGNABLE, current] : TEAM_ROLES.SSO_ASSIGNABLE;
+}
+__name(getSsoAssignableTeamRoleOptions, "getSsoAssignableTeamRoleOptions");
+__name2(getSsoAssignableTeamRoleOptions, "getSsoAssignableTeamRoleOptions");
 var DEFAULT_CLARITY_PROCESS_LABEL_COLOR_HUE = 215;
 var clarityProcessLabelColorHueSchema = z17.int().min(0).max(360);
 var clarityProcessLabelInputSchema = z17.object({
@@ -4069,6 +4242,9 @@ var clarityProcessLandscapeResponseSchema = z18.object({
   links: z18.array(clarityProcessLandscapeLinkSchema),
   unlinkedProcesses: z18.array(clarityProcessLandscapeUnlinkedProcessSchema),
   stats: clarityProcessLandscapeStatsSchema,
+  generationStatus: clarityProcessLandscapeGenerationStatusSchema.default("idle").describe(
+    "Latest organization-wide generation status. Available to every authorized organization viewer so terminal failures can be communicated without exposing generation input counts."
+  ),
   generation: clarityProcessLandscapeGenerationSchema.nullable().describe(
     "Organization-wide generation status and eligible input counts. Null unless the caller has an Owner or Executive organization role."
   ),
@@ -4120,6 +4296,131 @@ var clarityProcessPersonSchema = z18.object({
 var clarityProcessPeopleResponseSchema = z18.object({
   people: z18.array(clarityProcessPersonSchema)
 });
+var CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_NODE_COUNT = 20;
+var CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PEOPLE_COUNT = 20;
+var CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PAIR_COUNT = 100;
+function normalizeClarityHierarchyBatchText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+__name(normalizeClarityHierarchyBatchText, "normalizeClarityHierarchyBatchText");
+__name2(normalizeClarityHierarchyBatchText, "normalizeClarityHierarchyBatchText");
+var clarityHierarchyPeopleBatchPersonSchema = z18.object({
+  name: z18.string().max(200).nullable().transform(normalizeClarityHierarchyBatchText),
+  /** Null adds a name-only placeholder person; no invitation is sent. */
+  email: z18.string().transform((email) => email.trim().toLowerCase()).pipe(z18.email()).nullable(),
+  processRole: z18.string().max(200).nullable().transform(normalizeClarityHierarchyBatchText),
+  teamRole: z18.enum(TEAM_ROLES.ALL)
+}).strict().refine((person) => person.email !== null || person.name !== null, {
+  message: "Name or email is required"
+});
+var clarityHierarchyPeopleBatchRequestSchema = z18.object({
+  nodeIds: z18.array(z18.guid().transform((nodeId) => nodeId.toLowerCase())).min(1).max(CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_NODE_COUNT).refine((nodeIds) => new Set(nodeIds).size === nodeIds.length, {
+    message: "Process node IDs must be unique"
+  }),
+  people: z18.array(clarityHierarchyPeopleBatchPersonSchema).min(1).max(CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PEOPLE_COUNT).refine(
+    (people) => new Set(people.map((person) => person.email ?? `name:${person.name}`)).size === people.length,
+    { message: "People must be unique" }
+  )
+}).strict().refine(
+  ({ nodeIds, people }) => nodeIds.length * people.length <= CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PAIR_COUNT,
+  {
+    message: `Batch cannot exceed ${CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PAIR_COUNT} node/person assignments`
+  }
+);
+var CLARITY_HIERARCHY_PEOPLE_BATCH_ERROR_CODES = [
+  "NODE_NOT_FOUND",
+  "PROCESS_NOT_FOUND",
+  "CONCURRENT_CONFLICT",
+  "ASSIGNMENT_FAILED"
+];
+var clarityHierarchyPeopleBatchInvitationDeliveryStatusSchema = z18.enum(
+  ["sent", "not_needed", "failed"]
+);
+var clarityHierarchyPeopleBatchOutcomeKeySchema = z18.object({
+  nodeId: z18.guid(),
+  email: z18.email().nullable(),
+  name: z18.string().nullable()
+});
+var clarityHierarchyPeopleBatchAssignedOutcomeSchema = clarityHierarchyPeopleBatchOutcomeKeySchema.extend({
+  outcome: z18.literal("assigned"),
+  processPerson: clarityProcessPersonSchema.strict(),
+  invitationDeliveryStatus: clarityHierarchyPeopleBatchInvitationDeliveryStatusSchema
+}).strict();
+var clarityHierarchyPeopleBatchAlreadyPresentOutcomeSchema = clarityHierarchyPeopleBatchOutcomeKeySchema.extend({
+  outcome: z18.literal("already_present"),
+  processPerson: clarityProcessPersonSchema.strict().nullable(),
+  invitationDeliveryStatus: z18.literal("not_needed")
+}).strict();
+var clarityHierarchyPeopleBatchFailedOutcomeSchema = clarityHierarchyPeopleBatchOutcomeKeySchema.extend({
+  outcome: z18.literal("failed"),
+  processPerson: clarityProcessPersonSchema.strict().nullable(),
+  invitationDeliveryStatus: z18.literal("not_needed"),
+  error: z18.object({
+    code: z18.enum(CLARITY_HIERARCHY_PEOPLE_BATCH_ERROR_CODES),
+    message: z18.string().min(1),
+    retryable: z18.boolean()
+  }).strict()
+}).strict();
+var clarityHierarchyPeopleBatchOutcomeSchema = z18.discriminatedUnion(
+  "outcome",
+  [
+    clarityHierarchyPeopleBatchAssignedOutcomeSchema,
+    clarityHierarchyPeopleBatchAlreadyPresentOutcomeSchema,
+    clarityHierarchyPeopleBatchFailedOutcomeSchema
+  ]
+);
+var clarityHierarchyPeopleBatchCountSchema = z18.number().int().nonnegative().max(CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PAIR_COUNT);
+var clarityHierarchyPeopleBatchResponseSchema = z18.object({
+  outcomes: z18.array(clarityHierarchyPeopleBatchOutcomeSchema).min(1).max(CLARITY_HIERARCHY_PEOPLE_BATCH_MAX_PAIR_COUNT),
+  counts: z18.object({
+    requested: clarityHierarchyPeopleBatchCountSchema.min(1),
+    assigned: clarityHierarchyPeopleBatchCountSchema,
+    alreadyPresent: clarityHierarchyPeopleBatchCountSchema,
+    failed: clarityHierarchyPeopleBatchCountSchema,
+    invitationsSent: clarityHierarchyPeopleBatchCountSchema,
+    invitationFailures: clarityHierarchyPeopleBatchCountSchema
+  }).strict()
+}).strict().superRefine(({ outcomes, counts }, ctx) => {
+  const assigned = outcomes.filter(
+    (item) => item.outcome === "assigned"
+  ).length;
+  const alreadyPresent = outcomes.filter(
+    (item) => item.outcome === "already_present"
+  ).length;
+  const failed = outcomes.filter((item) => item.outcome === "failed").length;
+  const invitationsSent = outcomes.filter(
+    (item) => item.outcome === "assigned" && item.invitationDeliveryStatus === "sent"
+  ).length;
+  const invitationFailures = outcomes.filter(
+    (item) => item.outcome === "assigned" && item.invitationDeliveryStatus === "failed"
+  ).length;
+  const expectedCounts = {
+    requested: outcomes.length,
+    assigned,
+    alreadyPresent,
+    failed,
+    invitationsSent,
+    invitationFailures
+  };
+  for (const field of [
+    "requested",
+    "assigned",
+    "alreadyPresent",
+    "failed",
+    "invitationsSent",
+    "invitationFailures"
+  ]) {
+    if (counts[field] === expectedCounts[field]) {
+      continue;
+    }
+    ctx.addIssue({
+      code: "custom",
+      path: ["counts", field],
+      message: `${field} must equal ${expectedCounts[field]}`
+    });
+  }
+});
 var clarityHierarchyPersonSchema = clarityProcessPersonSchema.extend({
   nodeId: z18.guid(),
   processId: z18.guid()
@@ -4139,7 +4440,12 @@ var clarityLandscapePeopleResponseSchema = clarityHierarchyPeopleResponseSchema.
 var createClarityProcessPersonRequestSchema = z18.object({
   name: z18.string().max(200).nullable().optional(),
   email: z18.email().nullable().optional(),
-  role: z18.string().max(200).nullable().optional()
+  role: z18.string().max(200).nullable().optional(),
+  /**
+   * Team role granted when the email needs a new team invitation. Ignored
+   * for existing team members. Defaults to Clarity Member when absent.
+   */
+  teamRole: z18.enum(TEAM_ROLES.ALL).nullable().optional()
 }).refine(
   (body) => Boolean(body.name?.trim()) || Boolean(body.email?.trim()),
   "Name or email is required"
@@ -6113,6 +6419,12 @@ var clarityV2ProcessReadModelSchema = z25.object({
     generation_progress: generationProgressSchema.nullable().describe(
       "Live progress checklist while a generation is in flight; null otherwise. Field names inside the payload are camelCase, matching the legacy v1 generation-progress shape."
     ),
+    generation_started_at: z25.iso.datetime().nullable().default(null).describe(
+      "ISO 8601 timestamp for the most recent generation kickoff; useful for generation-duration reporting"
+    ),
+    generation_last_activity_at: z25.iso.datetime().nullable().default(null).describe(
+      "ISO 8601 timestamp of the latest process or message activity while generation is in flight; use it for stale-generation detection"
+    ),
     custom_prompt: z25.string().nullable().describe("User-supplied custom prompt that steers generation"),
     created_at: z25.string().describe("ISO 8601 creation timestamp"),
     updated_at: z25.string().describe("ISO 8601 last-update timestamp")
@@ -7236,6 +7548,12 @@ var NOTIFICATION_SEVERITIES = [
   "success"
 ];
 var notificationSeveritySchema = z31.enum(NOTIFICATION_SEVERITIES);
+var NOTIFICATION_SEVERITY_URGENCY_ORDER = [
+  "success",
+  "info",
+  "warning",
+  "critical"
+];
 var NOTIFICATION_TYPE_META = {
   connection_broken: {
     label: "Reconnect",
@@ -7342,7 +7660,25 @@ var notificationBaseShape = {
   seenAt: z31.string().nullable(),
   readAt: z31.string().nullable(),
   resolvedAt: z31.string().nullable(),
-  dismissedAt: z31.string().nullable().default(null)
+  dismissedAt: z31.string().nullable().default(null),
+  /**
+   * How many occurrences this row stands for. 1 for an ordinary notification;
+   * higher on a collapsed row (a repeated eval flag, a flapping connection).
+   *
+   * On the wire because a collapsed row that renders as "1" is worse than no
+   * collapsing at all — the reader sees one card and has no way to know the
+   * other N happened. Defaulted so older stored rows and clients that never
+   * sent it read as a single occurrence.
+   *
+   * `.min(1)` rather than `.positive()`: on an integer the two are the same
+   * constraint, but `.positive()` lowers to a *numeric* `exclusiveMinimum`,
+   * which is JSON Schema 2020-12. The published spec is OpenAPI 3.0.3, where
+   * `exclusiveMinimum` is a boolean modifier on `minimum`, so the numeric form
+   * is invalid there.
+   */
+  occurrenceCount: z31.number().int().min(1).default(1),
+  /** When the most recent occurrence arrived; null when never collapsed. */
+  lastSeenAt: z31.string().nullable().default(null)
 };
 var JOB_ISSUE_SOURCES = ["run_failed", "run_stuck"];
 var LEGACY_JOB_ISSUE_SOURCES = [
@@ -7466,6 +7802,9 @@ var notificationListQuerySchema = z31.object({
   severity: notificationSeveritySchema.optional().describe(
     `Only return notifications with this severity. One of: ${NOTIFICATION_SEVERITIES.join(", ")}.`
   ),
+  minSeverity: notificationSeveritySchema.optional().describe(
+    `Only return notifications at or above this urgency. Least to most urgent: ${NOTIFICATION_SEVERITY_URGENCY_ORDER.join(" < ")}. Mutually exclusive with severity.`
+  ),
   important: z31.enum(["true", "false"]).optional().transform((v) => v === "true").describe(
     "If true, only return important notifications: unresolved connection_broken rows pinned until reconnected, removed, or dismissed."
   ),
@@ -7484,6 +7823,9 @@ var notificationListQuerySchema = z31.object({
 }).refine((data) => data.sort !== "importance" || Boolean(data.batchId), {
   message: "sort=importance is only valid together with batchId",
   path: ["sort"]
+}).refine((data) => !(data.severity && data.minSeverity), {
+  message: "severity and minSeverity are mutually exclusive; use severity for an exact match or minSeverity for a threshold",
+  path: ["minSeverity"]
 });
 var notificationListResponseSchema = z31.object({
   notifications: z31.array(notificationWireSchema),
@@ -7518,7 +7860,13 @@ var typePreferenceListResponseSchema = z31.array(typePreferenceSchema);
 var EVAL_ISSUE_SCOPE_STATUSES = ["custom"];
 var evalIssueScopeSchema = z31.object({
   status: z31.enum(EVAL_ISSUE_SCOPE_STATUSES).nullable(),
-  customSet: z31.array(z31.string()).nullable()
+  customSet: z31.array(z31.string()).nullable(),
+  /**
+   * Minimum urgency an eval_issue must reach for this subscription to receive
+   * it. Optional rather than required so adding it does not break a client
+   * built against the previous shape; the backend always sends it.
+   */
+  minSeverity: notificationSeveritySchema.nullable().optional()
 });
 var agentNotificationSettingsResponseSchema = z31.object({
   muted: z31.boolean(),
@@ -7533,6 +7881,11 @@ var notificationBatchTypeCountSchema = z32.object({
   total: z32.number().int().nonnegative(),
   unread: z32.number().int().nonnegative()
 });
+var notificationBatchSeverityCountSchema = z32.object({
+  severity: notificationSeveritySchema,
+  total: z32.number().int().nonnegative(),
+  unread: z32.number().int().nonnegative()
+});
 var notificationBatchWireSchema = z32.object({
   id: z32.guid(),
   agentId: z32.guid().nullable(),
@@ -7543,6 +7896,20 @@ var notificationBatchWireSchema = z32.object({
   closedAt: z32.string().nullable(),
   /** Live-member counts, one entry per type with total > 0, ordered by type sortOrder. Narrowed to matching members under a type filter (Resolved #11/#17). */
   typeCounts: z32.array(notificationBatchTypeCountSchema),
+  /**
+   * Live-member counts broken down by severity, one entry per severity with
+   * total > 0. Exists because `worstSeverity` cannot answer an *exact*
+   * severity filter: a batch whose worst member is critical may still hold
+   * warning members, so "does this batch contain severity X" needs the
+   * breakdown. Narrowed alongside typeCounts under an active filter.
+   *
+   * Defaulted rather than required because this schema also parses *responses*
+   * in duvo-cli, which ships to npm on its own cadence: a CLI carrying this
+   * field against a backend that predates it would otherwise reject every feed
+   * page containing a batch. Same reasoning as occurrenceCount/lastSeenAt on
+   * the notification wire.
+   */
+  severityCounts: z32.array(notificationBatchSeverityCountSchema).default([]),
   /** Sum of typeCounts[].unread — the "N new" chip. */
   unreadCount: z32.number().int().nonnegative(),
   /** Worst severity among live members (severity accent, Resolved #15). */
@@ -7562,13 +7929,36 @@ var notificationFeedQuerySchema = z32.object({
   unread: z32.enum(["true", "false"]).optional().transform((v) => v === "true").describe(
     "If true, only return unread individual notifications and batches with at least one unread live member."
   ),
+  severity: notificationSeveritySchema.optional().describe(
+    `Only return individual notifications with exactly this severity, and batches with at least one live member of it. A batch's counts then describe only those members. Mutually exclusive with minSeverity. One of: ${NOTIFICATION_SEVERITIES.join(", ")}.`
+  ),
+  minSeverity: notificationSeveritySchema.optional().describe(
+    `Only return individual notifications at or above this urgency, and batches with at least one live member at or above it. A batch's counts and worst severity then describe only its members at or above the threshold. Least to most urgent: ${NOTIFICATION_SEVERITY_URGENCY_ORDER.join(" < ")}. Mutually exclusive with severity.`
+  ),
   limit: z32.coerce.number().int().min(1).max(NOTIFICATION_LIST_MAX_LIMIT).prefault(NOTIFICATION_LIST_DEFAULT_LIMIT),
   cursor: z32.string().optional()
+}).refine((data) => !(data.severity && data.minSeverity), {
+  message: "severity and minSeverity are mutually exclusive; use severity for an exact match or minSeverity for a threshold",
+  path: ["severity"]
 });
 var notificationFeedResponseSchema = z32.object({
   items: z32.array(notificationFeedItemSchema),
   nextCursor: z32.string().nullable()
 });
+var notificationBatchByIdQuerySchema = z32.object({
+  type: notificationTypeSchema.optional().describe(
+    "Count only live members of this type. Omit to count every live member."
+  ),
+  severity: notificationSeveritySchema.optional().describe(
+    `Count only live members with exactly this severity. Mutually exclusive with minSeverity. One of: ${NOTIFICATION_SEVERITIES.join(", ")}.`
+  ),
+  minSeverity: notificationSeveritySchema.optional().describe(
+    `Count only live members at or above this urgency. Least to most urgent: ${NOTIFICATION_SEVERITY_URGENCY_ORDER.join(" < ")}. Mutually exclusive with severity.`
+  )
+}).refine((data) => !(data.severity && data.minSeverity), {
+  message: "severity and minSeverity are mutually exclusive; use severity for an exact match or minSeverity for a threshold",
+  path: ["severity"]
+});
 var markBatchReadBodySchema = z32.object({
   /**
    * Narrow the mark-read to these member types (the page's active type
@@ -7582,7 +7972,30 @@ var markBatchReadBodySchema = z32.object({
    */
   types: z32.array(notificationTypeSchema).nonempty().max(NOTIFICATION_TYPES.length).refine((types) => new Set(types).size === types.length, {
     message: "types must not contain duplicates"
-  }).optional()
+  }).optional(),
+  /**
+   * Narrow the mark-read to members of exactly this severity (the page's active
+   * `severity` chip). Omit to mark every live member. Same reason `types`
+   * exists: a batch card surfaced under a severity filter counts only its
+   * matching members, so marking the whole batch read would silently consume
+   * members the reader never saw.
+   *
+   * Distinct from `minSeverity`, not a rename of it: the feed's chips are
+   * exact matches, so a batch opened under "Warning" shows warning members
+   * only and must consume only those. Marking it with a `minSeverity` of
+   * warning would also swallow its critical members — the unread rows the
+   * reader most needs.
+   */
+  severity: notificationSeveritySchema.optional(),
+  /**
+   * Narrow the mark-read to members at or above this urgency, for a caller
+   * paging the feed with `minSeverity` rather than `severity`. Mutually
+   * exclusive with `severity`.
+   */
+  minSeverity: notificationSeveritySchema.optional()
+}).refine((data) => !(data.severity && data.minSeverity), {
+  message: "severity and minSeverity are mutually exclusive; use severity for an exact match or minSeverity for a threshold",
+  path: ["severity"]
 });
 var markBatchReadResponseSchema = z32.object({
   count: z32.number().int().nonnegative()
@@ -8188,138 +8601,6 @@ function buildPulseThemeStyle() {
 }
 __name(buildPulseThemeStyle, "buildPulseThemeStyle");
 __name2(buildPulseThemeStyle, "buildPulseThemeStyle");
-var TEAM_ROLE = {
-  OWNER: "team:owner",
-  SUPERADMIN: "team:superadmin",
-  ADMIN: "team:admin",
-  MANAGER: "team:manager",
-  BUILDER: "team:builder",
-  MEMBER: "team:member",
-  CLARITY_MEMBER: "team:clarity-member"
-};
-var TEAM_ROLE_CONFIG = {
-  [TEAM_ROLE.OWNER]: {
-    displayName: "Owner",
-    parentRole: null
-  },
-  [TEAM_ROLE.SUPERADMIN]: {
-    displayName: "Administrator",
-    parentRole: TEAM_ROLE.OWNER
-  },
-  [TEAM_ROLE.ADMIN]: {
-    displayName: "Manager",
-    parentRole: TEAM_ROLE.SUPERADMIN
-  },
-  [TEAM_ROLE.MANAGER]: {
-    displayName: "Manager",
-    parentRole: TEAM_ROLE.ADMIN
-  },
-  [TEAM_ROLE.BUILDER]: {
-    displayName: "Builder",
-    parentRole: TEAM_ROLE.MANAGER
-  },
-  [TEAM_ROLE.MEMBER]: {
-    displayName: "Member",
-    parentRole: TEAM_ROLE.BUILDER
-  },
-  [TEAM_ROLE.CLARITY_MEMBER]: {
-    displayName: "Clarity Member",
-    parentRole: TEAM_ROLE.MEMBER
-  }
-};
-var TEAM_ROLES = {
-  OWNER_ONLY: [TEAM_ROLE.OWNER],
-  SUPERADMIN_AND_ABOVE: [TEAM_ROLE.OWNER, TEAM_ROLE.SUPERADMIN],
-  ADMIN_AND_ABOVE: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.ADMIN
-  ],
-  MANAGER_AND_ABOVE: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.ADMIN,
-    TEAM_ROLE.MANAGER
-  ],
-  BUILDER_AND_ABOVE: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.ADMIN,
-    TEAM_ROLE.MANAGER,
-    TEAM_ROLE.BUILDER
-  ],
-  MEMBER_AND_ABOVE: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.ADMIN,
-    TEAM_ROLE.MANAGER,
-    TEAM_ROLE.BUILDER,
-    TEAM_ROLE.MEMBER
-  ],
-  ALL: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.ADMIN,
-    TEAM_ROLE.MANAGER,
-    TEAM_ROLE.BUILDER,
-    TEAM_ROLE.MEMBER,
-    TEAM_ROLE.CLARITY_MEMBER
-  ],
-  /**
-   * Team roles an SSO role mapping — or a connection's default team role — may
-   * newly grant. Excludes `team:admin`: it is deprecated and shares the display
-   * name "Manager" with `team:manager`, so offering both leaves an
-   * administrator picking between two indistinguishable options.
-   *
-   * This governs what is *newly assignable*, not what is accepted: rows already
-   * holding `team:admin` stay valid and the write schema still takes `ALL`.
-   */
-  SSO_ASSIGNABLE: [
-    TEAM_ROLE.OWNER,
-    TEAM_ROLE.SUPERADMIN,
-    TEAM_ROLE.MANAGER,
-    TEAM_ROLE.BUILDER,
-    TEAM_ROLE.MEMBER,
-    TEAM_ROLE.CLARITY_MEMBER
-  ]
-};
-function hasMinimumRole(userRole, minimumRole) {
-  if (!isValidTeamRole(userRole)) {
-    return false;
-  }
-  let current = minimumRole;
-  while (current) {
-    if (current === userRole) {
-      return true;
-    }
-    current = TEAM_ROLE_CONFIG[current].parentRole;
-  }
-  return false;
-}
-__name(hasMinimumRole, "hasMinimumRole");
-__name2(hasMinimumRole, "hasMinimumRole");
-function isValidTeamRole(role) {
-  return Object.values(TEAM_ROLE).includes(role);
-}
-__name(isValidTeamRole, "isValidTeamRole");
-__name2(isValidTeamRole, "isValidTeamRole");
-function getTeamRoleLabel(role) {
-  if (!isValidTeamRole(role)) {
-    return role;
-  }
-  if (role === TEAM_ROLE.ADMIN) {
-    return `${TEAM_ROLE_CONFIG[role].displayName} (dep. admin)`;
-  }
-  return TEAM_ROLE_CONFIG[role].displayName;
-}
-__name(getTeamRoleLabel, "getTeamRoleLabel");
-__name2(getTeamRoleLabel, "getTeamRoleLabel");
-var SSO_ASSIGNABLE_TEAM_ROLES = TEAM_ROLES.SSO_ASSIGNABLE;
-function getSsoAssignableTeamRoleOptions(current) {
-  return isValidTeamRole(current) && !SSO_ASSIGNABLE_TEAM_ROLES.includes(current) ? [...TEAM_ROLES.SSO_ASSIGNABLE, current] : TEAM_ROLES.SSO_ASSIGNABLE;
-}
-__name(getSsoAssignableTeamRoleOptions, "getSsoAssignableTeamRoleOptions");
-__name2(getSsoAssignableTeamRoleOptions, "getSsoAssignableTeamRoleOptions");
 var TransportTypeSchema = z36.enum(["stdio", "sse", "http"]);
 var INTEGRATION_SLUGS = [
   "googlecalendar",
@@ -8428,6 +8709,13 @@ function isIntegrationSlug(value) {
 }
 __name(isIntegrationSlug, "isIntegrationSlug");
 __name2(isIntegrationSlug, "isIntegrationSlug");
+var COMPUTER_USE_INTEGRATION_SLUGS = /* @__PURE__ */ new Set(["duvo-computer-use", "duvo-computer-use-rdp"]);
+var BROWSING_INTEGRATION_SLUGS = /* @__PURE__ */ new Set(["browser-agent", "browser-agent-devtools"]);
+function isSupervisedModeIncompatibleIntegration(slug) {
+  return BROWSING_INTEGRATION_SLUGS.has(slug) || COMPUTER_USE_INTEGRATION_SLUGS.has(slug);
+}
+__name(isSupervisedModeIncompatibleIntegration, "isSupervisedModeIncompatibleIntegration");
+__name2(isSupervisedModeIncompatibleIntegration, "isSupervisedModeIncompatibleIntegration");
 var SERVER_RESOLVED_MCP_URL_SLUGS = /* @__PURE__ */ new Set([
   "sap-ecc",
   "tableau",
@@ -9508,15 +9796,7 @@ var adminCaseQueueConsumerSchema = z49.object({
   agentName: z49.string(),
   caseTriggerEnabled: z49.boolean(),
   isHandoverTarget: z49.boolean(),
-  problems: z49.array(adminCaseQueueAgentProblemSchema),
-  /** Raw concurrency set on the trigger row, null if unset or no trigger exists. */
-  triggerConcurrency: z49.number().nullable(),
-  /**
-   * Effective concurrency for the consumer trigger:
-   * `min(triggerConcurrency ?? defaultConcurrency, maxConcurrency)`.
-   * Null when this consumer has no trigger.
-   */
-  effectiveConcurrency: z49.number().nullable()
+  problems: z49.array(adminCaseQueueAgentProblemSchema)
 });
 var adminCaseQueueItemSummarySchema = z49.object({
   id: z49.string(),
@@ -9570,6 +9850,13 @@ var adminCaseQueueDetailResponseSchema = z49.object({
       name: z49.string(),
       description: z49.string().nullable(),
       folderId: z49.string().nullable(),
+      /** The configured per-queue concurrency cap (case_queue.concurrency); null uses the default. */
+      configuredConcurrency: z49.number().nullable(),
+      /**
+       * Effective per-queue concurrency after the default fallback and the
+       * `MAX_CASE_TRIGGER_CONCURRENCY` ceiling. Always a number.
+       */
+      effectiveConcurrency: z49.number(),
       createdAt: z49.string(),
       updatedAt: z49.string()
     }),
@@ -9577,13 +9864,13 @@ var adminCaseQueueDetailResponseSchema = z49.object({
     consumers: z49.array(adminCaseQueueConsumerSchema),
     /**
      * `env.DEFAULT_CASE_TRIGGER_CONCURRENCY` — the per-queue concurrency applied
-     * to a trigger that has no concurrency set.
+     * to a queue that has no explicit cap set.
      */
     defaultConcurrency: z49.number(),
     /**
      * `env.MAX_CASE_TRIGGER_CONCURRENCY` — the hard per-queue ceiling for
-     * effective trigger concurrency, clamping both a trigger's own concurrency
-     * and the fallback default when either exceeds this value.
+     * effective concurrency, clamping both a queue's own cap and the fallback
+     * default when either exceeds this value.
      */
     maxConcurrency: z49.number(),
     items: z49.object({
@@ -9594,20 +9881,19 @@ var adminCaseQueueDetailResponseSchema = z49.object({
     })
   })
 });
-var adminUpdateCaseTriggerConcurrencyRequestSchema = z49.object({
+var adminUpdateQueueConcurrencyRequestSchema = z49.object({
   concurrency: z49.int().positive().nullable().describe(
-    "New per-trigger concurrency cap. A positive integer (up to the platform max) sets an explicit cap; null clears it so the trigger uses the platform default."
+    "New per-queue concurrency cap. A positive integer (up to the platform max) sets an explicit cap; null clears it so the queue uses the platform default."
   )
 });
-var adminUpdateCaseTriggerConcurrencyResponseSchema = z49.object({
+var adminUpdateQueueConcurrencyResponseSchema = z49.object({
   data: z49.object({
-    agentId: z49.string(),
-    /** Raw concurrency stored on the trigger row, null when using the default. */
-    triggerConcurrency: z49.number().nullable(),
+    queueId: z49.string(),
+    /** The configured concurrency stored on the queue row, null when using the default. */
+    configuredConcurrency: z49.number().nullable(),
     /**
      * Effective concurrency after applying the default fallback and the
-     * `MAX_CASE_TRIGGER_CONCURRENCY` ceiling. Always a number because a trigger
-     * row exists.
+     * `MAX_CASE_TRIGGER_CONCURRENCY` ceiling.
      */
     effectiveConcurrency: z49.number()
   })
@@ -10022,7 +10308,12 @@ var inviteOrgMemberRequestSchema = z51.object({
     "organization:admin",
     "organization:member"
   ]),
-  frontendUrl: z51.url().optional(),
+  frontendUrl: z51.url().optional().describe(
+    "Deprecated. Use `sendEmail` instead. Kept because its presence is the legacy opt-in for sending the invitation email; the value never sets the link host, which is always the server's configured frontend URL."
+  ),
+  sendEmail: z51.boolean().optional().describe(
+    "Email the invitation to the recipient. `false` always suppresses the email. When omitted, the legacy opt-in applies instead: the email is sent only if the deprecated `frontendUrl` is present. Omit both to create the invitation without notifying anyone."
+  ),
   teamId: z51.guid().optional()
 });
 var inviteOrgMemberResponseSchema = z51.object({
@@ -10114,10 +10405,14 @@ var acceptOrgInvitationResponseSchema = z51.object({
   orgId: z51.guid()
 });
 var createOrganizationInviteLinkRequestSchema = z51.object({
-  frontendUrl: z51.url()
+  frontendUrl: z51.url().optional().describe(
+    "Deprecated and ignored. The link is built from the server's configured frontend URL so a caller can't choose the host in a Duvo-branded email."
+  )
 });
 var getOrganizationInviteLinkQuerySchema = z51.object({
-  frontendUrl: z51.url()
+  frontendUrl: z51.url().optional().describe(
+    "Deprecated and ignored. The link is built from the server's configured frontend URL so a caller can't choose the host in a Duvo-branded email."
+  )
 });
 var organizationInviteLinkCreatorSchema = z51.object({
   id: z51.guid(),
@@ -10282,7 +10577,9 @@ var adminOrgAddMemberResponseSchema = z52.object({
 var adminOrgInviteMemberRequestSchema = z52.object({
   email: z52.email(),
   role: z52.enum(ORG_ROLES.ALL),
-  frontendUrl: z52.url().optional()
+  frontendUrl: z52.url().optional().describe(
+    "Set any URL to opt into sending the invitation email; omit it to create the invitation silently. The value no longer sets the link host \u2014 that is always the server's configured frontend URL."
+  )
 });
 var adminOrgInviteMemberResponseSchema = z52.object({
   success: z52.literal(true),
@@ -10591,7 +10888,10 @@ var RuntimeOptionsSchema = z56.looseObject({
     "Browser infrastructure provider"
   ),
   evaluationSchemaId: z56.string().optional().describe("ID of the evaluation schema to apply to runs of this agent"),
-  benchmarkExpectedOutcomes: z56.array(BenchmarkExpectedOutcomeSchema).optional().describe("Expected outcomes used when running benchmark scenarios")
+  benchmarkExpectedOutcomes: z56.array(BenchmarkExpectedOutcomeSchema).optional().describe("Expected outcomes used when running benchmark scenarios"),
+  supervisedMode: z56.boolean().optional().describe(
+    "Run the agent under Duvo's permission classifier: every tool call is classified as allow/deny/ask, with 'ask' routed to human-in-the-loop approval. Mutually exclusive with browsing and computer-use connections."
+  )
 });
 var AgentConfigSchemaV2 = z56.object({
   models: z56.object({
@@ -11156,7 +11456,10 @@ var automationDetailResponseApiSchema = z64.object({
   automation: automationDetailApiSchema
 });
 var createAutomationResponseApiSchema = z64.object({
-  automation: automationSummaryApiSchema
+  automation: automationSummaryApiSchema,
+  draft_revision_id: z64.guid().describe(
+    "The draft revision the new automation was created with. A manually created automation has no live revision until it is first activated, so this is where its first agent build belongs."
+  )
 });
 var updateAutomationResponseApiSchema = z64.object({
   automation: automationSummaryApiSchema
@@ -11237,7 +11540,6 @@ var automationRevisionQueueBindingApiSchema = z64.object({
     "Agent the queue routes to in this revision (null when unrouted)"
   ),
   enabled: z64.boolean().describe("Whether the queue's routing is enabled"),
-  concurrency: z64.int().nullable().describe("Per-revision concurrency limit (null for the queue default)"),
   name: z64.string().nullable().describe(
     "Per-revision queue name override (null to keep the queue's own name)"
   ),
@@ -11281,6 +11583,111 @@ var automationRevisionScheduleBindingApiSchema = z64.object({
   day_of_month: z64.int().min(1).max(31).nullable().describe("Day of month for a monthly schedule"),
   task: z64.string().nullable().describe("Prompt passed as the run's initial user message")
 });
+var automationTriggerSubscriptionApiSchema = z64.object({
+  id: z64.guid().describe("Subscription identifier"),
+  automation_trigger_id: z64.guid().describe("Declaration this subscription fulfills"),
+  user_id: z64.guid().nullable().describe(
+    "Scope owner. Always populated today: a null-scope (team) subscription needs the shared-run runtime, so nothing creates one yet"
+  ),
+  created_by: z64.guid().nullable().describe("Who authored the subscription"),
+  enabled: z64.boolean().describe("Whether this scope participates"),
+  integration_instance_id: z64.guid().nullable().describe("The connection this subscription currently fires with"),
+  pending_integration_instance_id: z64.guid().nullable().describe(
+    "A connection change staged with a draft, applied atomically on that draft's promotion"
+  ),
+  pending_from_revision_id: z64.guid().nullable().describe("Draft revision the staged connection change belongs to")
+});
+var automationScheduleSubscriptionApiSchema = z64.object({
+  id: z64.guid().describe("Subscription identifier"),
+  automation_schedule_id: z64.guid().describe("Declaration this subscription fulfills"),
+  user_id: z64.guid().nullable().describe(
+    "Scope owner. Always populated today: a null-scope (team) subscription needs the shared-run runtime, so nothing creates one yet"
+  ),
+  created_by: z64.guid().nullable().describe("Who authored the subscription"),
+  enabled: z64.boolean().describe("Whether this scope participates")
+});
+var automationRevisionTriggersResponseApiSchema = z64.object({
+  revision_id: z64.guid().describe("Revision these declarations were read from"),
+  revision_status: automationRevisionStatusApiSchema.describe(
+    "`draft`, `live`, or `historic` \u2014 drives read-only presentation"
+  ),
+  revision_updated_at: z64.string().describe(
+    "ISO 8601 change stamp, and the concurrency token for the paired PUT. Send it back as `If-Match` and a write from stale state is refused with 409. Without it there is no check, and because the PUT replaces the complete set, a stale client silently drops declarations another editor added"
+  ),
+  triggers: z64.array(automationRevisionTriggerBindingApiSchema).describe(
+    "Credential-free trigger declarations and this revision's config"
+  ),
+  subscriptions: z64.array(automationTriggerSubscriptionApiSchema).describe(
+    "How each declaration is fulfilled **right now** \u2014 every scope's, not just the caller's. Returned at any revision status, and always current state: this is not a record of what fulfilled the declaration while a historic revision was live (that is not stored). On a historic revision it answers what a rollback would resume \u2014 note that activation disables the subscriptions of a declaration a newer revision omits and never re-enables them, so a bound-but-disabled row means rolling back will not resume it until each member opts back in"
+  )
+});
+var automationRevisionSchedulesResponseApiSchema = z64.object({
+  revision_id: z64.guid().describe("Revision these declarations were read from"),
+  revision_status: automationRevisionStatusApiSchema.describe(
+    "`draft`, `live`, or `historic` \u2014 drives read-only presentation"
+  ),
+  revision_updated_at: z64.string().describe(
+    "ISO 8601 change stamp, and the concurrency token for the paired PUT. Send it back as `If-Match` and a write from stale state is refused with 409. Without it there is no check, and because the PUT replaces the complete set, a stale client silently drops declarations another editor added"
+  ),
+  schedules: z64.array(automationRevisionScheduleBindingApiSchema).describe(
+    "Credential-free schedule declarations and this revision's config"
+  ),
+  subscriptions: z64.array(automationScheduleSubscriptionApiSchema).describe(
+    "Who the schedule runs as **right now** \u2014 every scope's, not just the caller's. Returned at any revision status, and always current state rather than a record of who it ran as while a historic revision was live. Unlike the trigger lane, activation never disables a schedule opt-in when a revision omits the declaration, so these survive a rollback intact"
+  )
+});
+var setAutomationRevisionTriggerApiSchema = z64.object({
+  automation_trigger_id: z64.guid().optional().describe("Existing declaration to update; omit to mint a new one"),
+  agent_id: z64.guid().describe("Agent this trigger routes to"),
+  integration_slug: z64.string().min(1).describe("Integration to watch"),
+  trigger_type: z64.string().min(1).describe("Trigger type within the integration"),
+  enabled: z64.boolean().default(true).describe("Whether the trigger is enabled in this revision"),
+  filter_config: z64.record(z64.string(), z64.unknown()).default({}).describe("Per-revision filter configuration"),
+  integration_instance_id: z64.guid().nullable().optional().describe(
+    "Connection to fulfill this declaration with. Applied on promotion for an already-live declaration; set directly for one that is not live. Omit to leave it as it is; pass null to discard a choice staged against this draft"
+  )
+});
+var setAutomationRevisionTriggersRequestApiSchema = z64.object({
+  triggers: z64.array(setAutomationRevisionTriggerApiSchema).describe(
+    "The draft's complete desired trigger set; declarations absent here are removed from the draft"
+  )
+});
+var setAutomationRevisionScheduleApiSchema = z64.object({
+  automation_schedule_id: z64.guid().optional().describe("Existing declaration to update; omit to mint a new one"),
+  agent_id: z64.guid().describe("Agent this schedule fires"),
+  enabled: z64.boolean().default(true).describe("Whether the schedule is enabled"),
+  cron: z64.string().min(1).nullable().optional().describe("5-field cron expression; mutually exclusive with `frequency`"),
+  frequency: z64.enum(AUTOMATION_SCHEDULE_FREQUENCIES).nullable().optional().describe("Frequency form; mutually exclusive with `cron`"),
+  time: z64.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).nullable().optional().describe("Local time of day as HH:MM"),
+  timezone: z64.string().default("UTC").describe("IANA timezone the schedule is evaluated in"),
+  day: z64.enum(AUTOMATION_SCHEDULE_DAYS).nullable().optional().describe("Day of week for a weekly schedule"),
+  day_of_month: z64.int().min(1).max(31).nullable().optional().describe("Day of month for a monthly schedule"),
+  task: z64.string().nullable().optional().describe("Prompt passed as the run's initial user message")
+});
+var setAutomationRevisionSchedulesRequestApiSchema = z64.object({
+  schedules: z64.array(setAutomationRevisionScheduleApiSchema).describe(
+    "The draft's complete desired schedule set; declarations absent here are removed from the draft"
+  )
+});
+var setAutomationTriggerSubscriptionRequestApiSchema = z64.object({
+  enabled: z64.boolean().describe("Whether this scope participates"),
+  integration_instance_id: z64.guid().nullable().optional().describe(
+    "Connection this scope fires with. Required to enable a subscription that has none"
+  )
+});
+var setAutomationScheduleSubscriptionRequestApiSchema = z64.object({
+  enabled: z64.boolean().describe("Whether this scope participates")
+});
+var automationTriggerSubscriptionResponseApiSchema = z64.object({
+  subscription: automationTriggerSubscriptionApiSchema.describe(
+    "The subscription after the change"
+  )
+});
+var automationScheduleSubscriptionResponseApiSchema = z64.object({
+  subscription: automationScheduleSubscriptionApiSchema.describe(
+    "The subscription after the change"
+  )
+});
 var automationRevisionDetailApiSchema = automationRevisionSummaryApiSchema.extend({
   ai_description: z64.string().nullable().describe(
     "AI-generated short description of what this revision does (null until generated)"
@@ -11360,9 +11767,6 @@ var setAutomationRevisionQueueBodyApiSchema = z64.object({
   enabled: z64.boolean().optional().describe(
     "Whether routing is enabled (omit to keep current; default true when new)"
   ),
-  concurrency: z64.int().nonnegative().nullable().optional().describe(
-    "Per-revision concurrency limit (null for queue default; omit to keep current)"
-  ),
   name: revisionNameFieldSchema.nullable().optional().describe("Per-revision name override (null clears; omit to keep current)"),
   description: revisionDescriptionFieldSchema.nullable().optional().describe(
     "Per-revision description override (null clears; omit to keep current)"
@@ -12263,10 +12667,14 @@ var publicClarityProcessSchema = z78.object({
   createdAt: z78.coerce.date()
 });
 var createTeamInviteLinkRequestSchema = z79.object({
-  frontendUrl: z79.url()
+  frontendUrl: z79.url().optional().describe(
+    "Deprecated and ignored. The link is built from the server's configured frontend URL so a caller can't choose the host in a Duvo-branded email."
+  )
 });
 var getTeamInviteLinkQuerySchema = z79.object({
-  frontendUrl: z79.url()
+  frontendUrl: z79.url().optional().describe(
+    "Deprecated and ignored. The link is built from the server's configured frontend URL so a caller can't choose the host in a Duvo-branded email."
+  )
 });
 var teamInviteLinkCreatorSchema = z79.object({
   id: z79.guid(),
@@ -12283,6 +12691,7 @@ var getTeamInviteLinkResponseSchema = z79.object({
   hasLink: z79.boolean(),
   link: teamInviteLinkSchema.optional()
 });
+var createTeamInviteLinkResponseSchema = teamInviteLinkSchema;
 var joinLinkInfoResponseSchema = z79.object({
   valid: z79.boolean(),
   teamName: z79.string().optional(),
@@ -12294,7 +12703,9 @@ var acceptJoinLinkResponseSchema = z79.object({
   teamId: z79.guid()
 });
 var createClarityProcessInviteLinkRequestSchema = z80.object({
-  frontendUrl: z80.url()
+  frontendUrl: z80.url().optional().describe(
+    "Deprecated and ignored. The link is built from the server's configured frontend URL so a caller can't choose the host in a Duvo-branded email."
+  )
 });
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
 var getClarityProcessInviteLinkResponseSchema = z80.object({
@@ -12451,6 +12862,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the L1-L4 Clarity process hierarchy surfaces, including the process landscape tree and related organize/auto-sort workflows."
   },
+  UNIFIED_CLARITY: {
+    key: "unified_clarity",
+    defaultValue: false,
+    description: "Enables the shared Clarity Tree and Map home, canonical navigation, compatibility redirects, and eligible team-only organization landscape reads. Off by default for internal and FDE prototype validation."
+  },
   LANDSCAPE_ONBOARDING: {
     key: "landscape_onboarding",
     defaultValue: false,
@@ -12616,6 +13032,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Grants connection sharing to teams that are NOT part of an organization (org-less teams have no org-level `connections_sharing_enabled` kill-switch). Resolved with team > global precedence; a global override turns it on for every org-less team. Teams inside an organization are governed solely by their org's setting and are unaffected by this flag."
   },
+  SUPERVISED_MODE: {
+    key: "supervised_mode",
+    defaultValue: false,
+    description: "Per-team opt-in for Supervised mode \u2014 running an agent under a custom `PreToolUse` classifier hook that rules on every tool call before it executes (`permissionMode` stays `bypassPermissions`; the SDK's own auto mode is not used). When on, the builder shows the Supervised mode toggle and build configs may persist `options.supervisedMode: true` (classifier asks route to the Requests center; per-tool-call verdicts render on run tool-call cards). When off (default), the toggle is hidden and saving a config with supervisedMode enabled is rejected at the build-config routes. Execution honors the frozen RunConfig regardless, so flipping the flag off does not break in-flight runs."
+  },
   SUPPORT_ESCALATION: {
     key: "support_escalation",
     defaultValue: false,
@@ -12753,6 +13174,9 @@ var jobListItemSchema = z84.object({
   agent_id: z84.guid(),
   agent_name: z84.string(),
   build_id: z84.guid(),
+  // Automation info (null for runs whose agent doesn't belong to an automation)
+  automation_id: z84.guid().nullable(),
+  automation_name: z84.string().nullable(),
   // User info
   user_id: z84.guid().nullable(),
   // Case info
@@ -12790,7 +13214,8 @@ var jobFilterOptionsSchema = z84.object({
       email: z84.string()
     })
   ),
-  caseQueues: z84.array(z84.object({ id: z84.string(), name: z84.string() }))
+  caseQueues: z84.array(z84.object({ id: z84.string(), name: z84.string() })),
+  automations: z84.array(z84.object({ id: z84.string(), name: z84.string() }))
 });
 var stepModeSchema = z85.enum(["deterministic", "parameterized", "agent"]).describe("How replay executes this step");
 var workflowParameterSchema = z85.object({
@@ -13498,9 +13923,13 @@ var teamInvitationDetailApiSchema = z93.object({
   }).optional()
 });
 var createTeamInvitationRequestSchema = z93.object({
-  email: z93.email(),
-  role: z93.string(),
-  processId: z93.guid().optional()
+  email: z93.email().describe("Email address of the person to invite."),
+  role: z93.string().describe(
+    "Team role to grant. One of: team:owner, team:superadmin, team:admin (deprecated), team:manager, team:builder, team:member, team:clarity-member. You cannot grant a role above your own. Process invitations must use team:clarity-member."
+  ),
+  processId: z93.guid().optional().describe(
+    "Invite the person to this Clarity process rather than the whole team. Requires the team:clarity-member role."
+  )
 });
 var acceptTeamInvitationRequestSchema = z93.object({
   name: z93.string().optional()
@@ -13515,6 +13944,7 @@ var bulkInviteResponseSchema = z93.object({
   skipped: z93.number(),
   failed: z93.number()
 });
+var createTeamInvitationResponseSchema = teamInvitationDetailApiSchema;
 var TEAM_DISCOVERY_MODES = ["request", "auto"];
 var teamDiscoveryModeSchema = z94.enum(TEAM_DISCOVERY_MODES);
 var BrowserRegionSchema = z94.enum([
@@ -15681,7 +16111,8 @@ function normalizeProfile(value) {
     return {
       type: "api-key",
       apiKey: profile.apiKey,
-      apiBaseUrl
+      apiBaseUrl,
+      defaultTeamId: typeof profile.defaultTeamId === "string" ? profile.defaultTeamId : void 0
     };
   }
   return null;
@@ -15859,7 +16290,10 @@ async function resolveConfig(options = {}) {
       apiBaseUrl: env.DUVO_API_BASE_URL ?? profile.apiBaseUrl,
       profileName,
       authType: "api-key",
-      defaultTeamId: null
+      // Honored for user-scoped keys (team_id NULL server-side), which can
+      // act on every team the owner can reach; a team-scoped key ignores it
+      // because the server pins the key's team.
+      defaultTeamId: profile.defaultTeamId ?? null
     };
   }
   const fresh = await ensureFreshOAuthProfile(config, profileName, profile);
@@ -16004,6 +16438,11 @@ async function resolveTeamIdFromApiKey(config) {
       "API key is not associated with a team. Pass --team <id> or check your key."
     );
   }
+  if (parsed.data.teams.length > 1) {
+    throw new CliError(
+      "This key can act on multiple teams. Pass --team <id>, set DUVO_TEAM_ID, or choose a default with `duvo team use <id>`. Run `duvo teams list` to see them."
+    );
+  }
   return team.id;
 }
 __name(resolveTeamIdFromApiKey, "resolveTeamIdFromApiKey");
@@ -16838,7 +17277,10 @@ var readinessDropSchema = z104.object({
   credentials_dropped: z104.number(),
   event_triggers_dropped: z104.number(),
   schedules_dropped: z104.number(),
-  case_triggers_dropped: z104.number()
+  case_triggers_dropped: z104.number(),
+  runs_interrupted: z104.number(),
+  blocks_approvals: z104.boolean(),
+  runs_at_risk: z104.number()
 });
 var inFlightRunSchema = z104.object({
   agent_id: z104.string(),
@@ -16866,7 +17308,9 @@ var moveAgentResponseSchema = z104.object({
       readiness: z104.object({
         users_missing_on_target: z104.array(readinessDropSchema)
       }),
-      in_flight_runs: z104.array(inFlightRunSchema)
+      in_flight_runs: z104.array(inFlightRunSchema),
+      runs_pinned: z104.number(),
+      runs_interrupted: z104.number()
     }),
     dropped_folders: z104.array(namedRefSchema),
     dropped_memory_count: z104.number(),
@@ -18014,14 +18458,39 @@ Files copied to target: ${paths}`);
       "\nOwners not on the target team \u2014 add them there first, or their connections, triggers, and schedules are dropped:"
     );
     for (const u of outcome.readiness.users_missing_on_target) {
-      console.log(`  - ${u.user_name} (${u.user_id}) \u2014 role ${u.source_role}`);
+      const consequences = [];
+      if (u.runs_interrupted > 0) {
+        consequences.push(`${u.runs_interrupted} run(s) will be stopped`);
+      }
+      if (u.blocks_approvals) {
+        consequences.push("the AOP names them as an approver");
+      }
+      if (u.runs_at_risk > 0) {
+        consequences.push(
+          `${u.runs_at_risk} run(s) they own keep going, but nobody could answer their next question`
+        );
+      }
+      const suffix = consequences.length > 0 ? ` \u2014 ${consequences.join("; ")}` : "";
+      console.log(
+        `  - ${u.user_name} (${u.user_id}) \u2014 role ${u.source_role}${suffix}`
+      );
     }
   }
   if (outcome.in_flight_runs.length > 0) {
-    console.log("\nAgents with runs in progress (will continue on target):");
+    console.log("\nAgents with runs in progress:");
     for (const r of outcome.in_flight_runs) {
       console.log(`  - ${r.agent_name} \u2014 ${r.count} run(s)`);
     }
+    if (outcome.runs_pinned > 0) {
+      console.log(
+        `  ${outcome.runs_pinned} run(s) keep the source team's connections until their next step, then switch to the target team.`
+      );
+    }
+    if (outcome.runs_interrupted > 0) {
+      console.log(
+        `  ${outcome.runs_interrupted} run(s) will be stopped \u2014 nobody on the target team can answer them, or a connection they use isn't coming along. Pending requests stay open, so adding the missing user picks those runs back up; a dropped connection has to be reconnected on the target team first.`
+      );
+    }
   }
   const dropped = [];
   if (outcome.event_triggers_dropped > 0) {
@@ -21984,6 +22453,14 @@ function renderOverview(overview) {
       { label: "Name", value: process2.name },
       { label: "Version", value: String(process2.version) },
       { label: "Status", value: process2.status },
+      {
+        label: "Generation started",
+        value: process2.generation_started_at ?? "none"
+      },
+      {
+        label: "Generation activity",
+        value: process2.generation_last_activity_at ?? "none"
+      },
       { label: "Captures", value: String(overview.process.captures.length) },
       {
         label: "Current",
@@ -28729,6 +29206,684 @@ function registerIntegrations(program) {
 }
 __name(registerIntegrations, "registerIntegrations");
 
+// src/commands/invite/team-roles.ts
+var TEAM_ROLES2 = Object.values(TEAM_ROLE);
+var DEFAULT_TEAM_ROLE = TEAM_ROLE.MEMBER;
+function assertTeamRole(role, flag = "--role") {
+  if (!TEAM_ROLES2.includes(role)) {
+    throw new CliError(
+      `Invalid ${flag} "${role}"; expected one of: ${TEAM_ROLES2.join(", ")}`
+    );
+  }
+  return role;
+}
+__name(assertTeamRole, "assertTeamRole");
+
+// src/commands/invite/bulk.ts
+var MAX_MEMBERS = 50;
+function collect3(value, previous = []) {
+  return [...previous, value];
+}
+__name(collect3, "collect");
+function parseMember(value, defaultRole) {
+  const raw = trimRequired(value, "--member");
+  const separator = raw.indexOf("=");
+  if (separator === -1) {
+    return { email: raw, role: defaultRole };
+  }
+  const email = raw.slice(0, separator).trim();
+  const role = raw.slice(separator + 1).trim();
+  if (email.length === 0) {
+    throw new CliError(
+      `Invalid --member "${raw}"; expected <email> or <email>=<role>.`
+    );
+  }
+  return { email, role: assertTeamRole(role, `--member ${email} role`) };
+}
+__name(parseMember, "parseMember");
+function registerInviteBulk(invite) {
+  invite.command("bulk").description("Invite several people to a team and email each invitation").requiredOption(
+    "--member <email[=role]>",
+    "person to invite; repeat for multiple. Append =<role> to override the --role default",
+    collect3,
+    []
+  ).option(
+    "--role <role>",
+    `role for members that don't specify their own (default ${DEFAULT_TEAM_ROLE})`,
+    DEFAULT_TEAM_ROLE
+  ).option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkAction(options) {
+    if (options.member.length === 0) {
+      throw new CliError("Provide at least one --member <email[=role]>.");
+    }
+    const defaultRole = assertTeamRole(options.role ?? DEFAULT_TEAM_ROLE);
+    const members = options.member.map(
+      (value) => parseMember(value, defaultRole)
+    );
+    if (members.length > MAX_MEMBERS) {
+      throw new CliError(
+        `Provide at most ${MAX_MEMBERS} --member values (got ${members.length}).`
+      );
+    }
+    const emails = members.map((member) => member.email.toLowerCase());
+    if (new Set(emails).size !== emails.length) {
+      throw new CliError("--member emails must be unique.");
+    }
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(teamId, "/invites/bulk"),
+      apiKey,
+      apiBaseUrl,
+      body: { members }
+    });
+    const parsed = bulkInviteResponseSchema.safeParse(raw);
+    if (options.json) {
+      printJson(raw);
+      if (parsed.success && parsed.data.failed > 0) {
+        throw new CliError(
+          `${parsed.data.failed} of ${members.length} invitations could not be emailed and were rolled back.`
+        );
+      }
+      return;
+    }
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { succeeded, skipped, failed } = parsed.data;
+    console.log(green(`Invited ${succeeded} of ${members.length} people.`));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Invited", value: String(succeeded) },
+        { label: "Skipped", value: String(skipped) },
+        { label: "Failed", value: String(failed) }
+      ])
+    );
+    if (skipped > 0) {
+      console.log();
+      console.log(
+        "Skipped people are already on the team or already hold a pending invitation."
+      );
+    }
+    if (failed > 0) {
+      console.log();
+      console.log(
+        "Failed invitations could not be emailed and were rolled back \u2014 re-run for those addresses."
+      );
+      throw new CliError(
+        `${failed} of ${members.length} invitations could not be emailed and were rolled back.`
+      );
+    }
+  }, "bulkAction"));
+}
+__name(registerInviteBulk, "registerInviteBulk");
+
+// src/api/invite-schemas.ts
+import { z as z127 } from "zod";
+var updateTeamInviteResponseSchema = z127.object({
+  id: z127.string(),
+  role: z127.string()
+});
+var inviteSuccessResponseSchema = z127.object({
+  success: z127.literal(true)
+});
+
+// src/commands/invite/send-invitation-email.ts
+function classifyFailure(error) {
+  if (error instanceof CliHttpError && error.status < 500) {
+    return "failed";
+  }
+  return "unconfirmed";
+}
+__name(classifyFailure, "classifyFailure");
+async function trySendInvitationEmail(args) {
+  try {
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(
+        args.teamId,
+        `/invites/${encodeURIComponent(args.inviteId)}/send-email`
+      ),
+      apiKey: args.apiKey,
+      apiBaseUrl: args.apiBaseUrl,
+      body: {}
+    });
+    const parsed = inviteSuccessResponseSchema.safeParse(raw);
+    if (parsed.success) {
+      return { status: "sent", error: null };
+    }
+    return { status: "unconfirmed", error: parsed.error.message };
+  } catch (error) {
+    return {
+      status: classifyFailure(error),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(trySendInvitationEmail, "trySendInvitationEmail");
+
+// src/commands/invite/create.ts
+var EMAIL_SENT_LABEL = {
+  sent: "yes",
+  failed: "no",
+  unconfirmed: "unconfirmed"
+};
+function assertEmailDelivered(emailRequested, outcome) {
+  if (!emailRequested || outcome.status === "sent") {
+    return;
+  }
+  throw new CliError(
+    outcome.status === "failed" ? `The invitation was created but --send-email failed: ${outcome.error}` : `The invitation was created but --send-email could not be confirmed: ${outcome.error}`
+  );
+}
+__name(assertEmailDelivered, "assertEmailDelivered");
+function registerInviteCreate(invite) {
+  invite.command("create").description("Invite one person to a team").requiredOption("--email <email>", "email address of the person to invite").option(
+    "--role <role>",
+    `team role to grant (default ${DEFAULT_TEAM_ROLE}, or ${TEAM_ROLE.CLARITY_MEMBER} with --process)`
+  ).option(
+    "--process <id>",
+    `invite them to this Clarity process instead of the whole team (defaults --role to ${TEAM_ROLE.CLARITY_MEMBER}, the only role a process invitation accepts)`
+  ).option(
+    "--send-email",
+    "also email the invitation to the recipient. Without it the invitation is created but nobody is notified"
+  ).option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
+    const email = trimRequired(options.email ?? "", "--email");
+    const processId = options.process === void 0 ? void 0 : trimRequired(options.process, "--process");
+    const defaultRole = processId === void 0 ? DEFAULT_TEAM_ROLE : TEAM_ROLE.CLARITY_MEMBER;
+    const role = assertTeamRole(options.role ?? defaultRole);
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const body = { email, role };
+    if (processId !== void 0) {
+      body.processId = processId;
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(teamId, "/invites"),
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    const parsed = createTeamInvitationResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      if (options.json) {
+        printJson(raw);
+        return;
+      }
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const emailRequested = options.sendEmail === true;
+    const emailOutcome = emailRequested ? await trySendInvitationEmail({
+      apiKey,
+      apiBaseUrl,
+      teamId,
+      inviteId: parsed.data.id
+    }) : { status: "failed", error: null };
+    if (options.json) {
+      printJson(raw);
+      assertEmailDelivered(emailRequested, emailOutcome);
+      return;
+    }
+    console.log(green("Invitation created!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Invitation ID", value: parsed.data.id },
+        { label: "Email", value: parsed.data.email },
+        { label: "Role", value: parsed.data.role },
+        { label: "Team", value: parsed.data.team.name },
+        { label: "Process", value: parsed.data.process?.name ?? "\u2014" },
+        { label: "Status", value: parsed.data.status },
+        { label: "Email sent", value: EMAIL_SENT_LABEL[emailOutcome.status] }
+      ])
+    );
+    if (!emailRequested) {
+      console.log();
+      console.log(
+        `Nobody has been notified yet. Send the email with: duvo invite resend ${parsed.data.id}`
+      );
+      return;
+    }
+    if (emailOutcome.status === "failed") {
+      console.log();
+      console.log(
+        `The invitation exists but the email was rejected, so nobody was notified: ${emailOutcome.error}`
+      );
+      console.log(`Send it with: duvo invite resend ${parsed.data.id}`);
+    }
+    if (emailOutcome.status === "unconfirmed") {
+      console.log();
+      console.log(
+        `The invitation exists but the email could not be confirmed: ${emailOutcome.error}`
+      );
+      console.log(
+        `It may or may not have been delivered. Check with the recipient before running: duvo invite resend ${parsed.data.id}`
+      );
+    }
+    assertEmailDelivered(emailRequested, emailOutcome);
+  }, "createAction"));
+}
+__name(registerInviteCreate, "registerInviteCreate");
+
+// src/commands/invite/delete.ts
+function registerInviteDelete(invite) {
+  invite.command("delete <id>").alias("revoke").description(
+    "Revoke a pending invitation so its link and email stop working"
+  ).option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(id, options) {
+    const inviteId = trimRequired(id, "<id>");
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    await confirmDestructive({
+      message: `Revoke invitation "${inviteId}"?`,
+      skip: options.yes === true
+    });
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: buildTeamPath(teamId, `/invites/${encodeURIComponent(inviteId)}`),
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = inviteSuccessResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green(`Invitation ${inviteId} revoked.`));
+  }, "deleteAction"));
+}
+__name(registerInviteDelete, "registerInviteDelete");
+
+// src/commands/invite/link.ts
+var LINK_PATH = "/team-invite-link";
+function registerGet(link) {
+  link.command("get").description("Show the team's shareable invite link").option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "GET",
+      path: buildTeamPath(teamId, LINK_PATH),
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = getTeamInviteLinkResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { hasLink, link: inviteLink } = parsed.data;
+    if (!hasLink || !inviteLink) {
+      console.log(
+        "No invite link yet. Create one with: duvo invite link create"
+      );
+      return;
+    }
+    console.log(
+      renderKeyValue([
+        { label: "Link ID", value: inviteLink.id },
+        { label: "URL", value: inviteLink.url ?? "\u2014" },
+        { label: "Created", value: inviteLink.createdAt },
+        {
+          label: "Created by",
+          value: inviteLink.createdBy.name ?? inviteLink.createdBy.email
+        }
+      ])
+    );
+  }, "getAction"));
+}
+__name(registerGet, "registerGet");
+function registerCreate2(link) {
+  link.command("create").description(
+    "Create or regenerate the team's shareable invite link (regenerating invalidates the previous URL)"
+  ).option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(teamId, LINK_PATH),
+      apiKey,
+      apiBaseUrl,
+      body: {}
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = createTeamInviteLinkResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Invite link ready!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Link ID", value: parsed.data.id },
+        { label: "URL", value: parsed.data.url ?? "\u2014" },
+        { label: "Created", value: parsed.data.createdAt }
+      ])
+    );
+    console.log();
+    console.log(
+      "Anyone with this URL can join the team. Any previous link no longer works."
+    );
+  }, "createAction"));
+}
+__name(registerCreate2, "registerCreate");
+function registerDelete2(link) {
+  link.command("delete").description("Delete the team's shareable invite link").option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    await confirmDestructive({
+      message: `Delete the invite link for team "${teamId}"?`,
+      skip: options.yes === true
+    });
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: buildTeamPath(teamId, LINK_PATH),
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log(green("Invite link deleted."));
+  }, "deleteAction"));
+}
+__name(registerDelete2, "registerDelete");
+function registerInviteLink(invite) {
+  const link = invite.command("link").description("Manage the team's shareable invite link");
+  registerGet(link);
+  registerCreate2(link);
+  registerDelete2(link);
+}
+__name(registerInviteLink, "registerInviteLink");
+
+// src/commands/invite/list.ts
+var TABLE_COLUMNS27 = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
+  { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
+  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+  {
+    header: "PROCESS",
+    cell: /* @__PURE__ */ __name((row) => row.process_id ?? "", "cell")
+  },
+  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at, "cell") }
+];
+function registerInviteList(invite) {
+  invite.command("list").description("List a team's pending invitations").option(
+    "--process <id>",
+    "list the pending invitations for this Clarity process instead of the team's own"
+  ).option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const searchParams = new URLSearchParams();
+    if (options.process !== void 0) {
+      searchParams.append(
+        "processId",
+        trimRequired(options.process, "--process")
+      );
+    }
+    const raw = await httpRequest({
+      method: "GET",
+      path: buildTeamPath(teamId, "/invites"),
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = listTeamInvitesResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { invitations } = parsed.data;
+    if (invitations.length === 0) {
+      console.log("No pending invitations found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS27, invitations));
+    console.log(`Showing ${invitations.length}`);
+  }, "listAction"));
+}
+__name(registerInviteList, "registerInviteList");
+
+// src/commands/invite/org-member.ts
+var ORG_ROLES2 = Object.values(ORG_ROLE);
+var DEFAULT_ROLE = ORG_ROLE.MEMBER;
+function registerInviteOrgMember(invite) {
+  invite.command("org-member <org-id>").description(
+    "Invite a person to an organization, optionally onto one of its teams"
+  ).requiredOption("--email <email>", "email address of the person to invite").option(
+    "--role <role>",
+    `organization role to grant: ${ORG_ROLES2.join(", ")} (default ${DEFAULT_ROLE})`,
+    DEFAULT_ROLE
+  ).option("--team-id <id>", "assign the invitee to this team in the org").option(
+    "--send-email",
+    "also email the invitation to the recipient. Without it the invitation is created but nobody is notified"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function inviteOrgMemberAction(orgId, options) {
+    const email = options.email?.trim();
+    if (email === void 0 || email.length === 0) {
+      throw new CliError("--email must not be empty");
+    }
+    const role = options.role ?? DEFAULT_ROLE;
+    if (!ORG_ROLES2.includes(role)) {
+      throw new CliError(
+        `Invalid --role "${role}"; expected one of: ${ORG_ROLES2.join(", ")}`
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const body = { email, role };
+    if (options.teamId !== void 0) {
+      const teamId = options.teamId.trim();
+      if (teamId.length === 0) {
+        throw new CliError("--team-id must not be empty");
+      }
+      body.teamId = teamId;
+    }
+    if (options.sendEmail === true) {
+      body.sendEmail = true;
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/organizations/${encodeURIComponent(orgId)}/members`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    const parsed = inviteOrgMemberResponseSchema.safeParse(raw);
+    if (options.json) {
+      printJson(raw);
+      if (options.sendEmail === true && parsed.success && !parsed.data.emailSent) {
+        throw new CliError(
+          `The invitation was created (${parsed.data.invitationId}) but --send-email did not deliver it.`
+        );
+      }
+      return;
+    }
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from POST /v2/organizations/:orgId/members: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Invitation created!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Invitation ID", value: parsed.data.invitationId },
+        { label: "Email", value: email },
+        { label: "Role", value: role },
+        { label: "Team", value: body.teamId ?? "\u2014" },
+        { label: "Email sent", value: parsed.data.emailSent ? "yes" : "no" }
+      ])
+    );
+    if (options.sendEmail === true && !parsed.data.emailSent) {
+      console.log();
+      throw new CliError(
+        `The invitation was created (${parsed.data.invitationId}) but --send-email did not deliver it. Send it from the organization members page.`
+      );
+    }
+  }, "inviteOrgMemberAction"));
+}
+__name(registerInviteOrgMember, "registerInviteOrgMember");
+
+// src/commands/invite/resend.ts
+function registerInviteResend(invite) {
+  invite.command("resend <id>").description("Email an invitation to its recipient").option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function resendAction(id, options) {
+    const inviteId = trimRequired(id, "<id>");
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(
+        teamId,
+        `/invites/${encodeURIComponent(inviteId)}/send-email`
+      ),
+      apiKey,
+      apiBaseUrl,
+      body: {}
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = inviteSuccessResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green(`Invitation ${inviteId} emailed.`));
+  }, "resendAction"));
+}
+__name(registerInviteResend, "registerInviteResend");
+
+// src/commands/invite/update.ts
+function registerInviteUpdate(invite) {
+  invite.command("update <id>").description("Change the role on a pending invitation").requiredOption("--role <role>", "new team role for the invitation").option(
+    "--team <id>",
+    "team ID (defaults to the team scoped to your credentials)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function updateAction(id, options) {
+    const inviteId = trimRequired(id, "<id>");
+    const role = assertTeamRole(trimRequired(options.role ?? "", "--role"));
+    const config = await requireAuthenticatedConfig(this);
+    const { apiKey, apiBaseUrl } = config;
+    const teamId = await resolveRequiredTeamId(config, {
+      override: options.team ?? getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: buildTeamPath(teamId, `/invites/${encodeURIComponent(inviteId)}`),
+      apiKey,
+      apiBaseUrl,
+      body: { role }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = updateTeamInviteResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Invitation updated!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Invitation ID", value: parsed.data.id },
+        { label: "Role", value: parsed.data.role }
+      ])
+    );
+  }, "updateAction"));
+}
+__name(registerInviteUpdate, "registerInviteUpdate");
+
+// src/commands/invite/index.ts
+function registerInvite(program) {
+  const invite = program.command("invite").description("Invite people to a team or organization");
+  registerInviteList(invite);
+  registerInviteCreate(invite);
+  registerInviteBulk(invite);
+  registerInviteUpdate(invite);
+  registerInviteResend(invite);
+  registerInviteDelete(invite);
+  registerInviteOrgMember(invite);
+  registerInviteLink(invite);
+}
+__name(registerInvite, "registerInvite");
+
 // src/commands/login.ts
 import { isCancel as isCancel4, log, password, spinner, text as text2 } from "@clack/prompts";
 
@@ -29422,7 +30577,7 @@ __name(parseNotificationTypeOption, "parseNotificationTypeOption");
 
 // src/commands/notifications/feed.ts
 var MIN_LIMIT11 = 1;
-var TABLE_COLUMNS27 = [
+var TABLE_COLUMNS28 = [
   { header: "KIND", cell: /* @__PURE__ */ __name((row) => row.kind, "cell") },
   {
     header: "ID",
@@ -29509,7 +30664,7 @@ function registerNotificationsFeed(notifications) {
       console.log("No feed items found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS27, items));
+    console.log(renderTable(TABLE_COLUMNS28, items));
     console.log(`Showing ${items.length}`);
     if (nextCursor) {
       console.log(
@@ -29616,7 +30771,7 @@ __name(registerNotificationsGet, "registerNotificationsGet");
 
 // src/commands/notifications/list.ts
 var MIN_LIMIT12 = 1;
-var TABLE_COLUMNS28 = [
+var TABLE_COLUMNS29 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "SEVERITY", cell: /* @__PURE__ */ __name((row) => row.severity, "cell") },
@@ -29750,7 +30905,7 @@ function registerNotificationsList(notifications) {
       console.log("No notifications found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, notifications2));
+    console.log(renderTable(TABLE_COLUMNS29, notifications2));
     console.log(`Showing ${notifications2.length}`);
     if (nextCursor) {
       console.log(
@@ -30105,7 +31260,7 @@ function parseHeaders(raw) {
   return result;
 }
 __name(parseHeaders, "parseHeaders");
-var TABLE_COLUMNS29 = [
+var TABLE_COLUMNS30 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
 ];
@@ -30163,7 +31318,7 @@ function registerOauthMcpProbe(mcp) {
       console.log("No tools advertised by this MCP server.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, rows));
+    console.log(renderTable(TABLE_COLUMNS30, rows));
     console.log(`Showing ${rows.length}`);
   }, "probeMcpAction"));
 }
@@ -30254,7 +31409,7 @@ function registerOauth(program) {
 __name(registerOauth, "registerOauth");
 
 // src/commands/plugins/list.ts
-var TABLE_COLUMNS30 = [
+var TABLE_COLUMNS31 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   {
@@ -30288,7 +31443,7 @@ function registerPluginsList(plugins) {
       console.log("No plugins found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS30, parsed.data.plugins));
+    console.log(renderTable(TABLE_COLUMNS31, parsed.data.plugins));
     console.log(`Showing ${parsed.data.plugins.length}`);
   }, "listAction"));
 }
@@ -30748,7 +31903,7 @@ function registerPulseAttachmentUrl(pulse) {
 __name(registerPulseAttachmentUrl, "registerPulseAttachmentUrl");
 
 // src/commands/pulse/connections.ts
-var TABLE_COLUMNS31 = [
+var TABLE_COLUMNS32 = [
   {
     header: "CONNECTION ID",
     cell: /* @__PURE__ */ __name((row) => row.connection_id, "cell")
@@ -30780,7 +31935,7 @@ function registerList4(connections) {
       console.log("No connections attached.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS31, parsed.data.connections));
+    console.log(renderTable(TABLE_COLUMNS32, parsed.data.connections));
   }, "listAction"));
 }
 __name(registerList4, "registerList");
@@ -31072,7 +32227,7 @@ __name(registerPulseHtml, "registerPulseHtml");
 var DEFAULT_LIMIT11 = 20;
 var MIN_LIMIT13 = 1;
 var MAX_LIMIT11 = 100;
-var TABLE_COLUMNS32 = [
+var TABLE_COLUMNS33 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   {
     header: "TITLE",
@@ -31134,7 +32289,7 @@ function registerPulseList(pulse) {
       console.log("No Pulse dashboards found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS32, response.artifacts));
+    console.log(renderTable(TABLE_COLUMNS33, response.artifacts));
     console.log(
       `Showing ${response.artifacts.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -31146,7 +32301,7 @@ __name(registerPulseList, "registerPulseList");
 var DEFAULT_LIMIT12 = 100;
 var MIN_LIMIT14 = 1;
 var MAX_LIMIT12 = 500;
-var TABLE_COLUMNS33 = [
+var TABLE_COLUMNS34 = [
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   {
     header: "CONTENT",
@@ -31194,7 +32349,7 @@ function registerPulseMessages(pulse) {
       console.log("No messages yet.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS33, data));
+    console.log(renderTable(TABLE_COLUMNS34, data));
     console.log(`Showing ${data.length} of ${total}`);
     if (hasMore) {
       console.log(
@@ -31747,7 +32902,7 @@ function registerPulse(program) {
 __name(registerPulse, "registerPulse");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS34 = [
+var TABLE_COLUMNS35 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -31763,9 +32918,9 @@ var TABLE_COLUMNS34 = [
 function registerQueueLabels(program) {
   const labels = program.command("queue-labels").description("Manage label vocabularies on a queue");
   registerList5(labels);
-  registerCreate2(labels);
+  registerCreate3(labels);
   registerUpdate2(labels);
-  registerDelete2(labels);
+  registerDelete3(labels);
 }
 __name(registerQueueLabels, "registerQueueLabels");
 function registerList5(labels) {
@@ -31801,12 +32956,12 @@ function registerList5(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS34, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS35, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
 __name(registerList5, "registerList");
-function registerCreate2(labels) {
+function registerCreate3(labels) {
   labels.command("create").description("Create a label on a queue without assigning it to a case").requiredOption("--queue <id>", "ID of the queue").option("--key <text>", "label key (omit for tag-only labels)").requiredOption("--value <text>", "label value (required, non-empty)").option("--color-hue <n>", "color hue 0-360 (auto-derived if omitted)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
     if (options.value.trim().length === 0) {
       throw new CliError("--value must not be empty");
@@ -31850,7 +33005,7 @@ function registerCreate2(labels) {
     );
   }, "createAction"));
 }
-__name(registerCreate2, "registerCreate");
+__name(registerCreate3, "registerCreate");
 function registerUpdate2(labels) {
   labels.command("update <label-id>").description(
     "Rename a label or change its color (affects every case it's assigned to)"
@@ -31913,7 +33068,7 @@ function registerUpdate2(labels) {
   }, "updateAction"));
 }
 __name(registerUpdate2, "registerUpdate");
-function registerDelete2(labels) {
+function registerDelete3(labels) {
   labels.command("delete <label-id>").description(
     "Delete a label from a queue (cascade-removes from every case it was assigned to)"
   ).requiredOption("--queue <id>", "ID of the queue the label belongs to").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(labelId, options) {
@@ -31944,7 +33099,7 @@ function registerDelete2(labels) {
     console.log(green("Label deleted!"));
   }, "deleteAction"));
 }
-__name(registerDelete2, "registerDelete");
+__name(registerDelete3, "registerDelete");
 var LABEL_PAGE_SIZE = 1e3;
 async function fetchCurrentLabelValue(queueId, labelId, apiKey, apiBaseUrl) {
   for (let offset = 0; ; offset += LABEL_PAGE_SIZE) {
@@ -32555,7 +33710,7 @@ __name(registerQueuesLinkAgent, "registerQueuesLinkAgent");
 var DEFAULT_LIMIT13 = 20;
 var MIN_LIMIT15 = 1;
 var MAX_LIMIT13 = 100;
-var TABLE_COLUMNS35 = [
+var TABLE_COLUMNS36 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -32603,7 +33758,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS35, response.queues));
+    console.log(renderTable(TABLE_COLUMNS36, response.queues));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.queues.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.queues.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -32861,7 +34016,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS36 = [
+var TABLE_COLUMNS37 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -32897,7 +34052,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS36, rows));
+    console.log(renderTable(TABLE_COLUMNS37, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -32970,7 +34125,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS37 = [
+var TABLE_COLUMNS38 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -33008,7 +34163,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS37, rows));
+    console.log(renderTable(TABLE_COLUMNS38, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -33024,91 +34179,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z127 } from "zod";
-var publicRunSchema = z127.object({
-  id: z127.string(),
-  agent_id: z127.string(),
-  build_id: z127.string(),
-  status: z127.string(),
-  source: z127.string().nullish(),
-  sandbox_id: z127.string().nullish(),
-  started_at: z127.string().nullish(),
-  completed_at: z127.string().nullish(),
-  created_at: z127.string(),
-  updated_at: z127.string().nullish(),
-  human_in_the_loop_enabled: z127.boolean().nullish()
-});
-var startRunResponseSchema = z127.object({
+import { z as z128 } from "zod";
+var publicRunSchema = z128.object({
+  id: z128.string(),
+  agent_id: z128.string(),
+  build_id: z128.string(),
+  status: z128.string(),
+  source: z128.string().nullish(),
+  sandbox_id: z128.string().nullish(),
+  started_at: z128.string().nullish(),
+  completed_at: z128.string().nullish(),
+  created_at: z128.string(),
+  updated_at: z128.string().nullish(),
+  human_in_the_loop_enabled: z128.boolean().nullish()
+});
+var startRunResponseSchema = z128.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z127.object({
-  label: z127.string(),
-  description: z127.string().nullish()
-});
-var questionSchema = z127.object({
-  question: z127.string(),
-  header: z127.string().nullish(),
-  options: z127.array(questionOptionSchema).nullish(),
-  multi_select: z127.boolean().nullish()
-});
-var pendingHumanRequestSchema = z127.object({
-  id: z127.string(),
-  title: z127.string(),
-  description: z127.string().nullish(),
-  created_at: z127.string(),
-  type: z127.string(),
-  questions: z127.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z127.object({
+var questionOptionSchema = z128.object({
+  label: z128.string(),
+  description: z128.string().nullish()
+});
+var questionSchema = z128.object({
+  question: z128.string(),
+  header: z128.string().nullish(),
+  options: z128.array(questionOptionSchema).nullish(),
+  multi_select: z128.boolean().nullish()
+});
+var pendingHumanRequestSchema = z128.object({
+  id: z128.string(),
+  title: z128.string(),
+  description: z128.string().nullish(),
+  created_at: z128.string(),
+  type: z128.string(),
+  questions: z128.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z128.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z127.object({
-  success: z127.boolean(),
-  message: z127.string().nullish()
-});
-var runMessageSchema = z127.object({
-  id: z127.string(),
-  type: z127.string(),
-  role: z127.string(),
-  timestamp: z127.string(),
-  text_content: z127.string().nullish(),
-  tool_call: z127.object({
-    id: z127.string(),
-    name: z127.string(),
-    arguments: z127.record(z127.string(), z127.unknown()).nullish()
+var stopRunResponseSchema = z128.object({
+  success: z128.boolean(),
+  message: z128.string().nullish()
+});
+var runMessageSchema = z128.object({
+  id: z128.string(),
+  type: z128.string(),
+  role: z128.string(),
+  timestamp: z128.string(),
+  text_content: z128.string().nullish(),
+  tool_call: z128.object({
+    id: z128.string(),
+    name: z128.string(),
+    arguments: z128.record(z128.string(), z128.unknown()).nullish()
   }).nullish(),
-  tool_result: z127.object({
-    tool_call_id: z127.string(),
-    result: z127.unknown().nullish(),
-    error: z127.string().nullish()
+  tool_result: z128.object({
+    tool_call_id: z128.string(),
+    result: z128.unknown().nullish(),
+    error: z128.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z127.object({
-  messages: z127.array(runMessageSchema),
-  total: z127.number().nullish(),
-  limit: z127.number().nullish(),
-  offset: z127.number().nullish()
+var listRunMessagesResponseSchema = z128.object({
+  messages: z128.array(runMessageSchema),
+  total: z128.number().nullish(),
+  limit: z128.number().nullish(),
+  offset: z128.number().nullish()
 });
-var postedMessageSchema = z127.object({
-  id: z127.string(),
-  type: z127.string(),
-  role: z127.string(),
-  timestamp: z127.string(),
-  text_content: z127.string()
+var postedMessageSchema = z128.object({
+  id: z128.string(),
+  type: z128.string(),
+  role: z128.string(),
+  timestamp: z128.string(),
+  text_content: z128.string()
 });
-var postRunMessageResponseSchema = z127.object({
+var postRunMessageResponseSchema = z128.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z127.object({
-  human_request: z127.object({
-    id: z127.string(),
-    run_id: z127.string(),
-    title: z127.string(),
-    description: z127.string().nullish(),
-    response: z127.string().nullish(),
-    responded_at: z127.string().nullish(),
-    created_at: z127.string()
+var respondHumanRequestResponseSchema = z128.object({
+  human_request: z128.object({
+    id: z128.string(),
+    run_id: z128.string(),
+    title: z128.string(),
+    description: z128.string().nullish(),
+    response: z128.string().nullish(),
+    responded_at: z128.string().nullish(),
+    created_at: z128.string()
   })
 });
 
@@ -33259,7 +34414,7 @@ var MAX_LIMIT14 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS38 = [
+var TABLE_COLUMNS39 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "RUN#", cell: /* @__PURE__ */ __name((row) => String(row.run_number), "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -33286,7 +34441,7 @@ function registerRunsList(runs) {
   runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT16}-${MAX_LIMIT14})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
     "--status <status>",
     "filter by status (e.g. running, completed, failed, waiting, interrupted, stopped, needs_attention)"
-  ).option("--agent <id>", "filter by agent ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
+  ).option("--agent <id>", "filter by agent ID").option("--automation <id>", "filter by automation ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
     "--has-issues <true|false>",
     `show only runs with (or without) issues (${HAS_ISSUES_VALUES.join("|")})`
   ).option(
@@ -33333,6 +34488,9 @@ function registerRunsList(runs) {
     if (options.agent !== void 0) {
       searchParams.append("agent_id", options.agent);
     }
+    if (options.automation !== void 0) {
+      searchParams.append("automation_id", options.automation);
+    }
     if (options.user !== void 0) {
       searchParams.append("user_id", options.user);
     }
@@ -33380,7 +34538,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS38, response.data));
+    console.log(renderTable(TABLE_COLUMNS39, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -33490,7 +34648,7 @@ var DEFAULT_LIMIT15 = 20;
 var MIN_LIMIT17 = 1;
 var MAX_LIMIT15 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS39 = [
+var TABLE_COLUMNS40 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -33555,7 +34713,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS39, response.messages));
+    console.log(renderTable(TABLE_COLUMNS40, response.messages));
     const resolvedOffset = response.offset ?? offset;
     const summary = response.total === null || response.total === void 0 ? `Showing ${response.messages.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.messages.length} of ${response.total} \xB7 offset ${resolvedOffset}`;
     console.log(summary);
@@ -33823,28 +34981,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z128 } from "zod";
-var createSandboxResponseSchema = z128.object({
-  sandbox_id: z128.string(),
-  expires_at: z128.string()
+import { z as z129 } from "zod";
+var createSandboxResponseSchema = z129.object({
+  sandbox_id: z129.string(),
+  expires_at: z129.string()
 });
-var createSandboxUploadUrlResponseSchema = z128.object({
-  upload_url: z128.string(),
-  path: z128.string(),
-  expires_in_seconds: z128.number()
+var createSandboxUploadUrlResponseSchema = z129.object({
+  upload_url: z129.string(),
+  path: z129.string(),
+  expires_in_seconds: z129.number()
 });
-var sandboxFileSchema = z128.object({
-  name: z128.string(),
-  path: z128.string(),
-  type: z128.enum(["file", "dir"]),
-  size_bytes: z128.number()
+var sandboxFileSchema = z129.object({
+  name: z129.string(),
+  path: z129.string(),
+  type: z129.enum(["file", "dir"]),
+  size_bytes: z129.number()
 });
-var listSandboxFilesResponseSchema = z128.object({
-  files: z128.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z129.object({
+  files: z129.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z128.object({
-  path: z128.string(),
-  size_bytes: z128.number()
+var uploadSandboxFileResponseSchema = z129.object({
+  path: z129.string(),
+  size_bytes: z129.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -33881,7 +35039,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS40 = [
+var TABLE_COLUMNS41 = [
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
@@ -33919,7 +35077,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS40, files));
+    console.log(renderTable(TABLE_COLUMNS41, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -34264,7 +35422,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS41 = [
+var TABLE_COLUMNS42 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -34308,7 +35466,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS41, rows));
+    console.log(renderTable(TABLE_COLUMNS42, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -34419,7 +35577,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS42 = [
+var TABLE_COLUMNS43 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -34447,7 +35605,7 @@ function registerSkillsAssignments(skills) {
       console.log("No agents use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS42, assignments));
+    console.log(renderTable(TABLE_COLUMNS43, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -34455,13 +35613,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { z as z129 } from "zod";
-var createSkillResponseSchema = z129.object({
-  skill: z129.object({
-    id: z129.string(),
-    name: z129.string(),
-    description: z129.string(),
-    team_id: z129.string()
+import { z as z130 } from "zod";
+var createSkillResponseSchema = z130.object({
+  skill: z130.object({
+    id: z130.string(),
+    name: z130.string(),
+    description: z130.string(),
+    team_id: z130.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -34740,7 +35898,7 @@ function registerSkillsFileUpdate(skills) {
 __name(registerSkillsFileUpdate, "registerSkillsFileUpdate");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS43 = [
+var TABLE_COLUMNS44 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -34779,7 +35937,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS43, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS44, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -34836,13 +35994,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z130 } from "zod";
-var installSkillResponseSchema = z130.object({
-  skill: z130.object({
-    id: z130.string(),
-    name: z130.string(),
-    description: z130.string(),
-    team_id: z130.string()
+import { z as z131 } from "zod";
+var installSkillResponseSchema = z131.object({
+  skill: z131.object({
+    id: z131.string(),
+    name: z131.string(),
+    description: z131.string(),
+    team_id: z131.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -34991,48 +36149,48 @@ function registerSkillsList(skills) {
 __name(registerSkillsList, "registerSkillsList");
 
 // src/api/skill-revision-schemas.ts
-import { z as z131 } from "zod";
-var skillRevisionSchema = z131.object({
-  id: z131.string(),
-  skill_id: z131.string(),
-  revision_number: z131.number().nullable(),
-  status: z131.enum(["draft", "live", "historic"]),
-  revision_name: z131.string().nullable(),
-  revision_description: z131.string().nullable(),
-  created_by: z131.string().nullable(),
-  created_by_name: z131.string().nullable(),
-  created_at: z131.string(),
-  updated_at: z131.string()
-});
-var listSkillRevisionsResponseSchema = z131.object({
-  revisions: z131.array(skillRevisionSchema),
-  total: z131.number().nullish(),
-  limit: z131.number().nullish(),
-  offset: z131.number().nullish()
-});
-var createSkillRevisionResponseSchema = z131.object({
+import { z as z132 } from "zod";
+var skillRevisionSchema = z132.object({
+  id: z132.string(),
+  skill_id: z132.string(),
+  revision_number: z132.number().nullable(),
+  status: z132.enum(["draft", "live", "historic"]),
+  revision_name: z132.string().nullable(),
+  revision_description: z132.string().nullable(),
+  created_by: z132.string().nullable(),
+  created_by_name: z132.string().nullable(),
+  created_at: z132.string(),
+  updated_at: z132.string()
+});
+var listSkillRevisionsResponseSchema = z132.object({
+  revisions: z132.array(skillRevisionSchema),
+  total: z132.number().nullish(),
+  limit: z132.number().nullish(),
+  offset: z132.number().nullish()
+});
+var createSkillRevisionResponseSchema = z132.object({
   revision: skillRevisionSchema,
-  created: z131.boolean()
+  created: z132.boolean()
 });
-var skillRevisionResponseSchema = z131.object({
+var skillRevisionResponseSchema = z132.object({
   revision: skillRevisionSchema
 });
-var deleteSkillRevisionResponseSchema = z131.object({
-  success: z131.boolean(),
-  message: z131.string()
+var deleteSkillRevisionResponseSchema = z132.object({
+  success: z132.boolean(),
+  message: z132.string()
 });
-var skillRevisionFileSchema = z131.object({
-  name: z131.string(),
-  path: z131.string(),
-  size: z131.number().optional(),
-  contentType: z131.string().optional(),
-  updatedAt: z131.string().optional()
+var skillRevisionFileSchema = z132.object({
+  name: z132.string(),
+  path: z132.string(),
+  size: z132.number().optional(),
+  contentType: z132.string().optional(),
+  updatedAt: z132.string().optional()
 });
-var listSkillRevisionFilesResponseSchema = z131.object({
-  files: z131.array(skillRevisionFileSchema),
-  limit: z131.number().nullish(),
-  has_more: z131.boolean().nullish(),
-  next_cursor: z131.string().nullish()
+var listSkillRevisionFilesResponseSchema = z132.object({
+  files: z132.array(skillRevisionFileSchema),
+  limit: z132.number().nullish(),
+  has_more: z132.boolean().nullish(),
+  next_cursor: z132.string().nullish()
 });
 
 // src/commands/skills/revisions/create.ts
@@ -35195,7 +36353,7 @@ __name(registerSkillsRevisionsFileUpdate, "registerSkillsRevisionsFileUpdate");
 var DEFAULT_LIMIT16 = 100;
 var MIN_LIMIT18 = 1;
 var MAX_LIMIT16 = 1e3;
-var TABLE_COLUMNS44 = [
+var TABLE_COLUMNS45 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -35257,7 +36415,7 @@ function registerSkillsRevisionsFiles(revisions) {
       );
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS44, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS45, parsed.data.files));
     console.log(
       nextCursor === null ? `Showing ${parsed.data.files.length}` : `Showing ${parsed.data.files.length} \xB7 more files remain \u2014 next page: --cursor ${nextCursor}`
     );
@@ -35269,7 +36427,7 @@ __name(registerSkillsRevisionsFiles, "registerSkillsRevisionsFiles");
 var DEFAULT_LIMIT17 = 20;
 var MIN_LIMIT19 = 1;
 var MAX_LIMIT17 = 100;
-var TABLE_COLUMNS45 = [
+var TABLE_COLUMNS46 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   {
     header: "VERSION",
@@ -35318,7 +36476,7 @@ function registerSkillsRevisionsList(revisions) {
       console.log("No revisions found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS45, response.revisions));
+    console.log(renderTable(TABLE_COLUMNS46, response.revisions));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.revisions.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.revisions.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -35508,13 +36666,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile10, stat as stat3 } from "node:fs/promises";
 import { basename as basename4 } from "node:path";
-import { z as z132 } from "zod";
-var uploadSkillResponseSchema = z132.object({
-  skill: z132.object({
-    id: z132.string(),
-    name: z132.string(),
-    description: z132.string(),
-    team_id: z132.string()
+import { z as z133 } from "zod";
+var uploadSkillResponseSchema = z133.object({
+  skill: z133.object({
+    id: z133.string(),
+    name: z133.string(),
+    description: z133.string(),
+    team_id: z133.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -35750,17 +36908,17 @@ function registerSuggestionsGet(suggestions) {
 __name(registerSuggestionsGet, "registerSuggestionsGet");
 
 // src/commands/suggestions/list.ts
-import { z as z133 } from "zod";
+import { z as z134 } from "zod";
 var DEFAULT_LIMIT18 = 100;
 var MIN_LIMIT20 = 1;
 var MAX_LIMIT18 = 250;
-var listEnvelopeSchema = z133.object({
-  data: z133.array(z133.unknown()),
-  pending_count: z133.number().int().nonnegative()
+var listEnvelopeSchema = z134.object({
+  data: z134.array(z134.unknown()),
+  pending_count: z134.number().int().nonnegative()
 });
 var STATUS_FILTERS = ["pending", "history"];
 var TITLE_PREVIEW_WIDTH2 = 50;
-var TABLE_COLUMNS46 = [
+var TABLE_COLUMNS47 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -35838,7 +36996,7 @@ function registerSuggestionsList(suggestions) {
       console.log(`Pending total: ${pendingCount}`);
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS46, data));
+    console.log(renderTable(TABLE_COLUMNS47, data));
     console.log(
       `Showing ${data.length} \xB7 offset ${offset} \xB7 pending total ${pendingCount}`
     );
@@ -35965,7 +37123,7 @@ __name(registerTeamGet, "registerTeamGet");
 var DEFAULT_LIMIT19 = 50;
 var MIN_LIMIT21 = 1;
 var MAX_LIMIT19 = 100;
-var TABLE_COLUMNS47 = [
+var TABLE_COLUMNS48 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name ?? "", "cell") },
   { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
@@ -36016,7 +37174,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS47, response.members));
+    console.log(renderTable(TABLE_COLUMNS48, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -36025,19 +37183,14 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z134 } from "zod";
+import { z as z135 } from "zod";
 var TEAM_ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var teamIdSchema = z134.string().regex(TEAM_ID_SHAPE);
+var teamIdSchema = z135.string().regex(TEAM_ID_SHAPE);
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
-    "Set the default team for the active OAuth profile (overridable per-command via --team or DUVO_TEAM_ID)"
+    "Set the default team for the active profile (overridable per-command via --team or DUVO_TEAM_ID)"
   ).action(/* @__PURE__ */ __name(async function useAction(teamId) {
     const auth = await requireAuthenticatedConfig(this);
-    if (auth.authType === "api-key") {
-      throw new CliError(
-        `This is an API-key profile \u2014 the team is baked into the key itself. Create or switch to an OAuth profile to use \`team use\`.`
-      );
-    }
     const parsedTeamId = teamIdSchema.safeParse(teamId);
     if (!parsedTeamId.success) {
       throw new CliError(
@@ -36050,16 +37203,17 @@ function registerTeamUse(team) {
       auth.apiBaseUrl
     );
     const config = await readConfig();
-    const profileFlag = getProfileFlag(this);
-    const profileName = profileFlag ?? config.defaultProfile;
+    const profileName = auth.profileName;
     if (!profileName) {
       throw new CliError(
-        "No active profile. Run `duvo login` first or pass --profile."
+        "Can't set a default team for an env-supplied credential (DUVO_API_KEY) \u2014 there's no stored profile to persist it to. Set DUVO_TEAM_ID instead, or store the key first with `duvo login --api-key`."
       );
     }
     const profile = config.profiles[profileName];
-    if (!profile || profile.type !== "oauth") {
-      throw new CliError(`Profile "${profileName}" is not an OAuth profile.`);
+    if (!profile) {
+      throw new CliError(
+        `Profile "${profileName}" does not exist. Run \`duvo profiles list\` to see available profiles.`
+      );
     }
     const updated = {
       ...config,
@@ -36113,10 +37267,10 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/create-org-team.ts
-import { z as z135 } from "zod";
-var createOrgTeamResponseSchema = z135.object({
-  id: z135.guid(),
-  name: z135.string()
+import { z as z136 } from "zod";
+var createOrgTeamResponseSchema = z136.object({
+  id: z136.guid(),
+  name: z136.string()
 });
 function registerTeamsCreateOrgTeam(teams) {
   teams.command("create-org-team <org-id>").description("Create a new team inside an organization you administer").requiredOption("--name <name>", "team name").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createOrgTeamAction(orgId, options) {
@@ -36153,87 +37307,15 @@ function registerTeamsCreateOrgTeam(teams) {
 }
 __name(registerTeamsCreateOrgTeam, "registerTeamsCreateOrgTeam");
 
-// src/commands/teams/invite-org-member.ts
-var ORG_ROLES2 = Object.values(ORG_ROLE);
-var DEFAULT_ROLE = ORG_ROLE.MEMBER;
-function registerTeamsInviteOrgMember(teams) {
-  teams.command("invite-org-member <org-id>").description(
-    "Invite a person to an organization, optionally onto one of its teams"
-  ).requiredOption("--email <email>", "email address of the person to invite").option(
-    "--role <role>",
-    `organization role to grant: ${ORG_ROLES2.join(", ")} (default ${DEFAULT_ROLE})`,
-    DEFAULT_ROLE
-  ).option("--team-id <id>", "assign the invitee to this team in the org").option(
-    "--frontend-url <url>",
-    "base URL used to build the invitation email link (email is skipped if omitted)"
-  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function inviteOrgMemberAction(orgId, options) {
-    const email = options.email?.trim();
-    if (email === void 0 || email.length === 0) {
-      throw new CliError("--email must not be empty");
-    }
-    const role = options.role ?? DEFAULT_ROLE;
-    if (!ORG_ROLES2.includes(role)) {
-      throw new CliError(
-        `Invalid --role "${role}"; expected one of: ${ORG_ROLES2.join(", ")}`
-      );
-    }
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    const body = { email, role };
-    if (options.teamId !== void 0) {
-      const teamId = options.teamId.trim();
-      if (teamId.length === 0) {
-        throw new CliError("--team-id must not be empty");
-      }
-      body.teamId = teamId;
-    }
-    if (options.frontendUrl !== void 0) {
-      const frontendUrl = options.frontendUrl.trim();
-      if (frontendUrl.length === 0) {
-        throw new CliError("--frontend-url must not be empty");
-      }
-      body.frontendUrl = frontendUrl;
-    }
-    const raw = await httpRequest({
-      method: "POST",
-      path: `/v2/organizations/${encodeURIComponent(orgId)}/members`,
-      apiKey,
-      apiBaseUrl,
-      body
-    });
-    if (options.json) {
-      printJson(raw);
-      return;
-    }
-    const parsed = inviteOrgMemberResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from POST /v2/organizations/:orgId/members: ${parsed.error.message}`
-      );
-    }
-    console.log(green("Invitation created!"));
-    console.log();
-    console.log(
-      renderKeyValue([
-        { label: "Invitation ID", value: parsed.data.invitationId },
-        { label: "Email", value: email },
-        { label: "Role", value: role },
-        { label: "Team", value: body.teamId ?? "\u2014" },
-        { label: "Email sent", value: parsed.data.emailSent ? "yes" : "no" }
-      ])
-    );
-  }, "inviteOrgMemberAction"));
-}
-__name(registerTeamsInviteOrgMember, "registerTeamsInviteOrgMember");
-
 // src/commands/teams/list.ts
-import { z as z136 } from "zod";
-var teamApiSchema2 = z136.object({
-  id: z136.string(),
-  name: z136.string(),
-  organization_id: z136.string().nullable()
+import { z as z137 } from "zod";
+var teamApiSchema2 = z137.object({
+  id: z137.string(),
+  name: z137.string(),
+  organization_id: z137.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z136.object({
-  teams: z136.array(teamApiSchema2)
+var listMyTeamsResponseSchema3 = z137.object({
+  teams: z137.array(teamApiSchema2)
 });
 function registerTeamsList(teams) {
   teams.command("list", { isDefault: true }).description("List every team you can act on").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -36276,21 +37358,21 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org-insights.ts
-import { z as z137 } from "zod";
-var headlineSchema = z137.object({
-  total_runs: z137.number(),
-  completed_runs: z137.number(),
-  failed_runs: z137.number(),
-  success_rate: z137.number().nullable(),
-  active_agents: z137.number(),
-  active_users: z137.number(),
-  start_date: z137.string(),
-  end_date: z137.string(),
-  truncated: z137.boolean(),
-  aggregated_teams: z137.number(),
-  total_teams: z137.number()
-});
-var orgInsightsHeadlineResponseSchema = z137.object({
+import { z as z138 } from "zod";
+var headlineSchema = z138.object({
+  total_runs: z138.number(),
+  completed_runs: z138.number(),
+  failed_runs: z138.number(),
+  success_rate: z138.number().nullable(),
+  active_agents: z138.number(),
+  active_users: z138.number(),
+  start_date: z138.string(),
+  end_date: z138.string(),
+  truncated: z138.boolean(),
+  aggregated_teams: z138.number(),
+  total_teams: z138.number()
+});
+var orgInsightsHeadlineResponseSchema = z138.object({
   headline: headlineSchema
 });
 function formatRate(rate) {
@@ -36358,26 +37440,26 @@ function registerTeamsOrgInsights(teams) {
 __name(registerTeamsOrgInsights, "registerTeamsOrgInsights");
 
 // src/commands/teams/org-metrics.ts
-import { z as z138 } from "zod";
-var teamMetricSchema = z138.object({
-  team_id: z138.string(),
-  team_name: z138.string(),
-  is_deleted: z138.boolean(),
-  member_count: z138.number(),
-  assignment_count: z138.number(),
-  scheduled_job_count: z138.number(),
-  total_jobs: z138.number(),
-  completed_jobs: z138.number(),
-  failed_jobs: z138.number(),
-  total_runs: z138.number()
-});
-var orgInsightsMetricsResponseSchema = z138.object({
-  teams: z138.array(teamMetricSchema),
-  start_date: z138.string(),
-  end_date: z138.string(),
-  truncated: z138.boolean(),
-  total_teams: z138.number(),
-  org_member_count: z138.number()
+import { z as z139 } from "zod";
+var teamMetricSchema = z139.object({
+  team_id: z139.string(),
+  team_name: z139.string(),
+  is_deleted: z139.boolean(),
+  member_count: z139.number(),
+  assignment_count: z139.number(),
+  scheduled_job_count: z139.number(),
+  total_jobs: z139.number(),
+  completed_jobs: z139.number(),
+  failed_jobs: z139.number(),
+  total_runs: z139.number()
+});
+var orgInsightsMetricsResponseSchema = z139.object({
+  teams: z139.array(teamMetricSchema),
+  start_date: z139.string(),
+  end_date: z139.string(),
+  truncated: z139.boolean(),
+  total_teams: z139.number(),
+  org_member_count: z139.number()
 });
 function registerTeamsOrgMetrics(teams) {
   teams.command("org-metrics <org-id>").description("Show per-team run metrics across an organization").option("--start-date <date>", "window start (ISO 8601, default 7d ago)").option("--end-date <date>", "window end (ISO 8601, default now)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function orgMetricsAction(orgId, options) {
@@ -36440,20 +37522,20 @@ ${total_teams} teams${suffix} \xB7 ${org_member_count} org members`
 __name(registerTeamsOrgMetrics, "registerTeamsOrgMetrics");
 
 // src/commands/teams/org-usage.ts
-import { z as z139 } from "zod";
+import { z as z140 } from "zod";
 var GRANULARITIES = ["day", "week", "month"];
 var DEFAULT_LOOKBACK_MS = 30 * 24 * 60 * 60 * 1e3;
-var bucketSchema = z139.object({
-  period: z139.string(),
-  total_runs: z139.number(),
-  scheduled_runs: z139.number(),
-  on_demand_runs: z139.number()
-});
-var usageChartResponseSchema = z139.object({
-  buckets: z139.array(bucketSchema),
-  granularity: z139.enum(GRANULARITIES),
-  truncated: z139.boolean(),
-  total_teams: z139.number()
+var bucketSchema = z140.object({
+  period: z140.string(),
+  total_runs: z140.number(),
+  scheduled_runs: z140.number(),
+  on_demand_runs: z140.number()
+});
+var usageChartResponseSchema = z140.object({
+  buckets: z140.array(bucketSchema),
+  granularity: z140.enum(GRANULARITIES),
+  truncated: z140.boolean(),
+  total_teams: z140.number()
 });
 function registerTeamsOrgUsage(teams) {
   teams.command("org-usage <org-id>").description("Show org-wide run volume over time (scheduled vs on-demand)").option("--start-date <date>", "window start (ISO 8601, default 30d ago)").option("--end-date <date>", "window end (ISO 8601, default now)").option(
@@ -36512,17 +37594,17 @@ function registerTeamsOrgUsage(teams) {
 __name(registerTeamsOrgUsage, "registerTeamsOrgUsage");
 
 // src/commands/teams/org.ts
-import { z as z140 } from "zod";
-var orgTeamSchema = z140.object({
-  id: z140.string(),
-  name: z140.string(),
-  userIsMember: z140.boolean(),
-  userRole: z140.string().nullable(),
-  memberCount: z140.number()
+import { z as z141 } from "zod";
+var orgTeamSchema = z141.object({
+  id: z141.string(),
+  name: z141.string(),
+  userIsMember: z141.boolean(),
+  userRole: z141.string().nullable(),
+  memberCount: z141.number()
 });
-var listOrgTeamsResponseSchema = z140.object({
-  teams: z140.array(orgTeamSchema),
-  total: z140.number()
+var listOrgTeamsResponseSchema = z141.object({
+  teams: z141.array(orgTeamSchema),
+  total: z141.number()
 });
 var SORT_BY_VALUES = ["createdAt", "name"];
 function registerTeamsOrg(teams) {
@@ -36583,17 +37665,17 @@ function registerTeamsOrg(teams) {
 __name(registerTeamsOrg, "registerTeamsOrg");
 
 // src/commands/teams/orgs.ts
-import { z as z141 } from "zod";
-var orgMembershipSchema = z141.object({
-  organization: z141.object({
-    id: z141.string(),
-    name: z141.string()
+import { z as z142 } from "zod";
+var orgMembershipSchema = z142.object({
+  organization: z142.object({
+    id: z142.string(),
+    name: z142.string()
   }),
-  role: z141.string(),
-  memberCount: z141.number()
+  role: z142.string(),
+  memberCount: z142.number()
 });
-var listMyOrganizationsResponseSchema = z141.object({
-  memberships: z141.array(orgMembershipSchema)
+var listMyOrganizationsResponseSchema = z142.object({
+  memberships: z142.array(orgMembershipSchema)
 });
 function registerTeamsOrgs(teams) {
   teams.command("orgs").description("List the organizations you belong to and your role in each").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function orgsAction(options) {
@@ -36640,7 +37722,6 @@ function registerTeams(program) {
   registerTeamsOrg(teams);
   registerTeamsOrgs(teams);
   registerTeamsCreateOrgTeam(teams);
-  registerTeamsInviteOrgMember(teams);
   registerTeamsOrgInsights(teams);
   registerTeamsOrgMetrics(teams);
   registerTeamsOrgUsage(teams);
@@ -36771,7 +37852,7 @@ __name(isStandaloneBinary, "isStandaloneBinary");
 import { createRequire } from "node:module";
 function getPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.45.2" };
+    return { name: "@duvoai/cli", version: "1.46.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../../package.json");
@@ -37002,15 +38083,25 @@ __name(updateNpmInstall, "updateNpmInstall");
 function registerWhoami(program) {
   program.command("whoami").description(
     "Print the active profile, the authenticated user's name and email, the team ID that subsequent commands will act on, and the auth type"
-  ).action(/* @__PURE__ */ __name(async function whoamiAction() {
+  ).option("--json", "output machine-readable JSON").action(/* @__PURE__ */ __name(async function whoamiAction(options) {
     const resolved = await requireAuthenticatedConfig(this);
+    const user = await fetchUser(resolved);
+    const teamId = await resolveActiveTeamId(resolved, getTeamFlag(this));
+    if (options.json) {
+      printJson({
+        profile: resolved.profileName,
+        user,
+        team: teamId,
+        authType: resolved.authType
+      });
+      return;
+    }
     const profileLabel = resolved.profileName ?? "(env-only, no stored profile)";
     console.log(`Profile   ${profileLabel}`);
-    const userLine = await fetchUserLine(resolved);
-    if (userLine !== null) {
+    if (user !== null) {
+      const userLine = user.name ? `${user.name} <${user.email}>` : user.email;
       console.log(`User      ${userLine}`);
     }
-    const teamId = await resolveActiveTeamId(resolved, getTeamFlag(this));
     if (teamId !== null) {
       console.log(`Team      ${teamId}`);
     }
@@ -37019,7 +38110,7 @@ function registerWhoami(program) {
   }, "whoamiAction"));
 }
 __name(registerWhoami, "registerWhoami");
-async function fetchUserLine(config) {
+async function fetchUser(config) {
   try {
     const raw = await httpRequest({
       method: "GET",
@@ -37031,13 +38122,13 @@ async function fetchUserLine(config) {
     if (!parsed.success) {
       return null;
     }
-    const { name, email } = parsed.data.profile;
-    return name ? `${name} <${email}>` : email;
+    const { id, name, email } = parsed.data.profile;
+    return { id, name, email };
   } catch {
     return null;
   }
 }
-__name(fetchUserLine, "fetchUserLine");
+__name(fetchUser, "fetchUser");
 async function resolveActiveTeamId(config, override) {
   try {
     return await resolveRequiredTeamId(config, { override });
@@ -37185,7 +38276,7 @@ function createProgram() {
     "use a specific profile for this invocation (overrides default profile)"
   ).option(
     "--team <id>",
-    "use a specific team for this invocation (overrides DUVO_TEAM_ID and profile default; API-key profiles are pinned to the key's team, so a different value is rejected by the server)"
+    "use a specific team for this invocation (overrides DUVO_TEAM_ID and profile default; team-scoped API keys stay pinned to the key's team)"
   ).addOption(
     new Option2(
       "--no-update-notifier",
@@ -37234,6 +38325,7 @@ ${notice}` : "";
   registerSuggestions(program);
   registerTeam(program);
   registerTeams(program);
+  registerInvite(program);
   registerSecrets(program);
   registerCredentials(program);
   registerRevisionSecrets(program);