@duvoai/cli 1.72.0 → 1.73.0

package/dist/bin/duvo.js

@@ -538,6 +538,7 @@ var CLARITY_INTERVIEW_LANGUAGES = [
   "cs",
   "de",
   "en",
+  "en-GB",
   "es",
   "es-MX",
   "fr",
@@ -556,7 +557,8 @@ var clarityInterviewLanguageResponseSchema = extensibleEnum(
   CLARITY_INTERVIEW_LANGUAGES
 ).default("en");
 var CLARITY_LANGUAGE_DISPLAY_NAMES = {
-  en: "English",
+  en: "English (United States)",
+  "en-GB": "English (United Kingdom)",
   cs: "Czech",
   fr: "French",
   de: "German",
@@ -6145,13 +6147,30 @@ var ORG_ROLE = {
   EXECUTIVE: "organization:executive",
   OWNER: "organization:owner",
   ADMIN: "organization:admin",
-  MEMBER: "organization:member"
+  MEMBER: "organization:member",
+  /**
+   * Belongs to a team of this organization, with no organization-level
+   * standing. Derived from team membership, never invited or assigned: the
+   * write paths are typed on {@link ORG_ROLES.ALL} (invitations) and
+   * {@link ORG_ROLES.SSO_ASSIGNABLE} (SSO defaults), neither of which
+   * contains it.
+   *
+   * A guest's reach is deliberately identical to a team member holding no
+   * membership row at all, with one exception: the organization appears in
+   * their switcher (`/organizations/mine` is self-scoped and ungated), where
+   * the row is rendered inert. See specs/org-owned-resources/PHASE_0_PLAN.md.
+   */
+  GUEST: "organization:guest"
 };
 var ORG_ROLE_CONFIG = {
   [ORG_ROLE.EXECUTIVE]: { parentRole: null },
   [ORG_ROLE.OWNER]: { parentRole: ORG_ROLE.EXECUTIVE },
   [ORG_ROLE.ADMIN]: { parentRole: ORG_ROLE.OWNER },
-  [ORG_ROLE.MEMBER]: { parentRole: ORG_ROLE.ADMIN }
+  [ORG_ROLE.MEMBER]: { parentRole: ORG_ROLE.ADMIN },
+  // Lowest tier: `hasMinimumOrgRole(GUEST, MEMBER)` is false, so a guest
+  // clears no role floor, while `canAssignOrgRole(ADMIN, GUEST)` is true so
+  // an admin can promote one.
+  [ORG_ROLE.GUEST]: { parentRole: ORG_ROLE.MEMBER }
 };
 var ORG_ROLES = {
   EXECUTIVE_ONLY: [ORG_ROLE.EXECUTIVE],
@@ -6161,6 +6180,23 @@ var ORG_ROLES = {
     ORG_ROLE.OWNER,
     ORG_ROLE.ADMIN
   ],
+  /**
+   * Every role that carries organization-level standing — the widest allowlist
+   * an org-scoped route may accept.
+   *
+   * `GUEST` is deliberately absent, and that omission is the whole of its
+   * access policy: `requireOrgRole` rejects any role missing from the list it
+   * is handed, so every current and future site gating on this array denies a
+   * guest by default. Adding `GUEST` here would silently grant guests the
+   * org-wide Clarity process landscape and ~20 other org-content reads. Don't.
+   *
+   * Need a place guest IS a legal value — e.g. a request body an admin may
+   * set it through — without touching this array? That's `MEMBER_ASSIGNABLE`
+   * below. Widening `ALL` for one such call site widens every authorization
+   * check built on it at the same time; that's exactly the bug this file's
+   * PR (`organization:guest`) had to fix twice already (the SSO login gate,
+   * the org-owned Pulse scope check) before landing on two separate arrays.
+   */
   ALL: [
     ORG_ROLE.EXECUTIVE,
     ORG_ROLE.OWNER,
@@ -6170,13 +6206,37 @@ var ORG_ROLES = {
   // Org roles an SSO connection may auto-grant to every user it admits.
   // Excludes executive/owner: default_org_role is applied unconditionally to
   // every SSO login, so those tiers must never be broadly granted by config.
-  SSO_ASSIGNABLE: [ORG_ROLE.ADMIN, ORG_ROLE.MEMBER]
+  // Excludes guest: it is derived from team membership, never configured.
+  SSO_ASSIGNABLE: [ORG_ROLE.ADMIN, ORG_ROLE.MEMBER],
+  /**
+   * Roles an admin may explicitly set on an *existing* member — `ALL` plus
+   * `GUEST`. Distinct from `ALL`: that array answers "does this role carry
+   * organization-level standing" (the authorization allowlist every org-scoped
+   * route gates on), while this answers "can a human pick this value for a
+   * member" — guest included, since assigning it is how an admin revokes a
+   * member's org-level access without removing them from their teams (it can
+   * only ever reduce reach, being the lowest tier). Invitations use `ALL`
+   * unchanged: guest can't be invited, only reached by joining a team or by
+   * this explicit downgrade.
+   */
+  MEMBER_ASSIGNABLE: [
+    ORG_ROLE.EXECUTIVE,
+    ORG_ROLE.OWNER,
+    ORG_ROLE.ADMIN,
+    ORG_ROLE.MEMBER,
+    ORG_ROLE.GUEST
+  ]
 };
 function isValidOrgRole(role) {
   return Object.values(ORG_ROLE).includes(role);
 }
 __name(isValidOrgRole, "isValidOrgRole");
 __name2(isValidOrgRole, "isValidOrgRole");
+function isOrgStandingRole(role) {
+  return ORG_ROLES.ALL.includes(role);
+}
+__name(isOrgStandingRole, "isOrgStandingRole");
+__name2(isOrgStandingRole, "isOrgStandingRole");
 function isSsoAssignableOrgRole(role) {
   return ORG_ROLES.SSO_ASSIGNABLE.includes(role);
 }
@@ -6201,7 +6261,14 @@ var TEAM_ROLE_BY_ORG_ROLE = {
   [ORG_ROLE.EXECUTIVE]: TEAM_ROLE.SUPERADMIN,
   [ORG_ROLE.OWNER]: TEAM_ROLE.OWNER,
   [ORG_ROLE.ADMIN]: TEAM_ROLE.SUPERADMIN,
-  [ORG_ROLE.MEMBER]: null
+  [ORG_ROLE.MEMBER]: null,
+  // Guest confers nothing, for the same reason MEMBER does not: it is a
+  // team-membership side effect with no organization-level standing. `null`
+  // rather than a missing key matters — callers test `=== null` and would let
+  // an `undefined` through as a team role (see `resolve-minted-team-role.ts`
+  // and `create-team-join-request.route.ts`), which the exhaustive `Record`
+  // exists to prevent.
+  [ORG_ROLE.GUEST]: null
 };
 function teamRoleForOrgRole(orgRole) {
   if (orgRole === null || !isValidOrgRole(orgRole)) {
@@ -9245,7 +9312,27 @@ var automationSummaryApiSchema = z41.object({
   agent_count: z41.int(),
   queue_count: z41.int(),
   created_at: z41.string(),
-  updated_at: z41.string()
+  updated_at: z41.string(),
+  // The wording below rests on `setup_started_at` being write-once AND
+  // demo-only: `markModuleSetupStarted` is its single writer, narrowed to a row
+  // that still has `demo_at`, and no path clears it. That is what makes the flag
+  // outlive the conversion, and what makes a list row carrying it an automation
+  // that is already set up.
+  //
+  // #10950 breaks both halves. `finish-setup` clears the column, so the flag
+  // stops outliving anything; `reopen-setup` and self-serve setup stamp it on a
+  // row whose `demo_at` is already NULL, so `is_setting_up` alone becomes the
+  // primary mid-setup state - the inverse of the worked example below, not just
+  // a change to how long it lasts.
+  //
+  // The agreed target is #10950's reading: `is_setting_up` means setup is
+  // CURRENTLY under way. This block is therefore the accurate description of
+  // today's code and not the destination - when #10950 lands, replace it with
+  // that meaning rather than merging the two. The text below is right only for
+  // as long as nothing clears the column.
+  is_setting_up: z41.boolean().default(false).describe(
+    "True once a team has started setting this Module up, and true from then on. setup_started_at is written once, by markModuleSetupStarted, and no path clears it, so this records that setup BEGAN rather than that it is still under way. Read together with is_demo, which lives on the detail response: both true is a demo with a build under way; is_demo alone is a demo nobody has begun; is_setting_up alone is an automation whose demo marker was cleared, which means it is already set up and running, NOT that it is still being set up. A list response carries only that last case, since the listing excludes demos - so is_setting_up on a list row is a record of past setup, and deciding whether a module is mid-setup needs is_demo from the detail. On the summary rather than the detail so that a client holding only a list, create or patch response knows the state too, and so every write onto the shared automation collection carries it. Defaulted rather than required: the client parses this response, so a backend that predates the column must not throw and take the automation's name down with it, and nothing on the wire has always meant an automation nobody has set up."
+  )
 });
 var automationsListApiSchema = z41.object({
   automations: z41.array(automationSummaryApiSchema),
@@ -9265,10 +9352,7 @@ var automationDetailApiSchema = automationSummaryApiSchema.extend({
   ),
   module_template_version: z41.int().nullable().describe("Version of that template, set alongside the slug."),
   is_demo: z41.boolean().describe(
-    "True while this is an unconverted Module demo: its data is sample data and it cannot run. Cleared by the Setup tab."
-  ),
-  is_setting_up: z41.boolean().default(false).describe(
-    "True once a team has started setting this Module up. Read together with is_demo: both true is a module being built from its setup interview, is_demo alone is an untouched demo. Stays true after setup, when is_demo is what has changed. Defaulted rather than required for the same reason `tabs` is optional: the client parses this response, so during a deploy window a backend that predates the field would otherwise throw and take the automation's name and revision state down with it."
+    "True while this is an unconverted Module demo: its data is sample data and it cannot run. Cleared when the demo is converted into a real automation, which is irreversible and either deletes the sample cases and Runs or closes them out as history. Starting setup does not clear it: that only records that setup began."
   ),
   has_draft: z41.boolean().describe(
     "Whether an open draft revision exists. Always false for an automation without revisions: an automation-level draft badge is a revision concept, and the agent builder surfaces its own draft build state."
@@ -10786,6 +10870,19 @@ var caseQueueSchema = z49.object({
   // links (e.g. the automation-shell redirect resolver).
   team_id: z49.string().nullable().optional(),
   created_at: z49.string(),
+  /**
+   * The user who created the queue, resolved to their profile. Null for a
+   * queue with no recorded creator — one created by an automation install or
+   * predating the column. Same shape as an agent's `created_by`, so a reader
+   * that renders one renders the other. Optional (additive) for the same
+   * reason as the fields above: existing fixtures and CLI callers must keep
+   * validating.
+   */
+  created_by: z49.object({
+    id: z49.string(),
+    name: z49.string().nullable(),
+    email: z49.string()
+  }).nullable().optional(),
   /**
    * True when at least one case in this queue has ever had an approval
    * batch (open, resolved, or cancelled). The frontend uses this to relabel
@@ -11215,12 +11312,7 @@ var inviteOrgMemberResponseSchema = z56.object({
   emailSent: z56.boolean()
 });
 var updateOrgMemberRoleRequestSchema = z56.object({
-  role: z56.enum([
-    "organization:executive",
-    "organization:owner",
-    "organization:admin",
-    "organization:member"
-  ])
+  role: z56.enum(ORG_ROLES.MEMBER_ASSIGNABLE)
 });
 var addOrgDomainRequestSchema = z56.object({
   domain: z56.string().min(3).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/)
@@ -14062,7 +14154,7 @@ __name(registerAgentsCaseTriggers, "registerAgentsCaseTriggers");
 // src/commands/agents/create.ts
 import { readFile as readFile2 } from "node:fs/promises";
 import { confirm as confirm2, isCancel as isCancel2, text } from "@clack/prompts";
-import { z as z120 } from "zod";
+import { z as z121 } from "zod";
 
 // src/api/agent-schemas.ts
 import { z as z68 } from "zod";
@@ -14341,14 +14433,15 @@ import { z as z108 } from "zod";
 import { z as z109 } from "zod";
 import { z as z110 } from "zod";
 import { z as z111 } from "zod";
-import { z as z113 } from "zod";
 import { z as z1122 } from "zod";
 import { z as z114 } from "zod";
+import { z as z113 } from "zod";
 import { z as z115 } from "zod";
 import { z as z116 } from "zod";
 import { z as z117 } from "zod";
 import { z as z118 } from "zod";
 import { z as z119 } from "zod";
+import { z as z120 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -18375,6 +18468,7 @@ var CLARITY_INTERVIEW_LANGUAGES2 = [
   "cs",
   "de",
   "en",
+  "en-GB",
   "es",
   "es-MX",
   "fr",
@@ -18393,7 +18487,8 @@ var clarityInterviewLanguageResponseSchema2 = extensibleEnum2(
   CLARITY_INTERVIEW_LANGUAGES2
 ).default("en");
 var CLARITY_LANGUAGE_DISPLAY_NAMES2 = {
-  en: "English",
+  en: "English (United States)",
+  "en-GB": "English (United Kingdom)",
   cs: "Czech",
   fr: "French",
   de: "German",
@@ -25030,13 +25125,30 @@ var ORG_ROLE2 = {
   EXECUTIVE: "organization:executive",
   OWNER: "organization:owner",
   ADMIN: "organization:admin",
-  MEMBER: "organization:member"
+  MEMBER: "organization:member",
+  /**
+   * Belongs to a team of this organization, with no organization-level
+   * standing. Derived from team membership, never invited or assigned: the
+   * write paths are typed on {@link ORG_ROLES.ALL} (invitations) and
+   * {@link ORG_ROLES.SSO_ASSIGNABLE} (SSO defaults), neither of which
+   * contains it.
+   *
+   * A guest's reach is deliberately identical to a team member holding no
+   * membership row at all, with one exception: the organization appears in
+   * their switcher (`/organizations/mine` is self-scoped and ungated), where
+   * the row is rendered inert. See specs/org-owned-resources/PHASE_0_PLAN.md.
+   */
+  GUEST: "organization:guest"
 };
 var ORG_ROLE_CONFIG2 = {
   [ORG_ROLE2.EXECUTIVE]: { parentRole: null },
   [ORG_ROLE2.OWNER]: { parentRole: ORG_ROLE2.EXECUTIVE },
   [ORG_ROLE2.ADMIN]: { parentRole: ORG_ROLE2.OWNER },
-  [ORG_ROLE2.MEMBER]: { parentRole: ORG_ROLE2.ADMIN }
+  [ORG_ROLE2.MEMBER]: { parentRole: ORG_ROLE2.ADMIN },
+  // Lowest tier: `hasMinimumOrgRole(GUEST, MEMBER)` is false, so a guest
+  // clears no role floor, while `canAssignOrgRole(ADMIN, GUEST)` is true so
+  // an admin can promote one.
+  [ORG_ROLE2.GUEST]: { parentRole: ORG_ROLE2.MEMBER }
 };
 var ORG_ROLES2 = {
   EXECUTIVE_ONLY: [ORG_ROLE2.EXECUTIVE],
@@ -25046,6 +25158,23 @@ var ORG_ROLES2 = {
     ORG_ROLE2.OWNER,
     ORG_ROLE2.ADMIN
   ],
+  /**
+   * Every role that carries organization-level standing — the widest allowlist
+   * an org-scoped route may accept.
+   *
+   * `GUEST` is deliberately absent, and that omission is the whole of its
+   * access policy: `requireOrgRole` rejects any role missing from the list it
+   * is handed, so every current and future site gating on this array denies a
+   * guest by default. Adding `GUEST` here would silently grant guests the
+   * org-wide Clarity process landscape and ~20 other org-content reads. Don't.
+   *
+   * Need a place guest IS a legal value — e.g. a request body an admin may
+   * set it through — without touching this array? That's `MEMBER_ASSIGNABLE`
+   * below. Widening `ALL` for one such call site widens every authorization
+   * check built on it at the same time; that's exactly the bug this file's
+   * PR (`organization:guest`) had to fix twice already (the SSO login gate,
+   * the org-owned Pulse scope check) before landing on two separate arrays.
+   */
   ALL: [
     ORG_ROLE2.EXECUTIVE,
     ORG_ROLE2.OWNER,
@@ -25055,13 +25184,37 @@ var ORG_ROLES2 = {
   // Org roles an SSO connection may auto-grant to every user it admits.
   // Excludes executive/owner: default_org_role is applied unconditionally to
   // every SSO login, so those tiers must never be broadly granted by config.
-  SSO_ASSIGNABLE: [ORG_ROLE2.ADMIN, ORG_ROLE2.MEMBER]
+  // Excludes guest: it is derived from team membership, never configured.
+  SSO_ASSIGNABLE: [ORG_ROLE2.ADMIN, ORG_ROLE2.MEMBER],
+  /**
+   * Roles an admin may explicitly set on an *existing* member — `ALL` plus
+   * `GUEST`. Distinct from `ALL`: that array answers "does this role carry
+   * organization-level standing" (the authorization allowlist every org-scoped
+   * route gates on), while this answers "can a human pick this value for a
+   * member" — guest included, since assigning it is how an admin revokes a
+   * member's org-level access without removing them from their teams (it can
+   * only ever reduce reach, being the lowest tier). Invitations use `ALL`
+   * unchanged: guest can't be invited, only reached by joining a team or by
+   * this explicit downgrade.
+   */
+  MEMBER_ASSIGNABLE: [
+    ORG_ROLE2.EXECUTIVE,
+    ORG_ROLE2.OWNER,
+    ORG_ROLE2.ADMIN,
+    ORG_ROLE2.MEMBER,
+    ORG_ROLE2.GUEST
+  ]
 };
 function isValidOrgRole2(role) {
   return Object.values(ORG_ROLE2).includes(role);
 }
 __name(isValidOrgRole2, "isValidOrgRole");
 __name3(isValidOrgRole2, "isValidOrgRole");
+function isOrgStandingRole2(role) {
+  return ORG_ROLES2.ALL.includes(role);
+}
+__name(isOrgStandingRole2, "isOrgStandingRole");
+__name3(isOrgStandingRole2, "isOrgStandingRole");
 function isSsoAssignableOrgRole2(role) {
   return ORG_ROLES2.SSO_ASSIGNABLE.includes(role);
 }
@@ -25086,7 +25239,14 @@ var TEAM_ROLE_BY_ORG_ROLE2 = {
   [ORG_ROLE2.EXECUTIVE]: TEAM_ROLE2.SUPERADMIN,
   [ORG_ROLE2.OWNER]: TEAM_ROLE2.OWNER,
   [ORG_ROLE2.ADMIN]: TEAM_ROLE2.SUPERADMIN,
-  [ORG_ROLE2.MEMBER]: null
+  [ORG_ROLE2.MEMBER]: null,
+  // Guest confers nothing, for the same reason MEMBER does not: it is a
+  // team-membership side effect with no organization-level standing. `null`
+  // rather than a missing key matters — callers test `=== null` and would let
+  // an `undefined` through as a team role (see `resolve-minted-team-role.ts`
+  // and `create-team-join-request.route.ts`), which the exhaustive `Record`
+  // exists to prevent.
+  [ORG_ROLE2.GUEST]: null
 };
 function teamRoleForOrgRole2(orgRole) {
   if (orgRole === null || !isValidOrgRole2(orgRole)) {
@@ -27680,7 +27840,12 @@ var toolExecutionPairSchema = z522.object({
   afterScreenshot: browserReplayScreenshotSchema.nullable()
 });
 var screenshotsTimelineResponseSchema = z522.object({
-  toolExecutions: z522.array(toolExecutionPairSchema)
+  toolExecutions: z522.array(toolExecutionPairSchema),
+  // Screenshots stored for the run, which exceeds the frames returned when the
+  // timeline is capped. Both fields are optional so a client parsing this
+  // schema still reads a response from a backend that predates the cap.
+  totalScreenshotCount: z522.number().int().nonnegative().optional(),
+  truncated: z522.boolean().optional()
 });
 var HUMAN_REQUEST_MIN_OPTIONS = 2;
 var HUMAN_REQUEST_MAX_OPTIONS = 6;
@@ -28965,12 +29130,7 @@ var inviteOrgMemberResponseSchema2 = z612.object({
   emailSent: z612.boolean()
 });
 var updateOrgMemberRoleRequestSchema2 = z612.object({
-  role: z612.enum([
-    "organization:executive",
-    "organization:owner",
-    "organization:admin",
-    "organization:member"
-  ])
+  role: z612.enum(ORG_ROLES2.MEMBER_ASSIGNABLE)
 });
 var addOrgDomainRequestSchema2 = z612.object({
   domain: z612.string().min(3).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/)
@@ -30403,6 +30563,58 @@ var agentChatMessageMetadataSchema = z722.object({
   }).optional(),
   /** Artifact produced/edited by this turn — renders the transcript chip. */
   artifact: agentChatMessageArtifactRefSchema2.optional(),
+  /**
+   * A New Pulse submission handed to Ask Duvo. The user pressed "Create Pulse"
+   * on the New Pulse page, so the request was collected outside the chat: the
+   * turn's hidden instruction tells the agent to call `create_pulse_artifact`,
+   * and this sidecar carries the arguments it must NOT author — the prompt
+   * verbatim (mention tags intact), the Connections picked in the composer,
+   * and the substrate the V1/V2 switch chose. The tool reads them server-side,
+   * exactly as `refinePulseDashboard` reads `pulse.selectedElement`, so a
+   * paraphrased prompt, a dropped `@queue` tag or an invented connection id is
+   * not expressible.
+   *
+   * Written only on the hidden turn row, so it is also the marker that says
+   * "this turn is a seeded creation" — see `resolveSeededPulseCreation`.
+   * Deliberately NOT in the response projection below: the readable copy of
+   * the request is the visible message the user already sees.
+   */
+  pulseCreation: z722.object({
+    prompt: z722.string().min(1).max(MAX_ARTIFACT_MESSAGE_CHARS2),
+    connectionIds: z722.array(z722.guid()).max(MAX_ARTIFACT_CONNECTIONS2),
+    /**
+     * Absent when PULSE_OPENUI is off for the team — the substrate then
+     * comes from the flag default, and a stored format would claim a
+     * substrate the page never offered.
+     */
+    contentFormat: pulseContentFormatSchema2.optional(),
+    /**
+     * The visible row carrying the same request, so the artifact ref lands
+     * on the message a reader can actually see (the transcript chip) rather
+     * than on the hidden instruction that produced it.
+     */
+    visibleMessageId: z722.guid(),
+    /**
+     * Set by whichever `create_pulse_artifact` call won the right to build
+     * this request's dashboard, BEFORE it starts building. The write is a
+     * conditional update that only succeeds while this field is unset, so
+     * two calls that overlap — parallel tool calls in one turn — cannot both
+     * proceed: the loser is told the dashboard is already being built rather
+     * than starting a second one. `fulfilledArtifactId` alone cannot do this
+     * job, because it is only knowable after the artifact exists, which is
+     * after the duplicate would already have been created.
+     *
+     * Cleared again if the build fails, so a real retry is not locked out.
+     */
+    fulfillmentClaimedAt: z722.iso.datetime().optional(),
+    /**
+     * The dashboard this request produced, stamped once it exists. A second
+     * `create_pulse_artifact` call on the same turn returns this dashboard
+     * instead of building another one — the model retrying (or "improving")
+     * its own successful call must not cost the user two dashboards.
+     */
+    fulfilledArtifactId: z722.guid().optional()
+  }).optional(),
   /**
    * Present when the SERVER composed this turn, rather than the party it is
    * attributed to having authored it. A flow preset collects its input outside
@@ -31021,7 +31233,27 @@ var automationSummaryApiSchema2 = z79.object({
   agent_count: z79.int(),
   queue_count: z79.int(),
   created_at: z79.string(),
-  updated_at: z79.string()
+  updated_at: z79.string(),
+  // The wording below rests on `setup_started_at` being write-once AND
+  // demo-only: `markModuleSetupStarted` is its single writer, narrowed to a row
+  // that still has `demo_at`, and no path clears it. That is what makes the flag
+  // outlive the conversion, and what makes a list row carrying it an automation
+  // that is already set up.
+  //
+  // #10950 breaks both halves. `finish-setup` clears the column, so the flag
+  // stops outliving anything; `reopen-setup` and self-serve setup stamp it on a
+  // row whose `demo_at` is already NULL, so `is_setting_up` alone becomes the
+  // primary mid-setup state - the inverse of the worked example below, not just
+  // a change to how long it lasts.
+  //
+  // The agreed target is #10950's reading: `is_setting_up` means setup is
+  // CURRENTLY under way. This block is therefore the accurate description of
+  // today's code and not the destination - when #10950 lands, replace it with
+  // that meaning rather than merging the two. The text below is right only for
+  // as long as nothing clears the column.
+  is_setting_up: z79.boolean().default(false).describe(
+    "True once a team has started setting this Module up, and true from then on. setup_started_at is written once, by markModuleSetupStarted, and no path clears it, so this records that setup BEGAN rather than that it is still under way. Read together with is_demo, which lives on the detail response: both true is a demo with a build under way; is_demo alone is a demo nobody has begun; is_setting_up alone is an automation whose demo marker was cleared, which means it is already set up and running, NOT that it is still being set up. A list response carries only that last case, since the listing excludes demos - so is_setting_up on a list row is a record of past setup, and deciding whether a module is mid-setup needs is_demo from the detail. On the summary rather than the detail so that a client holding only a list, create or patch response knows the state too, and so every write onto the shared automation collection carries it. Defaulted rather than required: the client parses this response, so a backend that predates the column must not throw and take the automation's name down with it, and nothing on the wire has always meant an automation nobody has set up."
+  )
 });
 var automationsListApiSchema2 = z79.object({
   automations: z79.array(automationSummaryApiSchema2),
@@ -31041,10 +31273,7 @@ var automationDetailApiSchema2 = automationSummaryApiSchema2.extend({
   ),
   module_template_version: z79.int().nullable().describe("Version of that template, set alongside the slug."),
   is_demo: z79.boolean().describe(
-    "True while this is an unconverted Module demo: its data is sample data and it cannot run. Cleared by the Setup tab."
-  ),
-  is_setting_up: z79.boolean().default(false).describe(
-    "True once a team has started setting this Module up. Read together with is_demo: both true is a module being built from its setup interview, is_demo alone is an untouched demo. Stays true after setup, when is_demo is what has changed. Defaulted rather than required for the same reason `tabs` is optional: the client parses this response, so during a deploy window a backend that predates the field would otherwise throw and take the automation's name and revision state down with it."
+    "True while this is an unconverted Module demo: its data is sample data and it cannot run. Cleared when the demo is converted into a real automation, which is irreversible and either deletes the sample cases and Runs or closes them out as history. Starting setup does not clear it: that only records that setup began."
   ),
   has_draft: z79.boolean().describe(
     "Whether an open draft revision exists. Always false for an automation without revisions: an automation-level draft badge is a revision concept, and the agent builder surfaces its own draft build state."
@@ -32662,6 +32891,19 @@ var caseQueueSchema2 = z922.object({
   // links (e.g. the automation-shell redirect resolver).
   team_id: z922.string().nullable().optional(),
   created_at: z922.string(),
+  /**
+   * The user who created the queue, resolved to their profile. Null for a
+   * queue with no recorded creator — one created by an automation install or
+   * predating the column. Same shape as an agent's `created_by`, so a reader
+   * that renders one renders the other. Optional (additive) for the same
+   * reason as the fields above: existing fixtures and CLI callers must keep
+   * validating.
+   */
+  created_by: z922.object({
+    id: z922.string(),
+    name: z922.string().nullable(),
+    email: z922.string()
+  }).nullable().optional(),
   /**
    * True when at least one case in this queue has ever had an approval
    * batch (open, resolved, or cancelled). The frontend uses this to relabel
@@ -33227,6 +33469,16 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Switches the evaluation judge model \u2014 the run-level judge (evaluate-agent-run) and the whole-case judge (case-evaluation-engine) \u2014 from the Sonnet default (EVALUATION_MODEL, claude-sonnet-5[1m]) to Kimi K3 served from Duvo's own GPU cluster (kimi-k3-duvo; LiteLLM fails over to the Fireworks deployment on cluster saturation or outage). Applies only when the team resolves to the `default` LLM provider: provider-pinned organizations keep the Sonnet judge, because kimi-k3-duvo has no deployment inside the pinned-provider key closure and the sandbox key would reject the request. Any provider or flag resolution failure fails safe to the Sonnet judge. The internal benchmark judges (ontology, workflow-builder) and AOP suggestion generation stay on EVALUATION_MODEL regardless. Judge scores are calibrated per model, so flipping this shifts the team's evaluation baseline \u2014 enable deliberately, per team. Off-by-default; also the kill-switch for the Kimi judge."
   },
+  HUMAN_OUTCOME_LABELS: {
+    key: "human_outcome_labels",
+    defaultValue: false,
+    description: "Private human outcome labels on completed Runs and Cases for internal reviewers. Enable per user. No runtime or judge effects."
+  },
+  IMPERSONATION: {
+    key: "impersonation",
+    defaultValue: true,
+    description: "Allows staff to impersonate users who belong to the targeted tenant. Default ON. Turn off as a team or organization override to refuse execute for any target who is a member of that tenant \u2014 impersonation is user-level, so one disabled tenant among the target's memberships blocks the session. User-level overrides are ignored (this is a tenant policy, not a per-person toggle). Creating and ending a session are not gated. An already-live session is not revoked; it expires on its existing deadline. The Impersonate control stays visible; execute returns 403."
+  },
   MAERSK_CONNECTION: {
     key: "maersk_connection",
     defaultValue: false,
@@ -33310,7 +33562,7 @@ var FEATURE_FLAG_CATALOGUE = {
   PULSE_EDIT_IN_ASK_DUVO: {
     key: "pulse_edit_in_ask_duvo",
     defaultValue: false,
-    description: "Routes the Pulse dashboard's 'Edit in chat' action to Ask Duvo instead of the native Pulse chat panel. When on, clicking 'Edit in chat' opens the Ask Duvo rail bound to the dashboard (so the agent can edit it and prior Pulse chat messages surface in-rail); when off, the button toggles the native in-page Pulse chat panel as before. Requires META_AGENT_ARTIFACTS. Off-by-default for staged rollout."
+    description: "Routes Pulse through Ask Duvo instead of the native Pulse chat panel. Covers both halves of a dashboard's life. Editing: clicking 'Edit in chat' opens the Ask Duvo rail bound to the dashboard (so the agent can edit it and prior Pulse chat messages surface in-rail); with the flag off the button toggles the native in-page Pulse chat panel as before. Creating: submitting a prompt on the New Pulse page opens an Ask Duvo conversation whose first message is that prompt and whose hidden companion turn makes the agent build the dashboard immediately, so the build narrates in the conversation instead of in silence; with the flag off New Pulse creates the dashboard directly and lands on its canvas. Text-only submissions take the Ask Duvo path \u2014 a submission carrying file attachments always creates directly, since the in-chat create tool cannot carry them. Requires META_AGENT_ARTIFACTS (which registers the in-chat create/edit tools; without it the agent falls back to the public createPulseDashboard tool and produces a dashboard with no binding and no in-chat progress) and AGENT_CHAT (the surface the conversation lands in). Off-by-default for staged rollout."
   },
   PULSE_OPENUI: {
     key: "pulse_openui",
@@ -33465,6 +33717,43 @@ var globalAdminDeleteResponseSchema = z101.object({
 var adminAccessCheckResponseSchema = z101.object({
   isGlobalAdmin: z101.boolean()
 });
+var humanOutcomeSubjectSchema = z1022.object({
+  kind: z1022.enum(["run", "case"]),
+  id: z1022.guid()
+});
+var humanOutcomeSchema = z1022.enum(["success", "failed"]);
+var humanOutcomeEvidenceSummarySchema = z1022.object({
+  evaluationId: z1022.guid().nullable(),
+  status: z1022.string(),
+  completedAt: z1022.string().nullable(),
+  messageCount: z1022.number().int().nonnegative(),
+  capturedAt: z1022.string()
+});
+var humanOutcomeLabelSchema = z1022.object({
+  id: z1022.guid(),
+  /** `null` means this row removed the label. */
+  outcome: humanOutcomeSchema.nullable(),
+  reason: z1022.string().nullable(),
+  evidenceFingerprint: z1022.string(),
+  /** The live subject no longer matches the evidence behind this label. */
+  evidenceChanged: z1022.boolean(),
+  createdAt: z1022.string()
+});
+var humanOutcomeStateSchema = z1022.object({
+  eligible: z1022.boolean(),
+  ineligibleReason: z1022.string().nullable(),
+  /** Echoed back on save so the server can detect changed evidence. */
+  evidenceFingerprint: z1022.string().nullable(),
+  summary: humanOutcomeEvidenceSummarySchema.nullable(),
+  current: humanOutcomeLabelSchema.nullable(),
+  history: z1022.array(humanOutcomeLabelSchema)
+});
+var humanOutcomeWriteSchema = z1022.object({
+  /** `null` removes the current label and keeps the history. */
+  outcome: humanOutcomeSchema.nullable(),
+  reason: z1022.string().trim().max(1e4).nullable(),
+  evidenceFingerprint: z1022.string().min(1)
+});
 function asRecord(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
@@ -33580,151 +33869,151 @@ function readDesktopStepParams(step) {
 __name(readDesktopStepParams, "readDesktopStepParams");
 __name3(readDesktopStepParams, "readDesktopStepParams");
 var JOB_LIST_SORT_COLUMNS2 = ["created_at"];
-var jobListSortColumnSchema2 = z1022.enum(JOB_LIST_SORT_COLUMNS2);
-var jobListIssueSeveritySchema2 = z1022.enum(
+var jobListSortColumnSchema2 = z103.enum(JOB_LIST_SORT_COLUMNS2);
+var jobListIssueSeveritySchema2 = z103.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES2
 );
-var jobListItemSchema2 = z1022.object({
-  id: z1022.guid(),
-  created_at: z1022.coerce.date(),
-  updated_at: z1022.coerce.date(),
-  started_at: z1022.coerce.date().nullable(),
-  completed_at: z1022.coerce.date().nullable(),
+var jobListItemSchema2 = z103.object({
+  id: z103.guid(),
+  created_at: z103.coerce.date(),
+  updated_at: z103.coerce.date(),
+  started_at: z103.coerce.date().nullable(),
+  completed_at: z103.coerce.date().nullable(),
   status: agentRunStatusSchema2,
-  source: z1022.string().nullable(),
-  title: z1022.string(),
-  run_number: z1022.number(),
+  source: z103.string().nullable(),
+  title: z103.string(),
+  run_number: z103.number(),
   // Agent info
-  agent_id: z1022.guid(),
-  agent_name: z1022.string(),
-  build_id: z1022.guid(),
+  agent_id: z103.guid(),
+  agent_name: z103.string(),
+  build_id: z103.guid(),
   // Automation info (null for runs whose agent doesn't belong to an automation)
-  automation_id: z1022.guid().nullable(),
-  automation_name: z1022.string().nullable(),
+  automation_id: z103.guid().nullable(),
+  automation_name: z103.string().nullable(),
   // User info
-  user_id: z1022.guid().nullable(),
+  user_id: z103.guid().nullable(),
   // Case info
-  case_queue_item_id: z1022.guid().nullable(),
-  case_queue_id: z1022.guid().nullable(),
-  case_queue_name: z1022.string().nullable(),
-  case_title: z1022.string().nullable(),
-  postponed_to: z1022.coerce.date().nullable(),
-  submitted_prompt_count: z1022.number().int().min(0),
+  case_queue_item_id: z103.guid().nullable(),
+  case_queue_id: z103.guid().nullable(),
+  case_queue_name: z103.string().nullable(),
+  case_title: z103.string().nullable(),
+  postponed_to: z103.coerce.date().nullable(),
+  submitted_prompt_count: z103.number().int().min(0),
   eval_summaries: evalSummarySchema2.nullable().optional()
 });
-var jobListResponseSchema2 = z1022.object({
-  data: z1022.array(jobListItemSchema2),
-  total: z1022.number()
+var jobListResponseSchema2 = z103.object({
+  data: z103.array(jobListItemSchema2),
+  total: z103.number()
 });
-var jobFilterOptionsSchema2 = z1022.object({
-  agents: z1022.array(
-    z1022.object({
-      id: z1022.string(),
-      name: z1022.string(),
-      folder_id: z1022.string().nullable()
+var jobFilterOptionsSchema2 = z103.object({
+  agents: z103.array(
+    z103.object({
+      id: z103.string(),
+      name: z103.string(),
+      folder_id: z103.string().nullable()
     })
   ),
-  folders: z1022.array(
-    z1022.object({
-      id: z1022.string(),
-      name: z1022.string(),
-      parent_folder_id: z1022.string().nullable()
+  folders: z103.array(
+    z103.object({
+      id: z103.string(),
+      name: z103.string(),
+      parent_folder_id: z103.string().nullable()
     })
   ),
-  users: z1022.array(
-    z1022.object({
-      id: z1022.string(),
-      name: z1022.string().nullable(),
-      email: z1022.string()
+  users: z103.array(
+    z103.object({
+      id: z103.string(),
+      name: z103.string().nullable(),
+      email: z103.string()
     })
   ),
-  caseQueues: z1022.array(z1022.object({ id: z1022.string(), name: z1022.string() })),
-  automations: z1022.array(z1022.object({ id: z1022.string(), name: z1022.string() }))
-});
-var stepModeSchema = z103.enum(["deterministic", "parameterized", "agent"]).describe("How replay executes this step");
-var credentialFieldSchema = z103.enum(["username", "password", "otp", "new-password"]).describe("Which login field this fill targets");
-var workflowParameterSchema = z103.object({
-  name: z103.string(),
-  type: z103.literal("string"),
-  description: z103.string(),
-  required: z103.boolean(),
-  example: z103.string().optional()
-});
-var outputCaptureSchema = z103.enum(["currentUrl", "elementText"]).describe("How the value is captured: page URL, or an element's text");
-var workflowOutputSchema = z103.object({
-  name: z103.string(),
+  caseQueues: z103.array(z103.object({ id: z103.string(), name: z103.string() })),
+  automations: z103.array(z103.object({ id: z103.string(), name: z103.string() }))
+});
+var stepModeSchema = z104.enum(["deterministic", "parameterized", "agent"]).describe("How replay executes this step");
+var credentialFieldSchema = z104.enum(["username", "password", "otp", "new-password"]).describe("Which login field this fill targets");
+var workflowParameterSchema = z104.object({
+  name: z104.string(),
+  type: z104.literal("string"),
+  description: z104.string(),
+  required: z104.boolean(),
+  example: z104.string().optional()
+});
+var outputCaptureSchema = z104.enum(["currentUrl", "elementText"]).describe("How the value is captured: page URL, or an element's text");
+var workflowOutputSchema = z104.object({
+  name: z104.string(),
   capture: outputCaptureSchema,
-  stepIndex: z103.number().int().nonnegative(),
-  selector: z103.string().optional().describe(
+  stepIndex: z104.number().int().nonnegative(),
+  selector: z104.string().optional().describe(
     "CSS selector to read text from; required when capture is 'elementText'"
   ),
-  description: z103.string()
+  description: z104.string()
 }).superRefine((output, ctx) => {
   if (output.capture === "elementText" && !output.selector) {
     ctx.addIssue({
-      code: z103.ZodIssueCode.custom,
+      code: z104.ZodIssueCode.custom,
       path: ["selector"],
       message: "elementText outputs must declare a selector"
     });
   }
 });
-var mcpStepSchema = z103.object({
-  tool: z103.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z103.record(z103.string(), z103.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z103.array(z103.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z103.string().optional().describe("Human-readable step description"),
-  screenshot: z103.string().optional().describe(
+var mcpStepSchema = z104.object({
+  tool: z104.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z104.record(z104.string(), z104.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z104.array(z104.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z104.string().optional().describe("Human-readable step description"),
+  screenshot: z104.string().optional().describe(
     "Path to this step's captured frame, relative to the skill root (e.g. `assets/screenshots/12.jpg`). Never inline image data \u2014 the frame is a separate asset in the skill bundle."
   ),
-  snapshot: z103.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  coordinates: z103.object({ x: z103.number(), y: z103.number() }).optional().describe(
+  snapshot: z104.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  coordinates: z104.object({ x: z104.number(), y: z104.number() }).optional().describe(
     "Where in the viewport the action happened, in CSS pixels relative to `viewport`. Presentation only \u2014 replay targets the element, never the point \u2014 so a player can mark the spot on this step's `screenshot`."
   ),
-  framePath: z103.array(z103.number()).optional().describe(
+  framePath: z104.array(z104.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   ),
   mode: stepModeSchema.optional().describe("Replay execution mode; absent is treated as deterministic"),
-  variable: z103.object({ name: z103.string() }).optional().describe(
+  variable: z104.object({ name: z104.string() }).optional().describe(
     "Binding key that replaces the recorded literal for parameterized steps"
   ),
   credentialField: credentialFieldSchema.optional().describe(
     "Set when this fill targets a login field. `username` / `password` / `otp` are resolved from the Login attached to the Agent (list_credentials, then fill_username / fill_password / fill_otp) \u2014 never from a recorded literal and never from a binding, so the secret stays out of model context. `new-password` is the opposite case: a password being *set* rather than signed in with, which must NOT come from the vault. It is tagged all the same so that no password box is ever declared as a bindable parameter."
   )
 });
-var workflowProviderSchema = z103.enum(["browsing", "computer_use"]).describe("Replay surface: browser vs computer-use desktop");
-var mcpWorkflowSchema = z103.object({
-  name: z103.string(),
+var workflowProviderSchema = z104.enum(["browsing", "computer_use"]).describe("Replay surface: browser vs computer-use desktop");
+var mcpWorkflowSchema = z104.object({
+  name: z104.string(),
   // Browser-only: the page the recording started on. Optional so computer-use
   // workflows (which have no URL) share this schema; required for browsing via
   // the refine below.
-  startUrl: z103.string().optional(),
+  startUrl: z104.string().optional(),
   // For browsing this is the browser viewport; for computer_use it is the
   // recorded desktop size. Same field, provider-specific meaning.
-  viewport: z103.object({
-    width: z103.number(),
-    height: z103.number()
+  viewport: z104.object({
+    width: z104.number(),
+    height: z104.number()
   }),
   // Optional (not defaulted) so existing browser workflows and every McpWorkflow
   // constructor stay valid without naming it; absent means "browsing".
   provider: workflowProviderSchema.optional(),
-  computer_use_backend: z103.enum(["sandbox", "rdp"]).optional().describe("Which computer-use backend recorded this workflow"),
-  steps: z103.array(mcpStepSchema),
-  version: z103.union([z103.literal(1), z103.literal(2)]).optional().describe(
+  computer_use_backend: z104.enum(["sandbox", "rdp"]).optional().describe("Which computer-use backend recorded this workflow"),
+  steps: z104.array(mcpStepSchema),
+  version: z104.union([z104.literal(1), z104.literal(2)]).optional().describe(
     "Workflow schema version: absent/1 = legacy, 2 = classified for deterministic workflow execution. Unknown versions are rejected rather than silently treated as legacy."
   ),
-  parameters: z103.array(workflowParameterSchema).optional().describe("Typed parameters the agent binds at replay"),
-  outputs: z103.array(workflowOutputSchema).optional().describe("Values the replay captures and returns to the agent")
+  parameters: z104.array(workflowParameterSchema).optional().describe("Typed parameters the agent binds at replay"),
+  outputs: z104.array(workflowOutputSchema).optional().describe("Values the replay captures and returns to the agent")
 }).superRefine((workflow, ctx) => {
   if ((workflow.provider ?? "browsing") === "browsing" && !workflow.startUrl) {
     ctx.addIssue({
-      code: z103.ZodIssueCode.custom,
+      code: z104.ZodIssueCode.custom,
       path: ["startUrl"],
       message: "browsing workflows must declare a startUrl"
     });
   }
   if (workflow.computer_use_backend !== void 0 && workflow.provider !== "computer_use") {
     ctx.addIssue({
-      code: z103.ZodIssueCode.custom,
+      code: z104.ZodIssueCode.custom,
       path: ["computer_use_backend"],
       message: "computer_use_backend requires provider: computer_use"
     });
@@ -33732,7 +34021,7 @@ var mcpWorkflowSchema = z103.object({
   workflow.steps.forEach((step, index) => {
     if (step.mode === "parameterized" && !step.variable) {
       ctx.addIssue({
-        code: z103.ZodIssueCode.custom,
+        code: z104.ZodIssueCode.custom,
         path: ["steps", index, "variable"],
         message: "parameterized steps must declare a variable binding"
       });
@@ -33742,7 +34031,7 @@ var mcpWorkflowSchema = z103.object({
   (workflow.outputs ?? []).forEach((output, i) => {
     if (seenOutputNames.has(output.name)) {
       ctx.addIssue({
-        code: z103.ZodIssueCode.custom,
+        code: z104.ZodIssueCode.custom,
         path: ["outputs", i, "name"],
         message: "output names must be unique"
       });
@@ -33750,14 +34039,14 @@ var mcpWorkflowSchema = z103.object({
     seenOutputNames.add(output.name);
     if (output.stepIndex >= workflow.steps.length) {
       ctx.addIssue({
-        code: z103.ZodIssueCode.custom,
+        code: z104.ZodIssueCode.custom,
         path: ["outputs", i, "stepIndex"],
         message: "output stepIndex is out of range"
       });
     }
   });
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z103.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z104.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -33766,38 +34055,38 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   2
 );
 var ORG_BROWSER_CONFIG_VERSION = 1;
-var organizationBrowserConfigDataSchema = z104.object({
+var organizationBrowserConfigDataSchema = z105.object({
   browserProvider: BrowserProviderTypeSchema2.nullable(),
   dataResidency: DataResidencySchema2.nullable(),
   dataHandling: DataHandlingSchema2.nullable(),
-  enforced: z104.boolean(),
+  enforced: z105.boolean(),
   egressMode: browserEgressModeSchema2.nullable().optional()
 });
-var organizationBrowserConfigSchema = z104.object({
-  version: z104.literal(ORG_BROWSER_CONFIG_VERSION),
+var organizationBrowserConfigSchema = z105.object({
+  version: z105.literal(ORG_BROWSER_CONFIG_VERSION),
   data: organizationBrowserConfigDataSchema
 });
-var organizationBrowserSettingsSchema = z104.object({
-  organizationId: z104.guid(),
+var organizationBrowserSettingsSchema = z105.object({
+  organizationId: z105.guid(),
   browserProvider: BrowserProviderTypeSchema2.nullable(),
   dataResidency: DataResidencySchema2.nullable(),
   dataHandling: DataHandlingSchema2.nullable(),
-  enforced: z104.boolean(),
+  enforced: z105.boolean(),
   egressMode: browserEgressModeSchema2.nullable().optional(),
-  createdAt: z104.string(),
-  updatedAt: z104.string()
+  createdAt: z105.string(),
+  updatedAt: z105.string()
 });
-var getOrganizationBrowserSettingsResponseSchema = z104.object({
+var getOrganizationBrowserSettingsResponseSchema = z105.object({
   settings: organizationBrowserSettingsSchema.nullable()
 });
-var updateOrganizationBrowserSettingsRequestSchema = z104.object({
+var updateOrganizationBrowserSettingsRequestSchema = z105.object({
   browserProvider: BrowserProviderTypeSchema2.nullable().optional(),
   dataResidency: DataResidencySchema2.nullable().optional(),
   dataHandling: DataHandlingSchema2.nullable().optional(),
-  enforced: z104.boolean().optional(),
+  enforced: z105.boolean().optional(),
   egressMode: browserEgressModeSchema2.nullable().optional()
 });
-var updateOrganizationBrowserSettingsResponseSchema = z104.object({
+var updateOrganizationBrowserSettingsResponseSchema = z105.object({
   settings: organizationBrowserSettingsSchema
 });
 var DEPLOYMENT_REGION_FACETS = [
@@ -33807,22 +34096,22 @@ var DEPLOYMENT_REGION_FACETS = [
   "storage",
   "analytics"
 ];
-var deploymentRegionFacetSchema = z105.enum(DEPLOYMENT_REGION_FACETS);
+var deploymentRegionFacetSchema = z106.enum(DEPLOYMENT_REGION_FACETS);
 var ORG_DEPLOYMENT_CONFIG_VERSION = 1;
-var deploymentFacetOverridesSchema = z105.object({
+var deploymentFacetOverridesSchema = z106.object({
   sandbox: DataResidencySchema2.nullable(),
   inference: DataResidencySchema2.nullable(),
   storage: DataResidencySchema2.nullable(),
   analytics: DataResidencySchema2.nullable()
 });
 var MAX_DEPLOYMENT_NOTES_LENGTH = 2e3;
-var organizationDeploymentConfigDataSchema = z105.object({
+var organizationDeploymentConfigDataSchema = z106.object({
   facetOverrides: deploymentFacetOverridesSchema,
-  analyticsEnabled: z105.boolean(),
-  notes: z105.string().max(MAX_DEPLOYMENT_NOTES_LENGTH).nullable()
+  analyticsEnabled: z106.boolean(),
+  notes: z106.string().max(MAX_DEPLOYMENT_NOTES_LENGTH).nullable()
 });
-var organizationDeploymentConfigSchema = z105.object({
-  version: z105.literal(ORG_DEPLOYMENT_CONFIG_VERSION),
+var organizationDeploymentConfigSchema = z106.object({
+  version: z106.literal(ORG_DEPLOYMENT_CONFIG_VERSION),
   data: organizationDeploymentConfigDataSchema
 });
 var DEPLOYMENT_REGION_SOURCES = [
@@ -33830,12 +34119,12 @@ var DEPLOYMENT_REGION_SOURCES = [
   "org-umbrella",
   "platform-default"
 ];
-var resolvedDeploymentRegionSchema = z105.object({
+var resolvedDeploymentRegionSchema = z106.object({
   value: DataResidencySchema2,
-  source: z105.enum(DEPLOYMENT_REGION_SOURCES),
-  divergesFromUmbrella: z105.boolean()
+  source: z106.enum(DEPLOYMENT_REGION_SOURCES),
+  divergesFromUmbrella: z106.boolean()
 });
-var platformRegionDefaultsSchema = z105.object({
+var platformRegionDefaultsSchema = z106.object({
   browser: DataResidencySchema2,
   sandbox: DataResidencySchema2,
   inference: DataResidencySchema2,
@@ -33893,108 +34182,108 @@ var ORGANIZATION_TAG_COLORS = [
   "pink",
   "teal"
 ];
-var organizationTagColorSchema = z105.enum(ORGANIZATION_TAG_COLORS);
+var organizationTagColorSchema = z106.enum(ORGANIZATION_TAG_COLORS);
 function normalizeTagSlug(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_TAG_SLUG_LENGTH);
 }
 __name(normalizeTagSlug, "normalizeTagSlug");
 __name3(normalizeTagSlug, "normalizeTagSlug");
-var organizationTagSchema = z105.object({
-  id: z105.guid(),
-  slug: z105.string(),
-  label: z105.string(),
+var organizationTagSchema = z106.object({
+  id: z106.guid(),
+  slug: z106.string(),
+  label: z106.string(),
   color: organizationTagColorSchema,
-  description: z105.string().nullable(),
-  createdAt: z105.string(),
-  updatedAt: z105.string()
+  description: z106.string().nullable(),
+  createdAt: z106.string(),
+  updatedAt: z106.string()
 });
-var createOrganizationTagRequestSchema = z105.object({
-  label: z105.string().min(1).max(MAX_TAG_LABEL_LENGTH),
-  slug: z105.string().min(1).max(MAX_TAG_SLUG_LENGTH).optional(),
+var createOrganizationTagRequestSchema = z106.object({
+  label: z106.string().min(1).max(MAX_TAG_LABEL_LENGTH),
+  slug: z106.string().min(1).max(MAX_TAG_SLUG_LENGTH).optional(),
   color: organizationTagColorSchema,
-  description: z105.string().max(MAX_TAG_DESCRIPTION_LENGTH).nullable().optional()
+  description: z106.string().max(MAX_TAG_DESCRIPTION_LENGTH).nullable().optional()
 });
-var updateOrganizationTagRequestSchema = z105.object({
-  label: z105.string().min(1).max(MAX_TAG_LABEL_LENGTH).optional(),
+var updateOrganizationTagRequestSchema = z106.object({
+  label: z106.string().min(1).max(MAX_TAG_LABEL_LENGTH).optional(),
   color: organizationTagColorSchema.optional(),
-  description: z105.string().max(MAX_TAG_DESCRIPTION_LENGTH).nullable().optional()
+  description: z106.string().max(MAX_TAG_DESCRIPTION_LENGTH).nullable().optional()
 });
-var listOrganizationTagsResponseSchema = z105.object({
-  tags: z105.array(organizationTagSchema)
+var listOrganizationTagsResponseSchema = z106.object({
+  tags: z106.array(organizationTagSchema)
 });
-var organizationTagResponseSchema = z105.object({
+var organizationTagResponseSchema = z106.object({
   tag: organizationTagSchema
 });
-var organizationDeploymentProfileSchema = z105.object({
-  organizationId: z105.guid(),
+var organizationDeploymentProfileSchema = z106.object({
+  organizationId: z106.guid(),
   dataRegion: DataResidencySchema2.nullable(),
   sandboxRegion: DataResidencySchema2.nullable(),
   inferenceRegion: DataResidencySchema2.nullable(),
   storageRegion: DataResidencySchema2.nullable(),
   analyticsRegion: DataResidencySchema2.nullable(),
-  analyticsEnabled: z105.boolean(),
-  notes: z105.string().nullable(),
-  createdAt: z105.string(),
-  updatedAt: z105.string()
+  analyticsEnabled: z106.boolean(),
+  notes: z106.string().nullable(),
+  createdAt: z106.string(),
+  updatedAt: z106.string()
 });
-var updateOrganizationDeploymentProfileRequestSchema = z105.object({
+var updateOrganizationDeploymentProfileRequestSchema = z106.object({
   /**
    * Optional tag assignment, applied in the same transaction as the profile.
    * The drawer saves both at once; two sequential requests could leave the
    * profile written and the tags not, while the UI reported a failed save.
    */
-  tagIds: z105.array(z105.guid()).max(50).optional(),
+  tagIds: z106.array(z106.guid()).max(50).optional(),
   dataRegion: DataResidencySchema2.nullable().optional(),
   sandboxRegion: DataResidencySchema2.nullable().optional(),
   inferenceRegion: DataResidencySchema2.nullable().optional(),
   storageRegion: DataResidencySchema2.nullable().optional(),
   analyticsRegion: DataResidencySchema2.nullable().optional(),
-  analyticsEnabled: z105.boolean().optional(),
-  notes: z105.string().max(MAX_DEPLOYMENT_NOTES_LENGTH).nullable().optional()
+  analyticsEnabled: z106.boolean().optional(),
+  notes: z106.string().max(MAX_DEPLOYMENT_NOTES_LENGTH).nullable().optional()
 });
-var organizationDeploymentProfileResponseSchema = z105.object({
+var organizationDeploymentProfileResponseSchema = z106.object({
   profile: organizationDeploymentProfileSchema,
   /** Present only when the request also set `tagIds`. */
-  tags: z105.array(organizationTagSchema).optional()
+  tags: z106.array(organizationTagSchema).optional()
 });
-var runVolumeSchema = z105.object({
-  last7Days: z105.number().int().nonnegative(),
-  last30Days: z105.number().int().nonnegative()
+var runVolumeSchema = z106.object({
+  last7Days: z106.number().int().nonnegative(),
+  last30Days: z106.number().int().nonnegative()
 });
-var resolvedRegionsSchema = z105.object({
+var resolvedRegionsSchema = z106.object({
   browser: resolvedDeploymentRegionSchema,
   sandbox: resolvedDeploymentRegionSchema,
   inference: resolvedDeploymentRegionSchema,
   storage: resolvedDeploymentRegionSchema,
   analytics: resolvedDeploymentRegionSchema
 });
-var deploymentOrgFlagsSchema = z105.object({
-  enterpriseBillingEnabled: z105.boolean(),
-  connectionsSharingEnabled: z105.boolean(),
-  discoveryMode: z105.string(),
-  analyticsEnabled: z105.boolean(),
-  browserSettingsEnforced: z105.boolean(),
-  hasVpnConfig: z105.boolean(),
-  hasSsoConnection: z105.boolean()
-});
-var deploymentOrgRowSchema = z105.object({
-  organizationId: z105.guid(),
-  name: z105.string(),
-  deletedAt: z105.string().nullable(),
-  llmProvider: z105.enum(LLM_PROVIDERS),
-  browserProvider: z105.string().nullable(),
+var deploymentOrgFlagsSchema = z106.object({
+  enterpriseBillingEnabled: z106.boolean(),
+  connectionsSharingEnabled: z106.boolean(),
+  discoveryMode: z106.string(),
+  analyticsEnabled: z106.boolean(),
+  browserSettingsEnforced: z106.boolean(),
+  hasVpnConfig: z106.boolean(),
+  hasSsoConnection: z106.boolean()
+});
+var deploymentOrgRowSchema = z106.object({
+  organizationId: z106.guid(),
+  name: z106.string(),
+  deletedAt: z106.string().nullable(),
+  llmProvider: z106.enum(LLM_PROVIDERS),
+  browserProvider: z106.string().nullable(),
   dataRegion: DataResidencySchema2.nullable(),
   regions: resolvedRegionsSchema,
   flags: deploymentOrgFlagsSchema,
-  tags: z105.array(organizationTagSchema),
-  teamCount: z105.number().int().nonnegative(),
+  tags: z106.array(organizationTagSchema),
+  teamCount: z106.number().int().nonnegative(),
   runVolume: runVolumeSchema
 });
-var deploymentTeamRowSchema = z105.object({
-  teamId: z105.guid(),
-  name: z105.string(),
-  browserProvider: z105.string().nullable(),
-  browserProviderSource: z105.enum([
+var deploymentTeamRowSchema = z106.object({
+  teamId: z106.guid(),
+  name: z106.string(),
+  browserProvider: z106.string().nullable(),
+  browserProviderSource: z106.enum([
     "team",
     "org-enforced",
     "org-default",
@@ -34006,47 +34295,47 @@ var deploymentTeamRowSchema = z105.object({
    * retry-time switch, so this column reports the resolved *setting*, never
    * proof of what a given run used.
    */
-  browserProviderPinned: z105.boolean(),
+  browserProviderPinned: z106.boolean(),
   residency: DataResidencySchema2.nullable(),
-  residencyDivergesFromOrg: z105.boolean(),
+  residencyDivergesFromOrg: z106.boolean(),
   runVolume: runVolumeSchema
 });
-var listDeploymentTeamsResponseSchema = z105.object({
-  teams: z105.array(deploymentTeamRowSchema)
+var listDeploymentTeamsResponseSchema = z106.object({
+  teams: z106.array(deploymentTeamRowSchema)
 });
-var unassignedTeamsSummarySchema = z105.object({
-  teamCount: z105.number().int().nonnegative(),
+var unassignedTeamsSummarySchema = z106.object({
+  teamCount: z106.number().int().nonnegative(),
   runVolume: runVolumeSchema
 });
-var listDeploymentOrganizationsResponseSchema = z105.object({
-  data: z105.array(deploymentOrgRowSchema),
-  total: z105.number().int().nonnegative(),
-  limit: z105.number().int().positive(),
-  offset: z105.number().int().nonnegative(),
+var listDeploymentOrganizationsResponseSchema = z106.object({
+  data: z106.array(deploymentOrgRowSchema),
+  total: z106.number().int().nonnegative(),
+  limit: z106.number().int().positive(),
+  offset: z106.number().int().nonnegative(),
   platformDefaults: platformRegionDefaultsSchema,
   unassigned: unassignedTeamsSummarySchema
 });
-var deploymentOrgDetailResponseSchema = z105.object({
+var deploymentOrgDetailResponseSchema = z106.object({
   organization: deploymentOrgRowSchema,
   profile: organizationDeploymentProfileSchema,
   platformDefaults: platformRegionDefaultsSchema,
-  products: z105.array(z105.string())
+  products: z106.array(z106.string())
 });
-var catalogPluginSchema2 = z106.object({
-  name: z106.string().describe("Identifier to pass in the build's plugins array."),
+var catalogPluginSchema2 = z107.object({
+  name: z107.string().describe("Identifier to pass in the build's plugins array."),
   type: extensibleEnum2(["duvo-platform", "knowledge-work", "github"], {
     description: "Plugin source. 'duvo-platform' plugins are pre-baked into the Duvo runtime; 'knowledge-work' plugins are role-oriented bundles (engineering, sales, legal, \u2026) also baked into the runtime; 'github' plugins are downloaded from a user-supplied repository URL at run time."
   }),
-  description: z106.string()
+  description: z107.string()
 });
-var pluginCatalogResponseSchema2 = z106.object({
-  plugins: z106.array(catalogPluginSchema2)
+var pluginCatalogResponseSchema2 = z107.object({
+  plugins: z107.array(catalogPluginSchema2)
 });
-var limitValueSchema = z107.union([
-  z107.number().int().nonnegative(),
-  z107.literal("unlimited")
+var limitValueSchema = z108.union([
+  z108.number().int().nonnegative(),
+  z108.literal("unlimited")
 ]);
-var runCountingModeSchema = z107.enum(["monthly", "lifetime"]);
+var runCountingModeSchema = z108.enum(["monthly", "lifetime"]);
 function addDuplicateKeyIssues({
   ctx,
   items,
@@ -34058,7 +34347,7 @@ function addDuplicateKeyIssues({
     const key = keyFor(item);
     if (seen.has(key)) {
       ctx.addIssue({
-        code: z107.ZodIssueCode.custom,
+        code: z108.ZodIssueCode.custom,
         message: `Duplicate Product Access grant key: ${key}`,
         path: [...path, index]
       });
@@ -34069,34 +34358,34 @@ function addDuplicateKeyIssues({
 }
 __name(addDuplicateKeyIssues, "addDuplicateKeyIssues");
 __name3(addDuplicateKeyIssues, "addDuplicateKeyIssues");
-var productAccessOwnerSchema = z107.discriminatedUnion("type", [
-  z107.object({
-    type: z107.literal("organization"),
-    organizationId: z107.guid()
+var productAccessOwnerSchema = z108.discriminatedUnion("type", [
+  z108.object({
+    type: z108.literal("organization"),
+    organizationId: z108.guid()
   }),
-  z107.object({
-    type: z107.literal("team"),
-    teamId: z107.guid(),
-    organizationId: z107.guid().nullable()
+  z108.object({
+    type: z108.literal("team"),
+    teamId: z108.guid(),
+    organizationId: z108.guid().nullable()
   })
 ]);
-var productAccessGrantSetSchema = z107.object({
-  products: z107.array(
-    z107.object({
-      productKey: z107.enum(PRODUCT_KEYS2),
-      enabled: z107.boolean()
+var productAccessGrantSetSchema = z108.object({
+  products: z108.array(
+    z108.object({
+      productKey: z108.enum(PRODUCT_KEYS2),
+      enabled: z108.boolean()
     })
   ),
-  capabilities: z107.array(
-    z107.object({
-      capabilityKey: z107.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      enabled: z107.boolean()
+  capabilities: z108.array(
+    z108.object({
+      capabilityKey: z108.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      enabled: z108.boolean()
     })
   ),
-  limits: z107.array(
-    z107.object({
-      productKey: z107.enum(PRODUCT_KEYS2),
-      limitKey: z107.enum(ENTITLEMENT_LIMIT_KEYS),
+  limits: z108.array(
+    z108.object({
+      productKey: z108.enum(PRODUCT_KEYS2),
+      limitKey: z108.enum(ENTITLEMENT_LIMIT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable()
     })
@@ -34121,59 +34410,59 @@ var productAccessGrantSetSchema = z107.object({
     path: ["limits"]
   });
 });
-var productAccessSnapshotSchema = z107.object({
-  products: z107.array(
-    z107.object({
-      productKey: z107.enum(PRODUCT_KEYS2),
-      enabled: z107.boolean()
+var productAccessSnapshotSchema = z108.object({
+  products: z108.array(
+    z108.object({
+      productKey: z108.enum(PRODUCT_KEYS2),
+      enabled: z108.boolean()
     })
   ),
-  capabilities: z107.array(
-    z107.object({
+  capabilities: z108.array(
+    z108.object({
       capabilityKey: extensibleEnum2(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      productKey: z107.enum(PRODUCT_KEYS2),
-      enabled: z107.boolean()
+      productKey: z108.enum(PRODUCT_KEYS2),
+      enabled: z108.boolean()
     })
   ),
-  limits: z107.array(
-    z107.object({
-      limitKey: z107.enum(ENTITLEMENT_LIMIT_KEYS),
-      productKey: z107.enum(PRODUCT_KEYS2),
+  limits: z108.array(
+    z108.object({
+      limitKey: z108.enum(ENTITLEMENT_LIMIT_KEYS),
+      productKey: z108.enum(PRODUCT_KEYS2),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable(),
-      label: z107.literal("per_team")
+      label: z108.literal("per_team")
     })
   )
 });
-var billingPlanSchema = z107.object({
-  planVersionId: z107.string(),
-  planName: z107.string(),
-  basePlan: z107.enum(["free", "pro", "enterprise"])
+var billingPlanSchema = z108.object({
+  planVersionId: z108.string(),
+  planName: z108.string(),
+  basePlan: z108.enum(["free", "pro", "enterprise"])
 });
-var inheritedFromSchema = z107.discriminatedUnion("type", [
-  z107.object({
-    type: z107.literal("organization"),
-    organizationId: z107.guid()
+var inheritedFromSchema = z108.discriminatedUnion("type", [
+  z108.object({
+    type: z108.literal("organization"),
+    organizationId: z108.guid()
   }),
-  z107.object({
-    type: z107.literal("team_subscription"),
-    planVersionId: z107.string()
+  z108.object({
+    type: z108.literal("team_subscription"),
+    planVersionId: z108.string()
   })
 ]);
-var productAccessReadResponseSchema = z107.object({
+var productAccessReadResponseSchema = z108.object({
   owner: productAccessOwnerSchema,
-  source: z107.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
-  accessRevision: z107.string().min(1),
+  source: z108.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  accessRevision: z108.string().min(1),
   /**
    * End of the owner's own access window — a trial deadline set on this
    * organization's or team's product grants. `null` means open-ended.
    * Inherited access is not summarised here: a team that follows its
    * organization reads `null` and the organization carries the window.
    */
-  accessExpiresAt: z107.iso.datetime().nullable(),
+  accessExpiresAt: z108.iso.datetime().nullable(),
   displayPreset: displayPresetSchema,
-  hasExplicitTeamAccess: z107.boolean(),
-  followsOrganization: z107.boolean(),
+  hasExplicitTeamAccess: z108.boolean(),
+  followsOrganization: z108.boolean(),
   inheritedFrom: inheritedFromSchema.nullable(),
   billingPlan: billingPlanSchema.nullable(),
   grants: productAccessSnapshotSchema,
@@ -34181,93 +34470,93 @@ var productAccessReadResponseSchema = z107.object({
 }).superRefine((value, ctx) => {
   if (value.owner.type === "team" && value.source === "organization" && value.inheritedFrom?.type !== "organization") {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "inheritedFrom organization context is required when team source is organization",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team_subscription" && value.inheritedFrom?.type !== "team_subscription") {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "inheritedFrom subscription context is required when team source is team_subscription",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "inheritedFrom must be null for direct team Product Access",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team" && value.followsOrganization) {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "followsOrganization cannot be set for direct team Product Access",
       path: ["followsOrganization"]
     });
   }
   if (value.owner.type === "organization" && value.followsOrganization) {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "followsOrganization must be false for organization Product Access",
       path: ["followsOrganization"]
     });
   }
   if (value.owner.type === "organization" && value.billingPlan !== null) {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "billingPlan must be null for organization Product Access",
       path: ["billingPlan"]
     });
   }
   if (value.owner.type === "organization" && value.source !== "organization") {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "organization Product Access source must be organization",
       path: ["source"]
     });
   }
   if (value.owner.type === "organization" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z107.ZodIssueCode.custom,
+      code: z108.ZodIssueCode.custom,
       message: "inheritedFrom must be null for organization Product Access",
       path: ["inheritedFrom"]
     });
   }
 });
-var productAccessImpactRequestSchema = z107.object({
+var productAccessImpactRequestSchema = z108.object({
   proposedGrants: productAccessGrantSetSchema
 });
-var productAccessWriteRequestSchema = z107.object({
+var productAccessWriteRequestSchema = z108.object({
   proposedGrants: productAccessGrantSetSchema,
-  accessRevision: z107.string().min(1),
-  impactFingerprint: z107.string().min(1).optional()
+  accessRevision: z108.string().min(1),
+  impactFingerprint: z108.string().min(1).optional()
 });
-var productAccessExpiryRequestSchema = z107.object({
-  expiresAt: z107.iso.datetime().nullable(),
-  accessRevision: z107.string().min(1),
+var productAccessExpiryRequestSchema = z108.object({
+  expiresAt: z108.iso.datetime().nullable(),
+  accessRevision: z108.string().min(1),
   /**
    * Required when the deadline has already passed, because that ends access
    * immediately and is confirmed like any other removal of access.
    */
-  impactFingerprint: z107.string().min(1).optional()
+  impactFingerprint: z108.string().min(1).optional()
 });
-var productAccessTeamResetRequestSchema = z107.object({
-  accessRevision: z107.string().min(1),
-  impactFingerprint: z107.string().min(1).optional()
+var productAccessTeamResetRequestSchema = z108.object({
+  accessRevision: z108.string().min(1),
+  impactFingerprint: z108.string().min(1).optional()
 });
 var productAccessTeamFollowOrganizationRequestSchema = productAccessTeamResetRequestSchema.extend({
-  follow: z107.boolean()
-});
-var productAccessChangeSummarySchema = z107.object({
-  addedProducts: z107.array(z107.enum(PRODUCT_KEYS2)),
-  removedProducts: z107.array(z107.enum(PRODUCT_KEYS2)),
-  addedCapabilities: z107.array(extensibleEnum2(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  removedCapabilities: z107.array(extensibleEnum2(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  limitChanges: z107.array(
-    z107.object({
-      limitKey: z107.enum(ENTITLEMENT_LIMIT_KEYS),
+  follow: z108.boolean()
+});
+var productAccessChangeSummarySchema = z108.object({
+  addedProducts: z108.array(z108.enum(PRODUCT_KEYS2)),
+  removedProducts: z108.array(z108.enum(PRODUCT_KEYS2)),
+  addedCapabilities: z108.array(extensibleEnum2(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  removedCapabilities: z108.array(extensibleEnum2(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  limitChanges: z108.array(
+    z108.object({
+      limitKey: z108.enum(ENTITLEMENT_LIMIT_KEYS),
       currentValue: limitValueSchema,
       currentCountingMode: runCountingModeSchema.nullable(),
       proposedValue: limitValueSchema,
@@ -34275,91 +34564,91 @@ var productAccessChangeSummarySchema = z107.object({
     })
   )
 });
-var productAccessImpactResponseSchema = z107.object({
+var productAccessImpactResponseSchema = z108.object({
   owner: productAccessOwnerSchema,
-  impactFingerprint: z107.string().min(1),
-  affectedTeamCount: z107.number().int().nonnegative(),
-  affectedTeamsTruncated: z107.boolean(),
+  impactFingerprint: z108.string().min(1),
+  affectedTeamCount: z108.number().int().nonnegative(),
+  affectedTeamsTruncated: z108.boolean(),
   changes: productAccessChangeSummarySchema,
-  sideEffects: z107.object({
-    automationWillPause: z107.boolean(),
-    clarityWillHide: z107.boolean()
+  sideEffects: z108.object({
+    automationWillPause: z108.boolean(),
+    clarityWillHide: z108.boolean()
   }),
-  affectedTeamsPreview: z107.array(
-    z107.object({
-      teamId: z107.guid(),
-      teamName: z107.string(),
-      source: z107.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  affectedTeamsPreview: z108.array(
+    z108.object({
+      teamId: z108.guid(),
+      teamName: z108.string(),
+      source: z108.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
       changes: productAccessChangeSummarySchema
     })
   )
 });
-var publicProfileSchema2 = z108.object({
-  id: z108.guid(),
-  name: z108.string().nullable(),
-  email: z108.email(),
-  teamId: z108.guid().nullable()
+var publicProfileSchema2 = z109.object({
+  id: z109.guid(),
+  name: z109.string().nullable(),
+  email: z109.email(),
+  teamId: z109.guid().nullable()
 });
-var publicProfileResponseSchema2 = z108.object({
+var publicProfileResponseSchema2 = z109.object({
   profile: publicProfileSchema2
 });
-var recordingProvisioningDesktopSchema = z109.discriminatedUnion("kind", [
-  z109.object({ kind: z109.literal("standard") }),
-  z109.object({ kind: z109.literal("template"), snapshotId: z109.string().min(1) })
+var recordingProvisioningDesktopSchema = z110.discriminatedUnion("kind", [
+  z110.object({ kind: z110.literal("standard") }),
+  z110.object({ kind: z110.literal("template"), snapshotId: z110.string().min(1) })
 ]);
-var recordingProvisioningNetworkSchema = z109.discriminatedUnion("kind", [
-  z109.object({ kind: z109.literal("direct") }),
-  z109.object({ kind: z109.literal("vpn"), vpnConfigId: z109.string().min(1) })
+var recordingProvisioningNetworkSchema = z110.discriminatedUnion("kind", [
+  z110.object({ kind: z110.literal("direct") }),
+  z110.object({ kind: z110.literal("vpn"), vpnConfigId: z110.string().min(1) })
 ]);
-var recordingProvisioningRequestSchema = z109.object({
+var recordingProvisioningRequestSchema = z110.object({
   desktop: recordingProvisioningDesktopSchema,
-  region: z109.string().min(1),
+  region: z110.string().min(1),
   network: recordingProvisioningNetworkSchema
 });
-var recordingLoginFillRecordSchema = z109.object({
+var recordingLoginFillRecordSchema = z110.object({
   /** Which login field was typed. */
-  field: z109.enum(["username", "password", "otp"]),
+  field: z110.enum(["username", "password", "otp"]),
   /** `name` attribute of the element that received it, if it had one. */
-  name: z109.string().optional(),
+  name: z110.string().optional(),
   /** `id` attribute of the element that received it, if it had one. */
-  id: z109.string().optional(),
+  id: z110.string().optional(),
   /** Lowercased tag name of that element. */
-  tagName: z109.string(),
+  tagName: z110.string(),
   /** When the fill landed, so a repeat fill of the same field can be ordered. */
-  filledAt: z109.number()
+  filledAt: z110.number()
 });
-var recordingLoginFillClaimSchema = z109.object({
-  token: z109.string(),
+var recordingLoginFillClaimSchema = z110.object({
+  token: z110.string(),
   /** Epoch millis, so a claim abandoned by a crashed request can go stale. */
-  at: z109.number()
-});
-var elementSelectorsSchema = z109.object({
-  css: z109.string().optional(),
-  cssPath: z109.string().optional(),
-  xpath: z109.string().optional(),
-  testId: z109.string().optional(),
-  ariaSelector: z109.string().optional(),
-  text: z109.string().optional()
-});
-var elementInfoSchema = z109.object({
-  uid: z109.string().optional(),
+  at: z110.number()
+});
+var elementSelectorsSchema = z110.object({
+  css: z110.string().optional(),
+  cssPath: z110.string().optional(),
+  xpath: z110.string().optional(),
+  testId: z110.string().optional(),
+  ariaSelector: z110.string().optional(),
+  text: z110.string().optional()
+});
+var elementInfoSchema = z110.object({
+  uid: z110.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z109.string(),
-  textContent: z109.string().optional(),
-  ariaLabel: z109.string().optional(),
-  computedRole: z109.string().optional(),
-  attributes: z109.record(z109.string(), z109.string()).optional(),
-  framePath: z109.array(z109.number()).optional(),
-  frameUrl: z109.string().optional()
-});
-var recordedEventSchema = z109.looseObject({
-  id: z109.string(),
-  type: z109.string(),
-  timestamp: z109.number(),
-  url: z109.string(),
-  tabId: z109.number().optional(),
-  frameId: z109.number().optional(),
-  framePath: z109.array(z109.number()).optional(),
+  tagName: z110.string(),
+  textContent: z110.string().optional(),
+  ariaLabel: z110.string().optional(),
+  computedRole: z110.string().optional(),
+  attributes: z110.record(z110.string(), z110.string()).optional(),
+  framePath: z110.array(z110.number()).optional(),
+  frameUrl: z110.string().optional()
+});
+var recordedEventSchema = z110.looseObject({
+  id: z110.string(),
+  type: z110.string(),
+  timestamp: z110.number(),
+  url: z110.string(),
+  tabId: z110.number().optional(),
+  frameId: z110.number().optional(),
+  framePath: z110.array(z110.number()).optional(),
   element: elementInfoSchema.optional()
 });
 var COMPUTER_USE_TARGET_SOURCES = [
@@ -34373,31 +34662,31 @@ var COMPUTER_USE_TARGET_CONFIDENCES = [
   "low"
 ];
 var COMPUTER_USE_MODIFIERS = ["Control", "Shift", "Alt"];
-var computerUseElementIdentitySchema = z109.object({
-  role: z109.string().optional(),
-  name: z109.string().optional(),
-  automationId: z109.string().optional(),
-  className: z109.string().optional(),
-  bounds: z109.object({
-    x: z109.number(),
-    y: z109.number(),
-    width: z109.number(),
-    height: z109.number()
+var computerUseElementIdentitySchema = z110.object({
+  role: z110.string().optional(),
+  name: z110.string().optional(),
+  automationId: z110.string().optional(),
+  className: z110.string().optional(),
+  bounds: z110.object({
+    x: z110.number(),
+    y: z110.number(),
+    width: z110.number(),
+    height: z110.number()
   }).optional()
 });
-var computerUseElementTargetSchema = z109.object({
-  selector: z109.string().optional(),
-  confidence: z109.enum(COMPUTER_USE_TARGET_CONFIDENCES),
-  source: z109.enum(COMPUTER_USE_TARGET_SOURCES),
+var computerUseElementTargetSchema = z110.object({
+  selector: z110.string().optional(),
+  confidence: z110.enum(COMPUTER_USE_TARGET_CONFIDENCES),
+  source: z110.enum(COMPUTER_USE_TARGET_SOURCES),
   element: computerUseElementIdentitySchema.optional(),
   /**
    * How many nodes in the recorded tree shared this target's anchor
    * (role+name, or the derived selector). Drives deterministic-vs-agent
    * classification: a non-unique anchor is ambiguous and must not replay blindly.
    */
-  matchCount: z109.number().int().positive().optional(),
+  matchCount: z110.number().int().positive().optional(),
   /** Convenience flag: `matchCount === 1`. Absent on older recordings. */
-  unique: z109.boolean().optional()
+  unique: z110.boolean().optional()
 });
 var EDITABLE_COMPUTER_USE_ROLES = /* @__PURE__ */ new Set([
   "combobox",
@@ -34436,16 +34725,16 @@ function canCaptureComputerUseTypedText(target) {
 }
 __name(canCaptureComputerUseTypedText, "canCaptureComputerUseTypedText");
 __name3(canCaptureComputerUseTypedText, "canCaptureComputerUseTypedText");
-var computerUseElementResolutionSchema = z109.object({
+var computerUseElementResolutionSchema = z110.object({
   target: computerUseElementTargetSchema.nullable(),
-  activeWindow: z109.string().nullable()
+  activeWindow: z110.string().nullable()
 });
-var computerUseEventBaseSchema = z109.object({
+var computerUseEventBaseSchema = z110.object({
   /** Client-generated id; correlates an async element resolution back. */
-  id: z109.string().optional(),
-  timestamp: z109.number(),
+  id: z110.string().optional(),
+  timestamp: z110.number(),
   /** Links this event to a screenshot uploaded in the same/earlier batch. */
-  screenshotSeq: z109.number().int().nonnegative().optional(),
+  screenshotSeq: z110.number().int().nonnegative().optional(),
   /** Resolved UIA element target (primary workflow-execution anchor). */
   target: computerUseElementTargetSchema.optional(),
   /**
@@ -34455,60 +34744,60 @@ var computerUseEventBaseSchema = z109.object({
    * performing the (possibly anchorless) action, so a fixed-pixel click can't
    * fire into a screen that hasn't reached the recorded state.
    */
-  activeWindow: z109.string().optional()
+  activeWindow: z110.string().optional()
 });
 var computerUseClickEventSchema = computerUseEventBaseSchema.extend({
-  type: z109.literal("click"),
+  type: z110.literal("click"),
   /** Cursor position in native desktop pixels. */
-  x: z109.number(),
-  y: z109.number(),
-  button: z109.enum(["left", "right", "middle"]).optional(),
-  double: z109.boolean().optional(),
+  x: z110.number(),
+  y: z110.number(),
+  button: z110.enum(["left", "right", "middle"]).optional(),
+  double: z110.boolean().optional(),
   /**
    * Modifier keys held during the click (e.g. ["Shift"], ["Control"]),
    * normalized to Windows names (Meta→Control) at capture. A modified click
    * (range/multi-select) can't replay atomically on the sandbox, so it is
    * classified as an agent step — but it must still be recorded, not lost.
    */
-  modifiers: z109.array(z109.enum(COMPUTER_USE_MODIFIERS)).optional()
+  modifiers: z110.array(z110.enum(COMPUTER_USE_MODIFIERS)).optional()
 });
 var computerUseScrollEventSchema = computerUseEventBaseSchema.extend({
-  type: z109.literal("scroll"),
-  x: z109.number(),
-  y: z109.number(),
-  deltaX: z109.number(),
-  deltaY: z109.number()
+  type: z110.literal("scroll"),
+  x: z110.number(),
+  y: z110.number(),
+  deltaX: z110.number(),
+  deltaY: z110.number()
 });
 var computerUseTypeEventSchema = computerUseEventBaseSchema.extend({
-  type: z109.literal("type"),
+  type: z110.literal("type"),
   /** Number of characters typed. */
-  textLength: z109.number().int().nonnegative(),
+  textLength: z110.number().int().nonnegative(),
   /**
    * Present only when the focused control is a known non-sensitive text field.
    * Sensitive and unresolved controls keep only `textLength`.
    */
-  text: z109.string().optional()
+  text: z110.string().optional()
 });
 var computerUseKeyEventSchema = computerUseEventBaseSchema.extend({
-  type: z109.literal("key"),
-  key: z109.string(),
+  type: z110.literal("key"),
+  key: z110.string(),
   /**
    * Modifier keys held with `key`, forming a chord (e.g. ["Control"] for
    * Ctrl+S), normalized to Windows names (Meta→Control) at capture. Replays
    * atomically via keyboard.press(key, modifiers).
    */
-  modifiers: z109.array(z109.enum(COMPUTER_USE_MODIFIERS)).optional()
+  modifiers: z110.array(z110.enum(COMPUTER_USE_MODIFIERS)).optional()
 });
-var computerUseRecordedEventSchema = z109.discriminatedUnion("type", [
+var computerUseRecordedEventSchema = z110.discriminatedUnion("type", [
   computerUseClickEventSchema,
   computerUseScrollEventSchema,
   computerUseTypeEventSchema,
   computerUseKeyEventSchema
 ]);
-var computerUseScreenshotSchema = z109.object({
-  seq: z109.number().int().nonnegative(),
+var computerUseScreenshotSchema = z110.object({
+  seq: z110.number().int().nonnegative(),
   /** Base64-encoded JPEG (no data: URL prefix). */
-  base64: z109.string()
+  base64: z110.string()
 });
 var DUVO_CLIENTS2 = {
   cli: "cli",
@@ -34526,30 +34815,30 @@ function resolveRequestSourceFromClientHeader2(header) {
 }
 __name(resolveRequestSourceFromClientHeader2, "resolveRequestSourceFromClientHeader");
 __name3(resolveRequestSourceFromClientHeader2, "resolveRequestSourceFromClientHeader");
-var RedactedMcpServerConfigSchema = z110.object({
+var RedactedMcpServerConfigSchema = z111.object({
   type: TransportTypeSchema2,
   integrationSlug: IntegrationSlugSchema2,
-  instanceId: z110.string().nullable()
+  instanceId: z111.string().nullable()
 });
-var ThreadContextMessageSchema = z110.object({
-  role: z110.enum(["user", "assistant"]),
-  content: z110.string()
+var ThreadContextMessageSchema = z111.object({
+  role: z111.enum(["user", "assistant"]),
+  content: z111.string()
 });
-var ChatFileReferenceSchema = z110.object({
-  id: z110.string(),
-  name: z110.string(),
-  mimetype: z110.string(),
-  size: z110.number(),
-  platform: z110.enum(["slack", "teams"]),
-  workspaceId: z110.string(),
-  channelId: z110.string()
-});
-var ResolvedSkillRefSchema = z110.object({
-  skillId: z110.string().uuid(),
-  skillName: z110.string(),
-  revisionId: z110.string().uuid().nullable(),
-  gcsBucket: z110.string(),
-  gcsPath: z110.string()
+var ChatFileReferenceSchema = z111.object({
+  id: z111.string(),
+  name: z111.string(),
+  mimetype: z111.string(),
+  size: z111.number(),
+  platform: z111.enum(["slack", "teams"]),
+  workspaceId: z111.string(),
+  channelId: z111.string()
+});
+var ResolvedSkillRefSchema = z111.object({
+  skillId: z111.string().uuid(),
+  skillName: z111.string(),
+  revisionId: z111.string().uuid().nullable(),
+  gcsBucket: z111.string(),
+  gcsPath: z111.string()
 });
 var RunConfigSchema = AgentConfigSchema2.omit({
   // Sub-Assignments is retired. `subAgents` survives on AgentConfigSchema only
@@ -34557,8 +34846,8 @@ var RunConfigSchema = AgentConfigSchema2.omit({
   // never had a reason to carry it, so it is dropped here rather than frozen.
   subAgents: true
 }).extend({
-  task: z110.string(),
-  mcpServers: z110.record(z110.string(), RedactedMcpServerConfigSchema),
+  task: z111.string(),
+  mcpServers: z111.record(z111.string(), RedactedMcpServerConfigSchema),
   /**
    * Newly created runs store `ResolvedSkillRef` entries exclusively. The
    * `string` arm exists ONLY for stored v1 rows written before skill pinning
@@ -34575,18 +34864,18 @@ var RunConfigSchema = AgentConfigSchema2.omit({
    * applies. Defaulting it to `[]` would read as "frozen with zero skills"
    * and silently drop those runs' skills. New writers always set the key.
    */
-  skills: z110.array(z110.union([ResolvedSkillRefSchema, z110.string()])).optional(),
-  conversationHistory: z110.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z110.array(ChatFileReferenceSchema).optional(),
+  skills: z111.array(z111.union([ResolvedSkillRefSchema, z111.string()])).optional(),
+  conversationHistory: z111.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z111.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z110.string().optional(),
+  timezone: z111.string().optional(),
   /**
    * ISO 8601 timestamp captured when the run was created. Frozen at
    * run-creation time and never recomputed, so resumes reuse the same value —
    * the runtime injects it into the cached system prompt and a changing value
    * would bust the prompt cache.
    */
-  sessionStartedAt: z110.string().optional(),
+  sessionStartedAt: z111.string().optional(),
   /**
    * True when this dispatch resumes a run the user stopped. Derived on each
    * continue from the durable `agent_run.stopped_by_user` column (set only by a
@@ -34595,17 +34884,17 @@ var RunConfigSchema = AgentConfigSchema2.omit({
    * first resumed turn. Lives here — not in cc-server memory — so it survives a
    * sandbox suspend/resume.
    */
-  resumedAfterStop: z110.boolean().optional()
+  resumedAfterStop: z111.boolean().optional()
 });
-var StoredRunConfigV0Schema = z110.object({
-  version: z110.literal("v0")
+var StoredRunConfigV0Schema = z111.object({
+  version: z111.literal("v0")
 });
 var STORED_CODE_STEP_RUN_CONFIG_VERSION = "code-v1";
-var policyValueJsonSchema = z110.json();
-z110.globalRegistry.add(policyValueJsonSchema, { id: "ResolvedPolicyValueJson" });
-var ResolvedPolicyValueSchema = z110.object({
-  key: z110.string(),
-  question: z110.string(),
+var policyValueJsonSchema = z111.json();
+z111.globalRegistry.add(policyValueJsonSchema, { id: "ResolvedPolicyValueJson" });
+var ResolvedPolicyValueSchema = z111.object({
+  key: z111.string(),
+  question: z111.string(),
   /**
    * The answer. A JSON schema rather than `z.unknown()`, which would let the
    * key be omitted entirely — Zod treats an `unknown` field as optional — and
@@ -34615,10 +34904,10 @@ var ResolvedPolicyValueSchema = z110.object({
    * already filters out. `null` stays legal: it is an answer.
    */
   value: policyValueJsonSchema,
-  locked: z110.boolean()
+  locked: z111.boolean()
 });
 var CodeStepRunConfigSchema = codeStepConfigSchema2.extend({
-  mcpServers: z110.record(z110.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  mcpServers: z111.record(z111.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs resolved for this run. Keyed as `<slug>` or `<slug>_<instanceId>`. Secrets resolved at call time."
   ),
   /**
@@ -34634,12 +34923,12 @@ var CodeStepRunConfigSchema = codeStepConfigSchema2.extend({
    *
    * Defaulted, so runs admitted before this shipped keep parsing.
    */
-  policyValues: z110.array(ResolvedPolicyValueSchema).default([]).describe(
+  policyValues: z111.array(ResolvedPolicyValueSchema).default([]).describe(
     "Policy field values this build reads, resolved and frozen at admission."
   )
 });
-var StoredCodeStepRunConfigSchema = z110.object({
-  version: z110.literal(STORED_CODE_STEP_RUN_CONFIG_VERSION),
+var StoredCodeStepRunConfigSchema = z111.object({
+  version: z111.literal(STORED_CODE_STEP_RUN_CONFIG_VERSION),
   data: CodeStepRunConfigSchema,
   /**
    * Per-run input, frozen at admission alongside the config.
@@ -34656,11 +34945,11 @@ var StoredCodeStepRunConfigSchema = z110.object({
   input: codeStepRunInputSchema.optional()
 });
 var StoredCodeStepRunConfigForConfigReadSchema = StoredCodeStepRunConfigSchema.omit({ input: true });
-var StoredRunConfigV1Schema = z110.object({
-  version: z110.literal("v1"),
+var StoredRunConfigV1Schema = z111.object({
+  version: z111.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z110.union([
+var StoredRunConfigSchema = z111.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema,
   StoredCodeStepRunConfigSchema
@@ -34685,187 +34974,187 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name3(isRunConfig, "isRunConfig");
-var skillApiSchema2 = z111.object({
-  id: z111.string(),
-  name: z111.string(),
-  description: z111.string(),
+var skillApiSchema2 = z1122.object({
+  id: z1122.string(),
+  name: z1122.string(),
+  description: z1122.string(),
   // System skills have null team_id.
-  team_id: z111.string().nullable()
+  team_id: z1122.string().nullable()
 });
-var listSkillsResponseSchema2 = z111.object({
-  skills: z111.array(skillApiSchema2)
+var listSkillsResponseSchema2 = z1122.object({
+  skills: z1122.array(skillApiSchema2)
 });
-var systemSkillSchema2 = z111.object({
-  id: z111.string(),
-  name: z111.string(),
-  description: z111.string()
+var systemSkillSchema2 = z1122.object({
+  id: z1122.string(),
+  name: z1122.string(),
+  description: z1122.string()
 });
-var listSystemSkillsResponseSchema2 = z111.object({
-  skills: z111.array(systemSkillSchema2)
+var listSystemSkillsResponseSchema2 = z1122.object({
+  skills: z1122.array(systemSkillSchema2)
 });
-var skillFileItemSchema2 = z111.object({
-  name: z111.string(),
-  path: z111.string(),
-  size: z111.number().optional(),
-  contentType: z111.string().optional(),
-  updatedAt: z111.string().optional()
+var skillFileItemSchema2 = z1122.object({
+  name: z1122.string(),
+  path: z1122.string(),
+  size: z1122.number().optional(),
+  contentType: z1122.string().optional(),
+  updatedAt: z1122.string().optional()
 });
-var listSkillFilesResponseSchema2 = z111.object({
-  files: z111.array(skillFileItemSchema2)
+var listSkillFilesResponseSchema2 = z1122.object({
+  files: z1122.array(skillFileItemSchema2)
 });
-var getSkillFileContentResponseSchema2 = z111.object({
-  content: z111.string(),
-  path: z111.string(),
-  contentType: z111.string().optional()
+var getSkillFileContentResponseSchema2 = z1122.object({
+  content: z1122.string(),
+  path: z1122.string(),
+  contentType: z1122.string().optional()
 });
-var updateSkillFileBodySchema2 = z111.object({
-  content: z111.string()
+var updateSkillFileBodySchema2 = z1122.object({
+  content: z1122.string()
 });
-var updateSkillFileResponseSchema2 = z111.object({
-  success: z111.boolean(),
-  message: z111.string(),
-  skill: z111.object({
-    id: z111.string(),
-    name: z111.string(),
-    description: z111.string()
+var updateSkillFileResponseSchema2 = z1122.object({
+  success: z1122.boolean(),
+  message: z1122.string(),
+  skill: z1122.object({
+    id: z1122.string(),
+    name: z1122.string(),
+    description: z1122.string()
   }).optional()
 });
-var deleteSkillResponseSchema2 = z111.object({
-  success: z111.boolean(),
-  message: z111.string()
+var deleteSkillResponseSchema2 = z1122.object({
+  success: z1122.boolean(),
+  message: z1122.string()
 });
-var generateSkillBodySchema2 = z111.object({
-  prompt: z111.string().min(1).max(2e3),
-  existingContent: z111.string().max(2e4).optional()
+var generateSkillBodySchema2 = z1122.object({
+  prompt: z1122.string().min(1).max(2e3),
+  existingContent: z1122.string().max(2e4).optional()
 });
-var generateSkillResponseSchema2 = z111.object({
-  content: z111.string()
+var generateSkillResponseSchema2 = z1122.object({
+  content: z1122.string()
 });
-var skillAssignmentSchema2 = z111.object({
-  id: z111.string(),
-  name: z111.string()
+var skillAssignmentSchema2 = z1122.object({
+  id: z1122.string(),
+  name: z1122.string()
 });
-var listSkillAssignmentsResponseSchema2 = z111.object({
-  assignments: z111.array(skillAssignmentSchema2),
-  total: z111.number()
+var listSkillAssignmentsResponseSchema2 = z1122.object({
+  assignments: z1122.array(skillAssignmentSchema2),
+  total: z1122.number()
 });
-var teamInvitationApiSchema2 = z1122.object({
-  id: z1122.string(),
-  team_id: z1122.string(),
-  email: z1122.email(),
-  invited_by: z1122.string(),
-  role: z1122.string(),
-  status: z1122.string(),
-  name: z1122.string().nullable(),
-  created_at: z1122.string(),
-  process_id: z1122.guid().nullable().optional()
-});
-var teamInvitationDetailApiSchema2 = z1122.object({
-  id: z1122.string(),
-  team_id: z1122.string(),
-  email: z1122.email(),
-  invited_by: z1122.string(),
-  role: z1122.string(),
-  status: z1122.string(),
-  name: z1122.string().nullable(),
-  created_at: z1122.string(),
-  process_id: z1122.guid().nullable().optional(),
-  team: z1122.object({
-    id: z1122.string(),
-    name: z1122.string()
+var teamInvitationApiSchema2 = z113.object({
+  id: z113.string(),
+  team_id: z113.string(),
+  email: z113.email(),
+  invited_by: z113.string(),
+  role: z113.string(),
+  status: z113.string(),
+  name: z113.string().nullable(),
+  created_at: z113.string(),
+  process_id: z113.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema2 = z113.object({
+  id: z113.string(),
+  team_id: z113.string(),
+  email: z113.email(),
+  invited_by: z113.string(),
+  role: z113.string(),
+  status: z113.string(),
+  name: z113.string().nullable(),
+  created_at: z113.string(),
+  process_id: z113.guid().nullable().optional(),
+  team: z113.object({
+    id: z113.string(),
+    name: z113.string()
   }),
-  invitedBy: z1122.object({
-    id: z1122.string(),
-    name: z1122.string().nullable(),
-    email: z1122.email()
+  invitedBy: z113.object({
+    id: z113.string(),
+    name: z113.string().nullable(),
+    email: z113.email()
   }),
-  process: z1122.object({
-    id: z1122.string(),
-    name: z1122.string()
+  process: z113.object({
+    id: z113.string(),
+    name: z113.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema2 = z1122.object({
-  email: z1122.email().describe("Email address of the person to invite."),
-  role: z1122.string().describe(
+var createTeamInvitationRequestSchema2 = z113.object({
+  email: z113.email().describe("Email address of the person to invite."),
+  role: z113.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: z1122.guid().optional().describe(
+  processId: z113.guid().optional().describe(
     "Invite the person to this Clarity process rather than the whole team. Requires the team:clarity-member role."
   )
 });
-var acceptTeamInvitationRequestSchema2 = z1122.object({
-  name: z1122.string().optional()
+var acceptTeamInvitationRequestSchema2 = z113.object({
+  name: z113.string().optional()
 });
-var acceptTeamInvitationResponseSchema2 = z1122.object({
-  success: z1122.boolean(),
-  teamId: z1122.guid().optional(),
-  processId: z1122.guid().optional()
+var acceptTeamInvitationResponseSchema2 = z113.object({
+  success: z113.boolean(),
+  teamId: z113.guid().optional(),
+  processId: z113.guid().optional()
 });
-var bulkInviteResponseSchema2 = z1122.object({
-  succeeded: z1122.number(),
-  skipped: z1122.number(),
-  failed: z1122.number()
+var bulkInviteResponseSchema2 = z113.object({
+  succeeded: z113.number(),
+  skipped: z113.number(),
+  failed: z113.number()
 });
 var TEAM_DISCOVERY_MODES2 = ["request", "auto"];
-var teamDiscoveryModeSchema2 = z113.enum(TEAM_DISCOVERY_MODES2);
-var BrowserRegionSchema2 = z113.enum([
+var teamDiscoveryModeSchema2 = z114.enum(TEAM_DISCOVERY_MODES2);
+var BrowserRegionSchema2 = z114.enum([
   "us-west-2",
   "us-east-1",
   "eu-central-1",
   "ap-southeast-1"
 ]);
-var BrowserLocationSchema2 = z113.union([
-  z113.literal("cz"),
-  z113.literal("de"),
-  z113.literal("fr"),
-  z113.literal("gb"),
-  z113.literal("it"),
-  z113.literal("pl"),
-  z113.literal("sk")
+var BrowserLocationSchema2 = z114.union([
+  z114.literal("cz"),
+  z114.literal("de"),
+  z114.literal("fr"),
+  z114.literal("gb"),
+  z114.literal("it"),
+  z114.literal("pl"),
+  z114.literal("sk")
 ]);
-var teamMemberApiSchema2 = z113.object({
-  id: z113.guid(),
-  name: z113.string().nullable(),
-  email: z113.email(),
-  role: z113.string(),
-  inheritedFromOrg: z113.boolean().default(false)
-});
-var listTeamMembersResponseSchema2 = z113.object({
-  members: z113.array(teamMemberApiSchema2),
-  total: z113.number().int().nonnegative(),
-  limit: z113.number().int().positive(),
-  offset: z113.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema2 = z113.object({
-  role: z113.string()
-});
-var removeMemberResponseSchema2 = z113.object({
-  success: z113.literal(true),
-  nextTeamId: z113.guid().nullable(),
-  planType: z113.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema2 = z113.object({
-  role: z113.string().nullable(),
+var teamMemberApiSchema2 = z114.object({
+  id: z114.guid(),
+  name: z114.string().nullable(),
+  email: z114.email(),
+  role: z114.string(),
+  inheritedFromOrg: z114.boolean().default(false)
+});
+var listTeamMembersResponseSchema2 = z114.object({
+  members: z114.array(teamMemberApiSchema2),
+  total: z114.number().int().nonnegative(),
+  limit: z114.number().int().positive(),
+  offset: z114.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema2 = z114.object({
+  role: z114.string()
+});
+var removeMemberResponseSchema2 = z114.object({
+  success: z114.literal(true),
+  nextTeamId: z114.guid().nullable(),
+  planType: z114.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema2 = z114.object({
+  role: z114.string().nullable(),
   // True only when a real `user_team_memberships` row exists. `role` can be a
   // read-only *virtual* role for org leaders who haven't joined, so it is not a
   // membership signal on its own — use this flag to tell a real member apart.
-  isMember: z113.boolean()
+  isMember: z114.boolean()
 });
-var addTeamMemberRequestSchema2 = z113.object({
-  userId: z113.guid(),
-  role: z113.string()
+var addTeamMemberRequestSchema2 = z114.object({
+  userId: z114.guid(),
+  role: z114.string()
 });
-var updateTeamRequestSchema2 = z113.object({
-  name: z113.string().min(1).optional(),
-  slack_team_id: z113.string().optional(),
+var updateTeamRequestSchema2 = z114.object({
+  name: z114.string().min(1).optional(),
+  slack_team_id: z114.string().optional(),
   discovery_mode: teamDiscoveryModeSchema2.optional()
 });
-var teamApiSchema2 = z113.object({
-  id: z113.guid().describe("Unique team identifier"),
-  name: z113.string().describe("Human-readable team name"),
-  created_at: z113.string().describe("ISO 8601 creation timestamp"),
-  organization_id: z113.guid().nullable().describe("Parent organization ID, or null if the team is standalone"),
-  slack_team_id: z113.string().nullable().describe("Linked Slack workspace ID, or null if Slack is not connected"),
+var teamApiSchema2 = z114.object({
+  id: z114.guid().describe("Unique team identifier"),
+  name: z114.string().describe("Human-readable team name"),
+  created_at: z114.string().describe("ISO 8601 creation timestamp"),
+  organization_id: z114.guid().nullable().describe("Parent organization ID, or null if the team is standalone"),
+  slack_team_id: z114.string().nullable().describe("Linked Slack workspace ID, or null if Slack is not connected"),
   // Responses use x-extensible-enum: adding a discovery mode to a strict
   // response enum is breaking in oasdiff, while an added x-extensible-enum
   // value is not. The strict request enum (updateTeamRequestSchema) still
@@ -34873,18 +35162,18 @@ var teamApiSchema2 = z113.object({
   discovery_mode: extensibleEnum2(TEAM_DISCOVERY_MODES2, {
     description: "How the team handles agent discovery"
   }),
-  automations_migrated_at: z113.string().nullable().describe(
+  automations_migrated_at: z114.string().nullable().describe(
     "ISO 8601 timestamp of the team's move to the Automations workspace, or null if it has not moved"
   ),
-  automation_revisions_migrated_at: z113.string().nullable().describe(
+  automation_revisions_migrated_at: z114.string().nullable().describe(
     "ISO 8601 timestamp of the team's move to automation revisions, or null. Narrower than automations_migrated_at: a team can be on the workspace without revisions"
   )
 });
-var teamResponseApiSchema2 = z113.object({
+var teamResponseApiSchema2 = z114.object({
   team: teamApiSchema2
 });
 var TEAM_CONFIG_VERSION2 = 1;
-var teamConfigDataSchema2 = z113.object({
+var teamConfigDataSchema2 = z114.object({
   browserProviderOverride: BrowserProviderTypeSchema2.nullable().optional(),
   // Egress identity (proxy country) — what the target site sees.
   browserLocationOverride: BrowserLocationSchema2.nullable().optional(),
@@ -34896,125 +35185,125 @@ var teamConfigDataSchema2 = z113.object({
   dataHandlingOverride: DataHandlingSchema2.nullable().optional(),
   // Domains that bypass the org VPN and connect directly (split tunnel).
   // Union'd at runtime with the org-default list on vpn_proxy_config.
-  vpnBypassDomains: z113.array(z113.string()).max(MAX_VPN_BYPASS_DOMAINS2).nullable().optional(),
+  vpnBypassDomains: z114.array(z114.string()).max(MAX_VPN_BYPASS_DOMAINS2).nullable().optional(),
   // Deprecated: superseded by dataResidencyOverride / dataHandlingOverride.
   // Kept optional so existing v1 rows still parse; the resolver reads the new
   // fields first and falls back to these. Do not surface in the UI.
   browserRegionOverride: BrowserRegionSchema2.nullable().optional(),
-  sessionRecordingOverride: z113.boolean().nullable().optional()
+  sessionRecordingOverride: z114.boolean().nullable().optional()
 });
-var teamConfigSchema2 = z113.object({
-  version: z113.literal(TEAM_CONFIG_VERSION2),
+var teamConfigSchema2 = z114.object({
+  version: z114.literal(TEAM_CONFIG_VERSION2),
   data: teamConfigDataSchema2
 });
-var listTeamInvitesResponseSchema2 = z113.object({
-  invitations: z113.array(teamInvitationApiSchema2)
+var listTeamInvitesResponseSchema2 = z114.object({
+  invitations: z114.array(teamInvitationApiSchema2)
 });
-var teamInsightsCopilotSchema = z114.object({
-  id: z114.guid(),
-  name: z114.string(),
-  teamName: z114.string().nullable().optional(),
-  created_at: z114.string().nullable(),
-  updated_at: z114.string().nullable(),
-  team_id: z114.string().nullable(),
-  thread_id: z114.string().nullable(),
-  slack_enabled: z114.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z114.object({
-  id: z114.guid(),
-  name: z114.string().nullable(),
-  email: z114.string()
+var teamInsightsCopilotSchema = z115.object({
+  id: z115.guid(),
+  name: z115.string(),
+  teamName: z115.string().nullable().optional(),
+  created_at: z115.string().nullable(),
+  updated_at: z115.string().nullable(),
+  team_id: z115.string().nullable(),
+  thread_id: z115.string().nullable(),
+  slack_enabled: z115.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z115.object({
+  id: z115.guid(),
+  name: z115.string().nullable(),
+  email: z115.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z114.number(),
-    lastRun: z114.string().nullable()
+    runCount: z115.number(),
+    lastRun: z115.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z114.object({
+var teamInsightsMetricSourceSchema = z115.object({
   source: agentRunSourceSchema2,
-  runsTotal: z114.number(),
-  completedRuns: z114.number()
+  runsTotal: z115.number(),
+  completedRuns: z115.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z114.array(z114.string()),
-  uniqueUsersCount: z114.number(),
-  users: z114.array(teamInsightsUserUsageSchema),
-  totalRuns: z114.number(),
-  completedRuns: z114.number(),
-  totalTimeSpentMs: z114.number(),
-  averageTimeSpentMs: z114.number(),
-  completedRunsWithTiming: z114.number(),
-  sources: z114.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z114.object({
-  data: z114.array(teamInsightsCopilotWithRunsSchema),
-  total: z114.number()
-});
-var teamInsightsMetricsResponseSchema = z114.object({
-  runsTotal: z114.number(),
-  completedRuns: z114.number(),
-  sources: z114.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z114.object({
-  id: z114.guid(),
-  created_at: z114.string(),
-  updated_at: z114.string(),
-  agent_id: z114.guid(),
-  agent_name: z114.string(),
-  build_id: z114.guid(),
-  source: z114.string().nullable(),
-  started_at: z114.string().nullable(),
-  completed_at: z114.string().nullable()
-});
-var teamInsightsAgentSchema = z114.object({
-  id: z114.guid(),
-  name: z114.string(),
-  teamName: z114.string().nullable().optional(),
-  runs: z114.array(teamInsightsUserAgentRunSchema)
-});
-var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z114.array(teamInsightsAgentSchema),
-  runs: z114.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z114.number()
-});
-var teamInsightsUsersResponseSchema = z114.object({
-  data: z114.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z114.number()
-});
-var guardrailsAuthorSchema = z115.object({
+  integrations: z115.array(z115.string()),
+  uniqueUsersCount: z115.number(),
+  users: z115.array(teamInsightsUserUsageSchema),
+  totalRuns: z115.number(),
+  completedRuns: z115.number(),
+  totalTimeSpentMs: z115.number(),
+  averageTimeSpentMs: z115.number(),
+  completedRunsWithTiming: z115.number(),
+  sources: z115.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z115.object({
+  data: z115.array(teamInsightsCopilotWithRunsSchema),
+  total: z115.number()
+});
+var teamInsightsMetricsResponseSchema = z115.object({
+  runsTotal: z115.number(),
+  completedRuns: z115.number(),
+  sources: z115.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z115.object({
   id: z115.guid(),
-  name: z115.string().nullable(),
-  email: z115.email()
-});
-var guardrailsRevisionSchema = z115.object({
+  created_at: z115.string(),
+  updated_at: z115.string(),
+  agent_id: z115.guid(),
+  agent_name: z115.string(),
+  build_id: z115.guid(),
+  source: z115.string().nullable(),
+  started_at: z115.string().nullable(),
+  completed_at: z115.string().nullable()
+});
+var teamInsightsAgentSchema = z115.object({
   id: z115.guid(),
-  teamId: z115.guid(),
-  guardrailsText: z115.string().nullable(),
-  blockedDomains: z115.array(z115.string()),
-  createdAt: z115.string(),
+  name: z115.string(),
+  teamName: z115.string().nullable().optional(),
+  runs: z115.array(teamInsightsUserAgentRunSchema)
+});
+var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
+  agents: z115.array(teamInsightsAgentSchema),
+  runs: z115.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z115.number()
+});
+var teamInsightsUsersResponseSchema = z115.object({
+  data: z115.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z115.number()
+});
+var guardrailsAuthorSchema = z116.object({
+  id: z116.guid(),
+  name: z116.string().nullable(),
+  email: z116.email()
+});
+var guardrailsRevisionSchema = z116.object({
+  id: z116.guid(),
+  teamId: z116.guid(),
+  guardrailsText: z116.string().nullable(),
+  blockedDomains: z116.array(z116.string()),
+  createdAt: z116.string(),
   createdBy: guardrailsAuthorSchema
 });
-var getTeamGuardrailsResponseSchema = z115.object({
+var getTeamGuardrailsResponseSchema = z116.object({
   current: guardrailsRevisionSchema.nullable()
 });
-var listTeamGuardrailsRevisionsQuerySchema = z115.object({
-  limit: z115.coerce.number().int().min(1).max(100).default(20),
-  offset: z115.coerce.number().int().min(0).default(0)
+var listTeamGuardrailsRevisionsQuerySchema = z116.object({
+  limit: z116.coerce.number().int().min(1).max(100).default(20),
+  offset: z116.coerce.number().int().min(0).default(0)
 });
-var listTeamGuardrailsRevisionsResponseSchema = z115.object({
-  revisions: z115.array(guardrailsRevisionSchema),
-  total: z115.number().int().nonnegative()
+var listTeamGuardrailsRevisionsResponseSchema = z116.object({
+  revisions: z116.array(guardrailsRevisionSchema),
+  total: z116.number().int().nonnegative()
 });
-var createTeamGuardrailsRevisionRequestSchema = z115.object({
-  guardrailsText: z115.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
-  blockedDomains: z115.array(z115.string()).max(MAX_BLOCKED_DOMAINS)
+var createTeamGuardrailsRevisionRequestSchema = z116.object({
+  guardrailsText: z116.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z116.array(z116.string()).max(MAX_BLOCKED_DOMAINS)
 });
-var userDismissalListResponseSchema = z116.object({
-  data: z116.array(z116.string())
+var userDismissalListResponseSchema = z117.object({
+  data: z117.array(z117.string())
 });
-var userDismissalMutationSchema = z116.object({
-  elementKey: z116.string()
+var userDismissalMutationSchema = z117.object({
+  elementKey: z117.string()
 });
 function orgWelcomeDismissalKey(orgId) {
   return `org-welcome:${orgId}`;
@@ -35026,94 +35315,94 @@ var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z117.object({
-  id: z117.guid(),
-  name: z117.string(),
-  server: z117.string(),
-  username: z117.string(),
-  enabled: z117.boolean(),
-  passwordSet: z117.boolean(),
-  organizationCount: z117.number().int().nonnegative(),
-  createdAt: z117.string(),
-  updatedAt: z117.string()
-});
-var vpnProxyConfigListResponseSchema = z117.object({
-  configs: z117.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z117.object({
-  name: z117.string().trim().min(1).max(NAME_MAX),
-  server: z117.string().trim().min(1).max(URL_MAX).url(),
-  username: z117.string().trim().min(1).max(USERNAME_MAX),
-  password: z117.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z117.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z117.object({
+var vpnProxyConfigSummarySchema = z118.object({
+  id: z118.guid(),
+  name: z118.string(),
+  server: z118.string(),
+  username: z118.string(),
+  enabled: z118.boolean(),
+  passwordSet: z118.boolean(),
+  organizationCount: z118.number().int().nonnegative(),
+  createdAt: z118.string(),
+  updatedAt: z118.string()
+});
+var vpnProxyConfigListResponseSchema = z118.object({
+  configs: z118.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z118.object({
+  name: z118.string().trim().min(1).max(NAME_MAX),
+  server: z118.string().trim().min(1).max(URL_MAX).url(),
+  username: z118.string().trim().min(1).max(USERNAME_MAX),
+  password: z118.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z118.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z118.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z117.object({
-  name: z117.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z117.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z117.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z117.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z117.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z118.object({
+  name: z118.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z118.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z118.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z118.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z118.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z117.object({
+var vpnProxyConfigUpdateResponseSchema = z118.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z117.object({
-  success: z117.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z118.object({
+  success: z118.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z117.object({
-  id: z117.guid(),
-  organizationId: z117.guid(),
-  organizationName: z117.string(),
-  bypassDomains: z117.array(z117.string()),
-  vpnEnforced: z117.boolean(),
-  attachedAt: z117.string()
+var vpnProxyConfigOrganizationSchema = z118.object({
+  id: z118.guid(),
+  organizationId: z118.guid(),
+  organizationName: z118.string(),
+  bypassDomains: z118.array(z118.string()),
+  vpnEnforced: z118.boolean(),
+  attachedAt: z118.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z117.object({
-  organizations: z117.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z118.object({
+  organizations: z118.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z117.object({
-  organizationId: z117.guid(),
-  bypassDomains: z117.array(z117.string()).max(MAX_VPN_BYPASS_DOMAINS2).prefault([]),
-  vpnEnforced: z117.boolean().prefault(false)
+var vpnProxyConfigAttachOrganizationRequestSchema = z118.object({
+  organizationId: z118.guid(),
+  bypassDomains: z118.array(z118.string()).max(MAX_VPN_BYPASS_DOMAINS2).prefault([]),
+  vpnEnforced: z118.boolean().prefault(false)
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z117.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z118.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z117.object({
-  success: z117.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z118.object({
+  success: z118.literal(true)
 });
-var vpnProxyConfigForOrganizationAttachmentSchema = z117.object({
-  bypassDomains: z117.array(z117.string()),
-  vpnEnforced: z117.boolean()
+var vpnProxyConfigForOrganizationAttachmentSchema = z118.object({
+  bypassDomains: z118.array(z118.string()),
+  vpnEnforced: z118.boolean()
 });
-var vpnProxyConfigForOrganizationResponseSchema = z117.object({
+var vpnProxyConfigForOrganizationResponseSchema = z118.object({
   config: vpnProxyConfigSummarySchema.nullable(),
   attachment: vpnProxyConfigForOrganizationAttachmentSchema.nullable()
 });
-var vpnProxyConfigUpdateOrganizationPolicyRequestSchema = z117.object({
-  bypassDomains: z117.array(z117.string()).max(MAX_VPN_BYPASS_DOMAINS2).optional(),
-  vpnEnforced: z117.boolean().optional()
+var vpnProxyConfigUpdateOrganizationPolicyRequestSchema = z118.object({
+  bypassDomains: z118.array(z118.string()).max(MAX_VPN_BYPASS_DOMAINS2).optional(),
+  vpnEnforced: z118.boolean().optional()
 });
-var vpnProxyConfigUpdateOrganizationPolicyResponseSchema = z117.object({
+var vpnProxyConfigUpdateOrganizationPolicyResponseSchema = z118.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var workflowExecutionReportSchema = z118.object({
-  agentRunId: z118.string(),
-  provider: z118.string().nullable(),
-  expectedProgrammatic: z118.number(),
-  totalSteps: z118.number(),
-  executedSteps: z118.number(),
-  calls: z118.number(),
-  executions: z118.number(),
-  handoffs: z118.number(),
-  errors: z118.number(),
-  failures: z118.number(),
-  stopReasons: z118.array(z118.string()),
-  reachedCompletion: z118.boolean(),
-  programmaticExecutionRate: z118.number()
+var workflowExecutionReportSchema = z119.object({
+  agentRunId: z119.string(),
+  provider: z119.string().nullable(),
+  expectedProgrammatic: z119.number(),
+  totalSteps: z119.number(),
+  executedSteps: z119.number(),
+  calls: z119.number(),
+  executions: z119.number(),
+  handoffs: z119.number(),
+  errors: z119.number(),
+  failures: z119.number(),
+  stopReasons: z119.array(z119.string()),
+  reachedCompletion: z119.boolean(),
+  programmaticExecutionRate: z119.number()
 });
 var OAUTH_SEED_RESOLVE_HEADROOM_MS = 10 * 6e4;
 var OAUTH_SEED_JITTER_MS = 5 * 6e4;
@@ -35380,7 +35669,7 @@ var CASE_FILTER_STATUS_LEGACY2 = [
   "completed",
   "failed"
 ];
-var caseFilterStatusSchema2 = z119.enum([
+var caseFilterStatusSchema2 = z120.enum([
   ...CASE_FILTER_STATUS_BUCKETS2,
   ...CASE_FILTER_STATUS_LEGACY2
 ]);
@@ -35388,18 +35677,18 @@ var CASE_FILTERABLE_ISSUE_SEVERITIES2 = [
   CASE_OUTCOME_SEVERITY2.CRITICAL,
   CASE_OUTCOME_SEVERITY2.MEDIUM
 ];
-var caseIssueSeverityFilterSchema2 = z119.enum(
+var caseIssueSeverityFilterSchema2 = z120.enum(
   CASE_FILTERABLE_ISSUE_SEVERITIES2
 );
-var casesFiltersSchema2 = z119.object({
-  status: z119.array(caseFilterStatusSchema2).optional(),
-  issue_severity: z119.array(caseIssueSeverityFilterSchema2).optional(),
-  priority: z119.array(casePriorityFilterSchema2).optional(),
-  created_at_from: z119.string().optional(),
-  created_at_to: z119.string().optional(),
-  updated_at_from: z119.string().optional(),
-  updated_at_to: z119.string().optional(),
-  labels: z119.record(z119.string(), z119.array(z119.string())).optional(),
+var casesFiltersSchema2 = z120.object({
+  status: z120.array(caseFilterStatusSchema2).optional(),
+  issue_severity: z120.array(caseIssueSeverityFilterSchema2).optional(),
+  priority: z120.array(casePriorityFilterSchema2).optional(),
+  created_at_from: z120.string().optional(),
+  created_at_to: z120.string().optional(),
+  updated_at_from: z120.string().optional(),
+  updated_at_to: z120.string().optional(),
+  labels: z120.record(z120.string(), z120.array(z120.string())).optional(),
   /**
    * Field-value filters over a typed Queue's `json_data` payload, ANDed with
    * each other and with every facet above. Each names a scalar path declared in
@@ -35410,16 +35699,16 @@ var casesFiltersSchema2 = z119.object({
    * the label filters already use, because a `{path, operator, value}` triple
    * has no unambiguous query-string spelling.
    */
-  json_data: z119.array(caseJsonDataFilterSchema2).max(MAX_CASE_JSON_DATA_FILTERS2).optional()
+  json_data: z120.array(caseJsonDataFilterSchema2).max(MAX_CASE_JSON_DATA_FILTERS2).optional()
 });
-var casesListRequestBodySchema2 = z119.object({
+var casesListRequestBodySchema2 = z120.object({
   filters: casesFiltersSchema2.default({}),
-  limit: z119.int().min(1).max(100).default(25),
-  offset: z119.int().min(0).default(0),
-  sort_by: z119.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z119.enum(["asc", "desc"]).default("desc"),
-  search: z119.string().optional(),
-  count_only: z119.boolean().optional().describe(
+  limit: z120.int().min(1).max(100).default(25),
+  offset: z120.int().min(0).default(0),
+  sort_by: z120.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z120.enum(["asc", "desc"]).default("desc"),
+  search: z120.string().optional(),
+  count_only: z120.boolean().optional().describe(
     "Skip Case row selection, enrichment, and transformation. The normal response shape contains an empty cases array and the matching total."
   )
 });
@@ -35540,7 +35829,7 @@ function setFilterValuesByCategoryKey2(filters, categoryKey, values) {
     if (values.length === 0) {
       return omitFilter2(filters, categoryKey);
     }
-    const parsed = z119.array(ARRAY_FILTER_ITEM_SCHEMAS2[categoryKey]).safeParse(values);
+    const parsed = z120.array(ARRAY_FILTER_ITEM_SCHEMAS2[categoryKey]).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -36591,7 +36880,7 @@ The step exists with no build. Retry with: duvo revisions create --agent ${agent
       if (parsedBuild.success && parsedBuild.data.build) {
         build = parsedBuild.data.build;
       }
-      const rawEnvelope = z120.object({ build: jsonValueSchema2 }).safeParse(rawBuild);
+      const rawEnvelope = z121.object({ build: jsonValueSchema2 }).safeParse(rawBuild);
       if (rawEnvelope.success) {
         rawRevisionBuild = rawEnvelope.data.build;
       }
@@ -37270,30 +37559,30 @@ function registerAgentsEvalScores(agents) {
 __name(registerAgentsEvalScores, "registerAgentsEvalScores");
 
 // src/api/build-schemas.ts
-import { z as z121 } from "zod";
-var publicBuildSchema2 = z121.object({
-  id: z121.string(),
-  agent_id: z121.string(),
-  name: z121.string(),
-  status: z121.string().nullish(),
+import { z as z123 } from "zod";
+var publicBuildSchema2 = z123.object({
+  id: z123.string(),
+  agent_id: z123.string(),
+  name: z123.string(),
+  status: z123.string().nullish(),
   config: jsonValueSchema2.nullish(),
-  revision_number: z121.number().nullish(),
-  handover_to: z121.string().nullish(),
-  created_at: z121.string().nullish(),
-  updated_at: z121.string().nullish()
-});
-var listBuildsResponseSchema3 = z121.object({
-  builds: z121.array(publicBuildSchema2),
-  total: z121.number().nullish(),
-  limit: z121.number().nullish(),
-  offset: z121.number().nullish()
-});
-var getBuildResponseSchema = z121.object({
+  revision_number: z123.number().nullish(),
+  handover_to: z123.string().nullish(),
+  created_at: z123.string().nullish(),
+  updated_at: z123.string().nullish()
+});
+var listBuildsResponseSchema3 = z123.object({
+  builds: z123.array(publicBuildSchema2),
+  total: z123.number().nullish(),
+  limit: z123.number().nullish(),
+  offset: z123.number().nullish()
+});
+var getBuildResponseSchema = z123.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z121.object({
+var createBuildResponseSchema = z123.object({
   build: publicBuildSchema2,
-  agent: z121.object({ id: z121.string() })
+  agent: z123.object({ id: z123.string() })
 });
 
 // src/commands/agents/get.ts
@@ -37777,30 +38066,30 @@ ${plan.warnings.dropped_memory_count} AOP exception(s) will be cleared for users
 __name(renderPlan, "renderPlan");
 
 // src/api/schedule-schemas.ts
-import { z as z123 } from "zod";
-var publicScheduleSchema = z123.object({
-  id: z123.string(),
-  build_id: z123.string(),
-  agent_id: z123.string(),
-  user_id: z123.string(),
-  enabled: z123.boolean(),
-  frequency: z123.string(),
-  time: z123.string().nullish(),
-  timezone: z123.string(),
-  day: z123.string().nullish(),
-  day_of_month: z123.number().nullish(),
-  cron: z123.string().nullish(),
-  source: z123.string().nullish(),
-  task: z123.string().nullish(),
-  recurring: z123.boolean().nullish(),
-  created_at: z123.string(),
-  updated_at: z123.string()
-});
-var listSchedulesResponseSchema = z123.object({
-  schedules: z123.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z123.object({
-  success: z123.literal(true)
+import { z as z124 } from "zod";
+var publicScheduleSchema = z124.object({
+  id: z124.string(),
+  build_id: z124.string(),
+  agent_id: z124.string(),
+  user_id: z124.string(),
+  enabled: z124.boolean(),
+  frequency: z124.string(),
+  time: z124.string().nullish(),
+  timezone: z124.string(),
+  day: z124.string().nullish(),
+  day_of_month: z124.number().nullish(),
+  cron: z124.string().nullish(),
+  source: z124.string().nullish(),
+  task: z124.string().nullish(),
+  recurring: z124.boolean().nullish(),
+  created_at: z124.string(),
+  updated_at: z124.string()
+});
+var listSchedulesResponseSchema = z124.object({
+  schedules: z124.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z124.object({
+  success: z124.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -38248,58 +38537,58 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z124 } from "zod";
-var triggerSchema = z124.object({
-  id: z124.string(),
-  agent_id: z124.string(),
-  user_id: z124.string(),
-  integration_slug: z124.string(),
-  trigger_type: z124.string(),
-  filter_config: z124.record(z124.string(), z124.unknown()),
-  integration_instance_id: z124.string(),
-  enabled: z124.boolean(),
-  created_at: z124.string(),
-  updated_at: z124.string()
-});
-var listTriggersResponseSchema = z124.object({
-  triggers: z124.array(triggerSchema)
-});
-var triggerTypeSchema = z124.object({
-  integration_slug: z124.string(),
-  integration_name: z124.string(),
-  icon_url: z124.string(),
-  trigger_type: z124.string(),
-  label: z124.string(),
-  description: z124.string(),
-  filter_schema: z124.record(z124.string(), z124.unknown())
-});
-var listTriggerTypesResponseSchema = z124.object({
-  trigger_types: z124.array(triggerTypeSchema)
-});
-var deleteTriggerResponseSchema = z124.object({
-  success: z124.literal(true)
-});
-var slackTriggerResponseSchema = z124.object({
+import { z as z125 } from "zod";
+var triggerSchema = z125.object({
+  id: z125.string(),
+  agent_id: z125.string(),
+  user_id: z125.string(),
+  integration_slug: z125.string(),
+  trigger_type: z125.string(),
+  filter_config: z125.record(z125.string(), z125.unknown()),
+  integration_instance_id: z125.string(),
+  enabled: z125.boolean(),
+  created_at: z125.string(),
+  updated_at: z125.string()
+});
+var listTriggersResponseSchema = z125.object({
+  triggers: z125.array(triggerSchema)
+});
+var triggerTypeSchema = z125.object({
+  integration_slug: z125.string(),
+  integration_name: z125.string(),
+  icon_url: z125.string(),
+  trigger_type: z125.string(),
+  label: z125.string(),
+  description: z125.string(),
+  filter_schema: z125.record(z125.string(), z125.unknown())
+});
+var listTriggerTypesResponseSchema = z125.object({
+  trigger_types: z125.array(triggerTypeSchema)
+});
+var deleteTriggerResponseSchema = z125.object({
+  success: z125.literal(true)
+});
+var slackTriggerResponseSchema = z125.object({
   slack_trigger: triggerSchema
 });
-var listSlackTriggersResponseSchema = z124.object({
-  slack_triggers: z124.array(triggerSchema)
+var listSlackTriggersResponseSchema = z125.object({
+  slack_triggers: z125.array(triggerSchema)
 });
-var deleteSlackTriggerResponseSchema = z124.object({
-  success: z124.literal(true)
+var deleteSlackTriggerResponseSchema = z125.object({
+  success: z125.literal(true)
 });
-var slackBoundWorkspaceSchema = z124.object({
-  slack_team_id: z124.string(),
-  slack_workspace_name: z124.string(),
-  integration_instance_id: z124.string(),
-  shared: z124.boolean()
+var slackBoundWorkspaceSchema = z125.object({
+  slack_team_id: z125.string(),
+  slack_workspace_name: z125.string(),
+  integration_instance_id: z125.string(),
+  shared: z125.boolean()
 });
-var listSlackBoundWorkspacesResponseSchema = z124.object({
-  workspaces: z124.array(slackBoundWorkspaceSchema)
+var listSlackBoundWorkspacesResponseSchema = z125.object({
+  workspaces: z125.array(slackBoundWorkspaceSchema)
 });
 
 // src/commands/agents/slack-triggers/render-slack-trigger.ts
-import { z as z125 } from "zod";
+import { z as z126 } from "zod";
 function readChannelId(trigger) {
   const value = trigger.filter_config.channelId;
   return typeof value === "string" ? value : "";
@@ -38315,9 +38604,9 @@ function readWorkspaceId(trigger) {
   return typeof value === "string" ? value : "";
 }
 __name(readWorkspaceId, "readWorkspaceId");
-var keywordMatchRuleSchema = z125.object({
-  kind: z125.literal("contains"),
-  values: z125.array(z125.string())
+var keywordMatchRuleSchema = z126.object({
+  kind: z126.literal("contains"),
+  values: z126.array(z126.string())
 });
 function readMatchRule(trigger) {
   const parsed = keywordMatchRuleSchema.safeParse(
@@ -39893,54 +40182,54 @@ function registerAutomations(program) {
 __name(registerAutomations, "registerAutomations");
 
 // src/api/integration-schemas.ts
-import { z as z126 } from "zod";
-var integrationSchema = z126.object({
-  id: z126.string(),
-  name: z126.string(),
-  type: z126.string(),
-  provider: z126.string(),
-  user_id: z126.string().nullable(),
-  team_id: z126.string(),
-  server_url: z126.string().optional(),
-  transport_type: z126.string().optional(),
-  auth_method: z126.string().nullish(),
-  custom_integration_id: z126.string().nullish(),
-  icon_url: z126.string().nullish(),
-  oauth_provider: z126.string().nullish(),
-  oauth_provider_key: z126.string().nullish(),
-  oauth_scopes: z126.array(z126.string()).nullish(),
-  integration_id: z126.string().nullish(),
-  created_at: z126.string(),
-  updated_at: z126.string()
-});
-var integrationsListResponseSchema3 = z126.object({
-  integrations: z126.array(integrationSchema)
+import { z as z127 } from "zod";
+var integrationSchema = z127.object({
+  id: z127.string(),
+  name: z127.string(),
+  type: z127.string(),
+  provider: z127.string(),
+  user_id: z127.string().nullable(),
+  team_id: z127.string(),
+  server_url: z127.string().optional(),
+  transport_type: z127.string().optional(),
+  auth_method: z127.string().nullish(),
+  custom_integration_id: z127.string().nullish(),
+  icon_url: z127.string().nullish(),
+  oauth_provider: z127.string().nullish(),
+  oauth_provider_key: z127.string().nullish(),
+  oauth_scopes: z127.array(z127.string()).nullish(),
+  integration_id: z127.string().nullish(),
+  created_at: z127.string(),
+  updated_at: z127.string()
+});
+var integrationsListResponseSchema3 = z127.object({
+  integrations: z127.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema3 = z126.object({
-  id: z126.string(),
-  integration_id: z126.string().nullable(),
-  custom_integration_id: z126.string().nullable(),
-  integration_type: z126.string(),
-  integration_name: z126.string(),
-  created_at: z126.string()
+var buildIntegrationConfigSchema3 = z127.object({
+  id: z127.string(),
+  integration_id: z127.string().nullable(),
+  custom_integration_id: z127.string().nullable(),
+  integration_type: z127.string(),
+  integration_name: z127.string(),
+  created_at: z127.string()
 });
-var listBuildIntegrationsResponseSchema3 = z126.object({
-  integrations: z126.array(buildIntegrationConfigSchema3)
+var listBuildIntegrationsResponseSchema3 = z127.object({
+  integrations: z127.array(buildIntegrationConfigSchema3)
 });
-var attachBuildIntegrationsResponseSchema = z126.object({
-  success: z126.boolean(),
-  count: z126.number()
+var attachBuildIntegrationsResponseSchema = z127.object({
+  success: z127.boolean(),
+  count: z127.number()
 });
-var buildIntegrationConnectionSchema = z126.object({
-  connection_id: z126.string(),
-  created_at: z126.string()
+var buildIntegrationConnectionSchema = z127.object({
+  connection_id: z127.string(),
+  created_at: z127.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z126.object({
-  connections: z126.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z127.object({
+  connections: z127.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z126.object({
-  success: z126.boolean()
+var successResponseSchema = z127.object({
+  success: z127.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -39983,15 +40272,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z127 } from "zod";
-var slotSchema = z127.object({
-  config_id: z127.string(),
-  integration_type: z127.string(),
-  linked_queue_count: z127.number()
+import { z as z128 } from "zod";
+var slotSchema = z128.object({
+  config_id: z128.string(),
+  integration_type: z128.string(),
+  linked_queue_count: z128.number()
 });
-var responseSchema3 = z127.object({
-  configs: z127.array(slotSchema),
-  has_available_queues: z127.boolean()
+var responseSchema3 = z128.object({
+  configs: z128.array(slotSchema),
+  has_available_queues: z128.boolean()
 });
 var TABLE_COLUMNS13 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -40514,9 +40803,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z128 } from "zod";
-var promoteResponseSchema = z128.object({
-  success: z128.boolean()
+import { z as z129 } from "zod";
+var promoteResponseSchema = z129.object({
+  success: z129.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -42209,7 +42498,7 @@ function buildListSearchParams({
 __name(buildListSearchParams, "buildListSearchParams");
 
 // src/commands/cases/runs.ts
-import { z as z129 } from "zod";
+import { z as z130 } from "zod";
 var MIN_LIMIT5 = 1;
 var MAX_LIMIT5 = 10;
 var DEFAULT_LIMIT5 = 3;
@@ -42227,17 +42516,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z129.object({
-  id: z129.string(),
-  type: z129.string(),
-  role: z129.string(),
-  timestamp: z129.string(),
-  text_content: z129.string().nullish(),
-  tool_call: z129.object({ id: z129.string(), name: z129.string() }).passthrough().nullish(),
-  tool_result: z129.object({ tool_call_id: z129.string() }).passthrough().nullish()
+var recentMessageSchema = z130.object({
+  id: z130.string(),
+  type: z130.string(),
+  role: z130.string(),
+  timestamp: z130.string(),
+  text_content: z130.string().nullish(),
+  tool_call: z130.object({ id: z130.string(), name: z130.string() }).passthrough().nullish(),
+  tool_result: z130.object({ tool_call_id: z130.string() }).passthrough().nullish()
 });
-var recentMessagesResponseSchema = z129.object({
-  messages: z129.array(recentMessageSchema)
+var recentMessagesResponseSchema = z130.object({
+  messages: z130.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -42430,65 +42719,65 @@ function registerCases(program) {
 __name(registerCases, "registerCases");
 
 // src/api/clarity-schemas.ts
-import { z as z130 } from "zod";
-var clarityListProcessSchema = z130.object({
-  id: z130.guid(),
-  name: z130.string(),
+import { z as z131 } from "zod";
+var clarityListProcessSchema = z131.object({
+  id: z131.guid(),
+  name: z131.string(),
   status: clarityProcessStatusSchema,
   visibility: clarityProcessVisibilitySchema,
-  version: z130.number().int(),
-  capture_count: z130.number().int(),
-  capture_counts: z130.object({
-    video: z130.number().int(),
-    interview: z130.number().int(),
-    document: z130.number().int()
+  version: z131.number().int(),
+  capture_count: z131.number().int(),
+  capture_counts: z131.object({
+    video: z131.number().int(),
+    interview: z131.number().int(),
+    document: z131.number().int()
   }).optional(),
-  pending_invitation_count: z130.number().int(),
-  contributors: z130.array(
-    z130.object({
-      user_id: z130.string(),
-      user_name: z130.string()
+  pending_invitation_count: z131.number().int(),
+  contributors: z131.array(
+    z131.object({
+      user_id: z131.string(),
+      user_name: z131.string()
     })
   ),
-  created_at: z130.string(),
-  created_by_name: z130.string().nullable()
-});
-var listClarityProcessesResponseSchema = z130.object({
-  processes: z130.array(clarityListProcessSchema),
-  total: z130.number().int(),
-  limit: z130.number().int(),
-  offset: z130.number().int()
-});
-var createClarityInviteLinkResponseSchema = z130.object({
-  invite_link: z130.object({
-    id: z130.guid(),
-    url: z130.url(),
-    created_at: z130.string(),
-    created_by: z130.object({
-      id: z130.guid(),
-      email: z130.email().nullable()
+  created_at: z131.string(),
+  created_by_name: z131.string().nullable()
+});
+var listClarityProcessesResponseSchema = z131.object({
+  processes: z131.array(clarityListProcessSchema),
+  total: z131.number().int(),
+  limit: z131.number().int(),
+  offset: z131.number().int()
+});
+var createClarityInviteLinkResponseSchema = z131.object({
+  invite_link: z131.object({
+    id: z131.guid(),
+    url: z131.url(),
+    created_at: z131.string(),
+    created_by: z131.object({
+      id: z131.guid(),
+      email: z131.email().nullable()
     })
   })
 });
-var createClarityProcessResponseSchema3 = z130.object({
-  id: z130.guid(),
-  name: z130.string(),
+var createClarityProcessResponseSchema3 = z131.object({
+  id: z131.guid(),
+  name: z131.string(),
   status: clarityProcessStatusSchema,
-  version: z130.union([z130.literal(1), z130.literal(2)]),
-  createdAt: z130.string()
+  version: z131.union([z131.literal(1), z131.literal(2)]),
+  createdAt: z131.string()
 });
-var getClarityCaptureResponseSchema = z130.object({
+var getClarityCaptureResponseSchema = z131.object({
   capture: clarityCaptureSchema
 });
-var createArtifactImportUploadUrlResponseSchema = z130.object({
-  signed_url: z130.url(),
-  capture_id: z130.guid(),
-  expires_at: z130.iso.datetime()
+var createArtifactImportUploadUrlResponseSchema = z131.object({
+  signed_url: z131.url(),
+  capture_id: z131.guid(),
+  expires_at: z131.iso.datetime()
 });
-var completeArtifactImportResponseSchema = z130.object({
+var completeArtifactImportResponseSchema = z131.object({
   capture: clarityCaptureSchema.extend({
-    createdAt: z130.iso.datetime(),
-    updatedAt: z130.iso.datetime()
+    createdAt: z131.iso.datetime(),
+    updatedAt: z131.iso.datetime()
   })
 });
 var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
@@ -42986,8 +43275,8 @@ function renderCompletedImport(response) {
 __name(renderCompletedImport, "renderCompletedImport");
 
 // src/commands/clarity/assign-extra-capture-request.ts
-import { z as z131 } from "zod";
-var responseSchema4 = z131.object({
+import { z as z133 } from "zod";
+var responseSchema4 = z133.object({
   request: clarityProposalExtraCaptureRequestSchema
 });
 function renderRequest(request) {
@@ -43034,11 +43323,11 @@ function registerClarityAssignExtraCaptureRequest(clarity) {
 __name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
 // src/commands/clarity/build-automation.ts
-import { z as z133 } from "zod";
-var responseSchema5 = z133.object({
-  automation_run: z133.object({
-    id: z133.string(),
-    status: z133.string()
+import { z as z134 } from "zod";
+var responseSchema5 = z134.object({
+  automation_run: z134.object({
+    id: z134.string(),
+    status: z134.string()
   })
 });
 function registerClarityBuildAutomation(clarity) {
@@ -43078,7 +43367,7 @@ function registerClarityBuildAutomation(clarity) {
 __name(registerClarityBuildAutomation, "registerClarityBuildAutomation");
 
 // src/commands/clarity/capture-administration.ts
-import { z as z134 } from "zod";
+import { z as z135 } from "zod";
 
 // src/commands/clarity/parse-response.ts
 function parseClarityResponse(schema, raw) {
@@ -43234,17 +43523,17 @@ async function uploadFileToSignedUrl(signedUrl, upload) {
 __name(uploadFileToSignedUrl, "uploadFileToSignedUrl");
 
 // src/commands/clarity/capture-administration.ts
-var createUploadResponseSchema = z134.object({
-  signedUrl: z134.url(),
-  captureId: z134.guid(),
-  expiresAt: z134.iso.datetime(),
-  gcsPath: z134.string()
-});
-var completeCaptureResponseSchema = z134.looseObject({
-  id: z134.guid(),
-  processId: z134.guid(),
-  type: z134.enum(["document", "video", "image"]),
-  status: z134.string()
+var createUploadResponseSchema = z135.object({
+  signedUrl: z135.url(),
+  captureId: z135.guid(),
+  expiresAt: z135.iso.datetime(),
+  gcsPath: z135.string()
+});
+var completeCaptureResponseSchema = z135.looseObject({
+  id: z135.guid(),
+  processId: z135.guid(),
+  type: z135.enum(["document", "video", "image"]),
+  status: z135.string()
 });
 function registerClarityCaptureAdministration(clarity) {
   const captures = clarity.command("capture-admin").description("Create and manage Clarity captures");
@@ -43445,7 +43734,7 @@ function registerClarityCreateProcess(clarity) {
 __name(registerClarityCreateProcess, "registerClarityCreateProcess");
 
 // src/commands/clarity/doctor.ts
-import { z as z135 } from "zod";
+import { z as z136 } from "zod";
 
 // src/commands/clarity/render.ts
 var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
@@ -46366,8 +46655,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z135.object({
-  teams: z135.array(z135.object({ id: z135.string() }))
+var listMyTeamsResponseSchema2 = z136.object({
+  teams: z136.array(z136.object({ id: z136.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -47220,19 +47509,19 @@ function buildGenerateTransformationProposalBody(options) {
 __name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
 // src/commands/clarity/get-current-process.ts
-import { z as z136 } from "zod";
-var snapshotSchema = z136.object({
-  snapshot: z136.object({
-    id: z136.string(),
-    kind: z136.string(),
-    source_snapshot_id: z136.string().nullable(),
-    parent_id: z136.string().nullable(),
-    status: z136.string(),
-    creator_type: z136.string(),
-    user_id: z136.string().nullable(),
-    sandbox_id: z136.string().nullable(),
-    created_at: z136.string(),
-    updated_at: z136.string()
+import { z as z137 } from "zod";
+var snapshotSchema = z137.object({
+  snapshot: z137.object({
+    id: z137.string(),
+    kind: z137.string(),
+    source_snapshot_id: z137.string().nullable(),
+    parent_id: z137.string().nullable(),
+    status: z137.string(),
+    creator_type: z137.string(),
+    user_id: z137.string().nullable(),
+    sandbox_id: z137.string().nullable(),
+    created_at: z137.string(),
+    updated_at: z137.string()
   })
 });
 function registerClarityGetCurrentProcess(clarity) {
@@ -47276,19 +47565,19 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z137 } from "zod";
-var snapshotSchema2 = z137.object({
-  snapshot: z137.object({
-    id: z137.string(),
-    kind: z137.string(),
-    source_snapshot_id: z137.string().nullable(),
-    parent_id: z137.string().nullable(),
-    status: z137.string(),
-    creator_type: z137.string(),
-    user_id: z137.string().nullable(),
-    sandbox_id: z137.string().nullable(),
-    created_at: z137.string(),
-    updated_at: z137.string()
+import { z as z138 } from "zod";
+var snapshotSchema2 = z138.object({
+  snapshot: z138.object({
+    id: z138.string(),
+    kind: z138.string(),
+    source_snapshot_id: z138.string().nullable(),
+    parent_id: z138.string().nullable(),
+    status: z138.string(),
+    creator_type: z138.string(),
+    user_id: z138.string().nullable(),
+    sandbox_id: z138.string().nullable(),
+    created_at: z138.string(),
+    updated_at: z138.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
@@ -47762,37 +48051,37 @@ __name(renderInterview, "renderInterview");
 
 // src/commands/clarity/invites-exports-portfolio.ts
 import { readFile as readFile8, stat as stat3 } from "node:fs/promises";
-import { z as z138 } from "zod";
+import { z as z139 } from "zod";
 var MAX_BPMN_BYTES = 5e6;
-var startExportResponseSchema = z138.object({
-  id: z138.guid(),
-  status: z138.literal("queued")
-});
-var activeExportSchema = z138.object({
-  exportRunId: z138.guid(),
-  processId: z138.guid(),
-  processName: z138.string(),
+var startExportResponseSchema = z139.object({
+  id: z139.guid(),
+  status: z139.literal("queued")
+});
+var activeExportSchema = z139.object({
+  exportRunId: z139.guid(),
+  processId: z139.guid(),
+  processName: z139.string(),
   status: clarityExportStatusSchema
 });
-var activeExportsResponseSchema = z138.array(activeExportSchema);
-var exportResponseSchema = z138.object({
-  id: z138.guid(),
-  target: z138.string(),
+var activeExportsResponseSchema = z139.array(activeExportSchema);
+var exportResponseSchema = z139.object({
+  id: z139.guid(),
+  target: z139.string(),
   status: clarityExportStatusSchema,
-  processId: z138.guid(),
-  teamId: z138.guid(),
-  userId: z138.guid(),
-  connectionInstanceId: z138.guid(),
-  sandboxId: z138.string().nullable(),
+  processId: z139.guid(),
+  teamId: z139.guid(),
+  userId: z139.guid(),
+  connectionInstanceId: z139.guid(),
+  sandboxId: z139.string().nullable(),
   result: clarityExportResultSchema.nullable(),
-  error: z138.string().nullable(),
-  createdAt: z138.string(),
-  updatedAt: z138.string()
+  error: z139.string().nullable(),
+  createdAt: z139.string(),
+  updatedAt: z139.string()
 });
-var portfolioGenerationResponseSchema = z138.object({
-  status: z138.literal("generating")
+var portfolioGenerationResponseSchema = z139.object({
+  status: z139.literal("generating")
 });
-var upgradeResponseSchema = z138.object({ id: z138.guid() });
+var upgradeResponseSchema = z139.object({ id: z139.guid() });
 var EXPORT_COLUMNS = [
   {
     header: "EXPORT",
@@ -48132,7 +48421,7 @@ function renderMutationResult(response, message, options) {
 __name(renderMutationResult, "renderMutationResult");
 
 // src/commands/clarity/landscape.ts
-import { z as z145 } from "zod";
+import { z as z146 } from "zod";
 
 // src/commands/clarity/landscape-paths.ts
 var NODES_RESOURCE_PATH = "/clarity/hierarchy/nodes";
@@ -48154,26 +48443,26 @@ function nodePersonPath(orgId, nodeId, personId) {
 __name(nodePersonPath, "nodePersonPath");
 
 // src/commands/clarity/landscape-people.ts
-import { z as z139 } from "zod";
+import { z as z140 } from "zod";
 var BATCH_PEOPLE_RESOURCE_PATH = "/clarity/hierarchy/people/batch";
-var personSchema = z139.object({
-  id: z139.string(),
-  userId: z139.string().nullable(),
-  name: z139.string().nullable(),
-  email: z139.string().nullable(),
-  role: z139.string().nullable(),
-  status: z139.string().nullable()
+var personSchema = z140.object({
+  id: z140.string(),
+  userId: z140.string().nullable(),
+  name: z140.string().nullable(),
+  email: z140.string().nullable(),
+  role: z140.string().nullable(),
+  status: z140.string().nullable()
 }).passthrough();
-var peopleResponseSchema = z139.object({ people: z139.array(personSchema) }).passthrough();
-var batchPeopleResponseSchema = z139.object({
-  outcomes: z139.array(z139.object({ outcome: z139.string() }).passthrough()),
-  counts: z139.object({
-    requested: z139.number().int().nonnegative(),
-    assigned: z139.number().int().nonnegative(),
-    alreadyPresent: z139.number().int().nonnegative(),
-    failed: z139.number().int().nonnegative(),
-    invitationsSent: z139.number().int().nonnegative(),
-    invitationFailures: z139.number().int().nonnegative()
+var peopleResponseSchema = z140.object({ people: z140.array(personSchema) }).passthrough();
+var batchPeopleResponseSchema = z140.object({
+  outcomes: z140.array(z140.object({ outcome: z140.string() }).passthrough()),
+  counts: z140.object({
+    requested: z140.number().int().nonnegative(),
+    assigned: z140.number().int().nonnegative(),
+    alreadyPresent: z140.number().int().nonnegative(),
+    failed: z140.number().int().nonnegative(),
+    invitationsSent: z140.number().int().nonnegative(),
+    invitationFailures: z140.number().int().nonnegative()
   }).passthrough()
 }).passthrough();
 var PERSON_COLUMNS = [
@@ -48293,7 +48582,7 @@ function parseBatchPeopleInput(input) {
   );
   if (!parsed.success) {
     throw new CliError(
-      `Invalid batch-people input: ${z139.prettifyError(parsed.error)}`
+      `Invalid batch-people input: ${z140.prettifyError(parsed.error)}`
     );
   }
   return parsed.data;
@@ -48332,17 +48621,17 @@ function buildUpdatePersonBody(options) {
 __name(buildUpdatePersonBody, "buildUpdatePersonBody");
 
 // src/commands/clarity/landscape-priorities.ts
-import { z as z140 } from "zod";
+import { z as z141 } from "zod";
 var LANDSCAPE_PRIORITIES = ["high", "medium", "low"];
 var PRIORITIES_RESOURCE_PATH = "/clarity/hierarchy/priorities";
 var MAX_BATCH_SIZE = 200;
-var setPrioritiesResponseSchema = z140.object({
-  nodes: z140.array(z140.object({ id: z140.string() }).passthrough())
+var setPrioritiesResponseSchema = z141.object({
+  nodes: z141.array(z141.object({ id: z141.string() }).passthrough())
 }).passthrough();
-var inputEntrySchema = z140.object({
-  nodeId: z140.string().min(1),
-  priority: z140.enum(LANDSCAPE_PRIORITIES).nullable(),
-  reasoning: z140.string().nullable().optional()
+var inputEntrySchema = z141.object({
+  nodeId: z141.string().min(1),
+  priority: z141.enum(LANDSCAPE_PRIORITIES).nullable(),
+  reasoning: z141.string().nullable().optional()
 }).passthrough();
 function registerClarityLandscapeSetPriorities(landscape, orgFlagDescription) {
   landscape.command("set-priorities").description(
@@ -48439,7 +48728,7 @@ function parseClearId(nodeId) {
 }
 __name(parseClearId, "parseClearId");
 function parseInputEntries(value) {
-  const parsed = z140.array(inputEntrySchema).safeParse(value);
+  const parsed = z141.array(inputEntrySchema).safeParse(value);
   if (!parsed.success) {
     throw new CliError(
       "Input must be a JSON array of {nodeId, priority, reasoning} entries with priority high, medium, low, or null."
@@ -48470,19 +48759,19 @@ function isLandscapePriority(value) {
 __name(isLandscapePriority, "isLandscapePriority");
 
 // src/commands/clarity/landscape-proposals.ts
-import { z as z141 } from "zod";
-var acceptedNodeSchema = z141.object({
-  id: z141.string(),
-  parentId: z141.string().nullable(),
-  processId: z141.string().nullable(),
-  name: z141.string()
+import { z as z143 } from "zod";
+var acceptedNodeSchema = z143.object({
+  id: z143.string(),
+  parentId: z143.string().nullable(),
+  processId: z143.string().nullable(),
+  name: z143.string()
 }).passthrough();
-var declineResponseSchema = z141.object({
-  deletedCount: z141.number(),
-  detachedCount: z141.number()
+var declineResponseSchema = z143.object({
+  deletedCount: z143.number(),
+  detachedCount: z143.number()
 }).passthrough();
 var assignTeamResponseSchema = acceptedNodeSchema.extend({
-  assignedTeam: z141.object({ id: z141.string(), name: z141.string() }).passthrough().nullable()
+  assignedTeam: z143.object({ id: z143.string(), name: z143.string() }).passthrough().nullable()
 });
 function registerClarityLandscapeProposals(landscape, orgFlagDescription) {
   landscape.command("accept-node <node-id>").description(
@@ -48572,16 +48861,16 @@ function assertAssignIntent(value) {
 __name(assertAssignIntent, "assertAssignIntent");
 
 // src/commands/clarity/landscape-structure.ts
-import { z as z143 } from "zod";
+import { z as z144 } from "zod";
 var AREA_ORDER_RESOURCE_PATH = "/clarity/hierarchy/areas/order";
 var PROCESS_NODES_RESOURCE_PATH = "/clarity/hierarchy/process-nodes";
-var nodeSchema = z143.object({
-  id: z143.string(),
-  parentId: z143.string().nullable(),
-  processId: z143.string().nullable(),
-  name: z143.string()
+var nodeSchema = z144.object({
+  id: z144.string(),
+  parentId: z144.string().nullable(),
+  processId: z144.string().nullable(),
+  name: z144.string()
 }).passthrough();
-var reorderAreasResponseSchema = z143.object({ nodes: z143.array(nodeSchema) }).passthrough();
+var reorderAreasResponseSchema = z144.object({ nodes: z144.array(nodeSchema) }).passthrough();
 function registerClarityLandscapeStructure(landscape, orgFlagDescription) {
   landscape.command("reorder-areas").description(
     "Reorder a sibling group of area folders left-to-right. Pass every sibling exactly once \u2014 a partial list is rejected"
@@ -48653,7 +48942,7 @@ function collectRepeatable4(value, previous) {
 }
 __name(collectRepeatable4, "collectRepeatable");
 function parseInputAreaIds(value) {
-  const parsed = z143.array(z143.string().min(1)).safeParse(value);
+  const parsed = z144.array(z144.string().min(1)).safeParse(value);
   if (!parsed.success) {
     throw new CliError("Input must be a JSON array of area node ids.");
   }
@@ -48674,23 +48963,23 @@ function assertUniqueAreaIds(areaIds) {
 __name(assertUniqueAreaIds, "assertUniqueAreaIds");
 
 // src/commands/clarity/landscape-suggestions.ts
-import { z as z144 } from "zod";
+import { z as z145 } from "zod";
 var ORGANIZE_RESOURCE_PATH = "/clarity/hierarchy/organize";
 var FLAT_HIERARCHY_NODES_PATH = "/v2/clarity/hierarchy/nodes";
-var organizeResponseSchema = z144.object({
-  started: z144.boolean(),
-  bagSize: z144.number().int().nonnegative()
+var organizeResponseSchema = z145.object({
+  started: z145.boolean(),
+  bagSize: z145.number().int().nonnegative()
 });
-var identifiedResourceSchema = z144.object({ id: z144.string() }).passthrough();
-var teamSuggestionAcceptResponseSchema = z144.object({
-  node: identifiedResourceSchema.extend({ name: z144.string() }),
+var identifiedResourceSchema = z145.object({ id: z145.string() }).passthrough();
+var teamSuggestionAcceptResponseSchema = z145.object({
+  node: identifiedResourceSchema.extend({ name: z145.string() }),
   suggestion: identifiedResourceSchema
 }).passthrough();
-var captureSuggestionAcceptResponseSchema = z144.object({
+var captureSuggestionAcceptResponseSchema = z145.object({
   suggestion: identifiedResourceSchema,
   request: identifiedResourceSchema
 }).passthrough();
-var captureRequestAssignmentResponseSchema = z144.object({ request: identifiedResourceSchema }).passthrough();
+var captureRequestAssignmentResponseSchema = z145.object({ request: identifiedResourceSchema }).passthrough();
 var SUGGESTION_MUTATIONS = [
   {
     command: "accept-team",
@@ -48809,131 +49098,131 @@ var CAPTURES_RESOURCE_PATH = "/clarity/hierarchy/captures";
 var PROPOSED_PROCESSES_RESOURCE_PATH = "/clarity/hierarchy/proposed-processes";
 var PROCESS_NODE_TYPE = "process";
 var AREA_NODE_TYPE = "area";
-var processSummarySchema = z145.object({
-  id: z145.string(),
-  name: z145.string()
+var processSummarySchema = z146.object({
+  id: z146.string(),
+  name: z146.string()
 }).passthrough();
 var prioritySchemaShape = {
-  priority: z145.enum(LANDSCAPE_PRIORITIES).nullable().optional(),
-  priorityReasoning: z145.string().nullable().optional(),
-  priorityAssessedAt: z145.string().nullable().optional()
+  priority: z146.enum(LANDSCAPE_PRIORITIES).nullable().optional(),
+  priorityReasoning: z146.string().nullable().optional(),
+  priorityAssessedAt: z146.string().nullable().optional()
 };
-var landscapeFullNodeSchema = z145.object({
-  access: z145.literal("full").default("full"),
-  id: z145.string(),
-  parentId: z145.string().nullable(),
-  processId: z145.string().nullable(),
-  name: z145.string(),
-  ownerLabel: z145.string().nullable(),
+var landscapeFullNodeSchema = z146.object({
+  access: z146.literal("full").default("full"),
+  id: z146.string(),
+  parentId: z146.string().nullable(),
+  processId: z146.string().nullable(),
+  name: z146.string(),
+  ownerLabel: z146.string().nullable(),
   process: processSummarySchema.nullable(),
   ...prioritySchemaShape
 }).passthrough();
-var landscapeRedactedNodeSchema = z145.object({
-  access: z145.literal("redacted"),
-  hint: z145.literal("restricted_process"),
-  id: z145.string(),
-  parentId: z145.string().nullable(),
-  sortOrder: z145.number(),
-  depth: z145.number()
+var landscapeRedactedNodeSchema = z146.object({
+  access: z146.literal("redacted"),
+  hint: z146.literal("restricted_process"),
+  id: z146.string(),
+  parentId: z146.string().nullable(),
+  sortOrder: z146.number(),
+  depth: z146.number()
 }).strict();
-var landscapeNodeSchema = z145.union([
+var landscapeNodeSchema = z146.union([
   landscapeFullNodeSchema,
   landscapeRedactedNodeSchema
 ]);
 var unlinkedProcessSchema = processSummarySchema.extend({
-  teamId: z145.string(),
-  teamName: z145.string().nullable()
+  teamId: z146.string(),
+  teamName: z146.string().nullable()
 }).passthrough();
-var treeNodeSchema = z145.object({
-  id: z145.string(),
-  parentId: z145.string().nullable(),
-  processId: z145.string().nullable(),
-  name: z145.string(),
-  ownerLabel: z145.string().nullable(),
-  depth: z145.number(),
+var treeNodeSchema = z146.object({
+  id: z146.string(),
+  parentId: z146.string().nullable(),
+  processId: z146.string().nullable(),
+  name: z146.string(),
+  ownerLabel: z146.string().nullable(),
+  depth: z146.number(),
   ...prioritySchemaShape
 }).passthrough();
-var landscapeResponseSchema = z145.object({
-  nodes: z145.array(landscapeNodeSchema),
-  links: z145.array(
-    z145.object({
-      id: z145.string(),
-      sourceNodeId: z145.string(),
-      targetNodeId: z145.string(),
-      type: z145.string(),
-      state: z145.string(),
-      confidence: z145.number().nullable()
+var landscapeResponseSchema = z146.object({
+  nodes: z146.array(landscapeNodeSchema),
+  links: z146.array(
+    z146.object({
+      id: z146.string(),
+      sourceNodeId: z146.string(),
+      targetNodeId: z146.string(),
+      type: z146.string(),
+      state: z146.string(),
+      confidence: z146.number().nullable()
     }).passthrough()
   ),
-  unlinkedProcesses: z145.array(unlinkedProcessSchema),
-  stats: z145.object({
-    totalNodes: z145.number(),
-    processNodes: z145.number(),
-    proposedNodes: z145.number(),
-    unsortedProcesses: z145.number(),
-    latestUpdatedAt: z145.string().nullable()
+  unlinkedProcesses: z146.array(unlinkedProcessSchema),
+  stats: z146.object({
+    totalNodes: z146.number(),
+    processNodes: z146.number(),
+    proposedNodes: z146.number(),
+    unsortedProcesses: z146.number(),
+    latestUpdatedAt: z146.string().nullable()
   }).passthrough(),
-  truncated: z145.boolean()
+  truncated: z146.boolean()
 }).passthrough();
-var treeResponseSchema = z145.object({
-  nodes: z145.array(treeNodeSchema),
-  truncated: z145.boolean()
+var treeResponseSchema = z146.object({
+  nodes: z146.array(treeNodeSchema),
+  truncated: z146.boolean()
 }).passthrough();
-var hierarchyPersonSchema = z145.object({
-  nodeId: z145.string(),
-  processId: z145.string(),
-  id: z145.string(),
-  userId: z145.string().nullable(),
-  name: z145.string().nullable(),
-  email: z145.string().nullable(),
-  role: z145.string().nullable(),
-  status: z145.string().nullable(),
-  captureCount: z145.number()
+var hierarchyPersonSchema = z146.object({
+  nodeId: z146.string(),
+  processId: z146.string(),
+  id: z146.string(),
+  userId: z146.string().nullable(),
+  name: z146.string().nullable(),
+  email: z146.string().nullable(),
+  role: z146.string().nullable(),
+  status: z146.string().nullable(),
+  captureCount: z146.number()
 }).passthrough();
-var hierarchyPeopleResponseSchema = z145.object({
-  people: z145.array(hierarchyPersonSchema),
-  truncated: z145.boolean()
+var hierarchyPeopleResponseSchema = z146.object({
+  people: z146.array(hierarchyPersonSchema),
+  truncated: z146.boolean()
 }).passthrough();
-var nodeResponseSchema = z145.object({
-  id: z145.string(),
-  parentId: z145.string().nullable(),
-  processId: z145.string().nullable(),
-  name: z145.string(),
-  ownerLabel: z145.string().nullable(),
-  outcome: z145.enum(["created", "reused"]).optional(),
+var nodeResponseSchema = z146.object({
+  id: z146.string(),
+  parentId: z146.string().nullable(),
+  processId: z146.string().nullable(),
+  name: z146.string(),
+  ownerLabel: z146.string().nullable(),
+  outcome: z146.enum(["created", "reused"]).optional(),
   ...prioritySchemaShape
 }).passthrough();
-var deleteNodeResponseSchema = z145.object({
-  deletedCount: z145.number(),
-  detachedCount: z145.number()
-});
-var generateLandscapeResponseSchema = z145.object({
-  started: z145.literal(true),
-  generationId: z145.string(),
-  eligibleCaptureCount: z145.number(),
-  eligibleProcessCount: z145.number().int().nonnegative()
+var deleteNodeResponseSchema = z146.object({
+  deletedCount: z146.number(),
+  detachedCount: z146.number()
+});
+var generateLandscapeResponseSchema = z146.object({
+  started: z146.literal(true),
+  generationId: z146.string(),
+  eligibleCaptureCount: z146.number(),
+  eligibleProcessCount: z146.number().int().nonnegative()
 }).passthrough();
-var captureSchema = z145.object({
-  id: z145.string(),
-  scope: z145.string(),
-  type: z145.string(),
-  title: z145.string(),
-  organizationId: z145.string().nullable(),
-  organizationName: z145.string().nullable(),
-  teamId: z145.string().nullable(),
-  teamName: z145.string().nullable(),
-  processNodeId: z145.string().nullable(),
-  createdAt: z145.string(),
-  transcriptMessageCount: z145.number(),
-  usability_status: z145.enum(["usable", "excluded"]).default("usable"),
-  usability_reason: z145.string().nullable().default(null),
-  usability_source: z145.enum(["agent", "interviewee", "manager"]).nullable().default(null),
-  usability_confidence: z145.enum(["high", "medium", "low"]).nullable().default(null)
+var captureSchema = z146.object({
+  id: z146.string(),
+  scope: z146.string(),
+  type: z146.string(),
+  title: z146.string(),
+  organizationId: z146.string().nullable(),
+  organizationName: z146.string().nullable(),
+  teamId: z146.string().nullable(),
+  teamName: z146.string().nullable(),
+  processNodeId: z146.string().nullable(),
+  createdAt: z146.string(),
+  transcriptMessageCount: z146.number(),
+  usability_status: z146.enum(["usable", "excluded"]).default("usable"),
+  usability_reason: z146.string().nullable().default(null),
+  usability_source: z146.enum(["agent", "interviewee", "manager"]).nullable().default(null),
+  usability_confidence: z146.enum(["high", "medium", "low"]).nullable().default(null)
 }).passthrough();
-var captureListResponseSchema = z145.object({
-  captures: z145.array(captureSchema),
-  total: z145.number(),
-  truncated: z145.boolean()
+var captureListResponseSchema = z146.object({
+  captures: z146.array(captureSchema),
+  total: z146.number(),
+  truncated: z146.boolean()
 }).passthrough();
 var LANDSCAPE_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -49605,22 +49894,22 @@ function registerClarityProcessSummaries(clarity) {
 __name(registerClarityProcessSummaries, "registerClarityProcessSummaries");
 
 // src/commands/clarity/list-snapshots.ts
-import { z as z146 } from "zod";
+import { z as z147 } from "zod";
 var SNAPSHOT_KINDS = ["current_process", "transformation_proposal"];
 var DEFAULT_LIMIT9 = 50;
 var MIN_LIMIT9 = 1;
 var MAX_LIMIT9 = 100;
-var snapshotListItemSchema = z146.looseObject({
-  id: z146.string(),
-  status: z146.string(),
-  creator_type: z146.string(),
-  created_at: z146.string(),
-  parent_id: z146.string().nullable().optional(),
-  source_snapshot_id: z146.string().nullable().optional()
-});
-var listSnapshotsResponseSchema = z146.looseObject({
-  snapshots: z146.array(snapshotListItemSchema),
-  total: z146.number().int().optional()
+var snapshotListItemSchema = z147.looseObject({
+  id: z147.string(),
+  status: z147.string(),
+  creator_type: z147.string(),
+  created_at: z147.string(),
+  parent_id: z147.string().nullable().optional(),
+  source_snapshot_id: z147.string().nullable().optional()
+});
+var listSnapshotsResponseSchema = z147.looseObject({
+  snapshots: z147.array(snapshotListItemSchema),
+  total: z147.number().int().optional()
 });
 var TABLE_COLUMNS25 = [
   {
@@ -49733,46 +50022,46 @@ __name(registerClarityPostprocess, "registerClarityPostprocess");
 
 // src/commands/clarity/process-administration.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { z as z147 } from "zod";
+import { z as z148 } from "zod";
 var MAX_GUIDANCE_LENGTH = 5e3;
 var MAX_GUIDANCE_BYTES = MAX_GUIDANCE_LENGTH * 4;
-var guidanceResponseSchema = z147.object({
-  id: z147.guid(),
-  processId: z147.guid(),
-  content: z147.string(),
-  author: z147.string().nullable(),
-  createdAt: z147.string().optional(),
-  updatedAt: z147.string().optional()
-});
-var sharingResponseSchema = z147.object({
-  shareEnabled: z147.boolean(),
-  shareToken: z147.string().nullable(),
-  shareUrl: z147.string().nullable(),
-  proposalShareEnabled: z147.boolean()
-});
-var processAccessUserSchema = z147.object({
-  id: z147.guid(),
-  name: z147.string().nullable(),
-  email: z147.email().nullable()
-});
-var processMemberSchema = z147.object({
-  id: z147.guid(),
+var guidanceResponseSchema = z148.object({
+  id: z148.guid(),
+  processId: z148.guid(),
+  content: z148.string(),
+  author: z148.string().nullable(),
+  createdAt: z148.string().optional(),
+  updatedAt: z148.string().optional()
+});
+var sharingResponseSchema = z148.object({
+  shareEnabled: z148.boolean(),
+  shareToken: z148.string().nullable(),
+  shareUrl: z148.string().nullable(),
+  proposalShareEnabled: z148.boolean()
+});
+var processAccessUserSchema = z148.object({
+  id: z148.guid(),
+  name: z148.string().nullable(),
+  email: z148.email().nullable()
+});
+var processMemberSchema = z148.object({
+  id: z148.guid(),
   user: processAccessUserSchema,
-  role: z147.string().nullable(),
-  createdAt: z147.string()
+  role: z148.string().nullable(),
+  createdAt: z148.string()
 });
-var processPendingInviteSchema = z147.object({
-  id: z147.guid(),
-  email: z147.string(),
-  createdAt: z147.string()
+var processPendingInviteSchema = z148.object({
+  id: z148.guid(),
+  email: z148.string(),
+  createdAt: z148.string()
 });
-var processMembersResponseSchema = z147.object({
-  visibility: z147.enum(["team", "restricted"]),
+var processMembersResponseSchema = z148.object({
+  visibility: z148.enum(["team", "restricted"]),
   owner: processAccessUserSchema,
-  members: z147.array(processMemberSchema),
+  members: z148.array(processMemberSchema),
   // Defaulted so a backend that predates the field still parses, and so the
   // renderer never has to branch on undefined.
-  pending: z147.array(processPendingInviteSchema).default([])
+  pending: z148.array(processPendingInviteSchema).default([])
 });
 var MEMBER_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((member) => member.id, "cell") },
@@ -50569,21 +50858,21 @@ function renderLabelSummary(label) {
 __name(renderLabelSummary, "renderLabelSummary");
 
 // src/commands/clarity/process-lifecycle.ts
-import { z as z148 } from "zod";
-var visibilitySchema = z148.enum(["team", "restricted"]);
-var updatedProcessSchema = z148.object({
-  id: z148.guid(),
-  name: z148.string(),
-  status: z148.string(),
+import { z as z149 } from "zod";
+var visibilitySchema = z149.enum(["team", "restricted"]);
+var updatedProcessSchema = z149.object({
+  id: z149.guid(),
+  name: z149.string(),
+  status: z149.string(),
   visibility: visibilitySchema,
-  customPrompt: z148.string().nullable(),
-  updatedAt: z148.string()
+  customPrompt: z149.string().nullable(),
+  updatedAt: z149.string()
 });
-var duplicatedProcessSchema = z148.object({
-  id: z148.guid()
+var duplicatedProcessSchema = z149.object({
+  id: z149.guid()
 });
-var deletedProcessSchema = z148.object({
-  success: z148.literal(true)
+var deletedProcessSchema = z149.object({
+  success: z149.literal(true)
 });
 function registerClarityProcessLifecycle(clarity) {
   clarity.command("update <process-id>").description("Update a Clarity process").option("--name <name>", "set the process name").option("--guidance <text>", "set process-specific guidance").option("--clear-guidance", "remove process-specific guidance").option("--visibility <visibility>", "set visibility: team or restricted").option("--complete", "mark a review-stage process complete").option("--json", "output raw JSON from the API").action(updateProcess);
@@ -50691,41 +50980,41 @@ function parseResponse2(schema, raw) {
 __name(parseResponse2, "parseResponse");
 
 // src/commands/clarity/process-links.ts
-import { z as z149 } from "zod";
+import { z as z150 } from "zod";
 var MIN_LIMIT11 = 1;
 var MAX_LIMIT11 = 500;
 var DEFAULT_LIMIT11 = 100;
 var ORG_FLAG_DESCRIPTION4 = "organization id for the org-scoped process landscape (overrides DUVO_ORG_ID)";
 var PROCESS_LINKS_RESOURCE_PATH = "/clarity/hierarchy/process-links";
-var processLinkTypeSchema = z149.enum([
+var processLinkTypeSchema = z150.enum([
   "hands_off_to",
   "shares_step_with",
   "variant_of"
 ]);
-var processLinkStateSchema = z149.enum(["suggested", "confirmed"]);
-var processLinkSchema = z149.object({
-  id: z149.string(),
-  source_node_id: z149.string(),
-  target_node_id: z149.string(),
+var processLinkStateSchema = z150.enum(["suggested", "confirmed"]);
+var processLinkSchema = z150.object({
+  id: z150.string(),
+  source_node_id: z150.string(),
+  target_node_id: z150.string(),
   type: processLinkTypeSchema,
   state: processLinkStateSchema,
-  confidence: z149.number().nullable(),
-  rationale: z149.string().nullable().default(null),
-  created_at: z149.string(),
-  updated_at: z149.string()
-});
-var listProcessLinksResponseSchema = z149.object({
-  process_links: z149.array(processLinkSchema),
-  total: z149.number(),
-  limit: z149.number(),
-  offset: z149.number()
-});
-var processLinkMutationResponseSchema = z149.object({
+  confidence: z150.number().nullable(),
+  rationale: z150.string().nullable().default(null),
+  created_at: z150.string(),
+  updated_at: z150.string()
+});
+var listProcessLinksResponseSchema = z150.object({
+  process_links: z150.array(processLinkSchema),
+  total: z150.number(),
+  limit: z150.number(),
+  offset: z150.number()
+});
+var processLinkMutationResponseSchema = z150.object({
   process_link: processLinkSchema,
-  created: z149.boolean().optional()
+  created: z150.boolean().optional()
 });
-var deleteProcessLinkResponseSchema = z149.object({
-  deleted: z149.boolean()
+var deleteProcessLinkResponseSchema = z150.object({
+  deleted: z150.boolean()
 });
 var PROCESS_LINK_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -50926,14 +51215,14 @@ function renderProcessLinks(response) {
 __name(renderProcessLinks, "renderProcessLinks");
 
 // src/commands/clarity/promote-current-process.ts
-import { z as z150 } from "zod";
-var snapshotSchema3 = z150.object({
-  snapshot: z150.object({
-    id: z150.string(),
-    status: z150.string(),
-    creator_type: z150.string(),
-    created_at: z150.string(),
-    updated_at: z150.string()
+import { z as z151 } from "zod";
+var snapshotSchema3 = z151.object({
+  snapshot: z151.object({
+    id: z151.string(),
+    status: z151.string(),
+    creator_type: z151.string(),
+    created_at: z151.string(),
+    updated_at: z151.string()
   })
 });
 function registerClarityPromoteCurrentProcess(clarity) {
@@ -50970,14 +51259,14 @@ function registerClarityPromoteCurrentProcess(clarity) {
 __name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
 
 // src/commands/clarity/promote-transformation-proposal.ts
-import { z as z151 } from "zod";
-var snapshotSchema4 = z151.object({
-  snapshot: z151.object({
-    id: z151.string(),
-    status: z151.string(),
-    creator_type: z151.string(),
-    created_at: z151.string(),
-    updated_at: z151.string()
+import { z as z153 } from "zod";
+var snapshotSchema4 = z153.object({
+  snapshot: z153.object({
+    id: z153.string(),
+    status: z153.string(),
+    creator_type: z153.string(),
+    created_at: z153.string(),
+    updated_at: z153.string()
   })
 });
 function registerClarityPromoteTransformationProposal(clarity) {
@@ -51053,9 +51342,9 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile9 } from "node:fs/promises";
-import { z as z153 } from "zod";
-var snapshotFileStepsSchema = z153.array(postprocessClarityStepBaseSchema).min(1);
-var snapshotFileSchema = z153.union([
+import { z as z154 } from "zod";
+var snapshotFileStepsSchema = z154.array(postprocessClarityStepBaseSchema).min(1);
+var snapshotFileSchema = z154.union([
   snapshotFileStepsSchema,
   saveClarityProcessSnapshotBodySchema.pick({ summary: true, swot: true, projectedImpact: true }).extend({ steps: snapshotFileStepsSchema })
 ]);
@@ -52212,17 +52501,17 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z154 } from "zod";
-var toolSchema = z154.object({
-  name: z154.string(),
-  description: z154.string().optional(),
-  input_schema: z154.record(z154.string(), z154.unknown()).optional()
+import { z as z155 } from "zod";
+var toolSchema = z155.object({
+  name: z155.string(),
+  description: z155.string().optional(),
+  input_schema: z155.record(z155.string(), z155.unknown()).optional()
 });
-var probeResponseSchema = z154.object({
-  success: z154.boolean(),
-  tools: z154.array(toolSchema).optional(),
-  error: z154.string().optional(),
-  code: z154.enum(["listing_unavailable", "probe_failed"]).optional()
+var probeResponseSchema = z155.object({
+  success: z155.boolean(),
+  tools: z155.array(toolSchema).optional(),
+  error: z155.string().optional(),
+  code: z155.enum(["listing_unavailable", "probe_failed"]).optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
 var TABLE_COLUMNS28 = [
@@ -52432,48 +52721,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z155 } from "zod";
-var dateLike = z155.string();
-var secretSchema = z155.object({
-  id: z155.string(),
-  team_id: z155.string(),
-  user_id: z155.string().nullable(),
-  name: z155.string(),
-  service_slug: z155.string().nullable(),
-  env_var_keys: z155.array(z155.string()),
-  created_by: z155.string(),
+import { z as z156 } from "zod";
+var dateLike = z156.string();
+var secretSchema = z156.object({
+  id: z156.string(),
+  team_id: z156.string(),
+  user_id: z156.string().nullable(),
+  name: z156.string(),
+  service_slug: z156.string().nullable(),
+  env_var_keys: z156.array(z156.string()),
+  created_by: z156.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z155.array(secretSchema);
+var secretsListResponseSchema = z156.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z155.object({
-  id: z155.string(),
-  user_id: z155.string().nullable(),
-  team_id: z155.string(),
-  domain: z155.string(),
-  username: z155.string().nullable(),
+var browserLoginSchema = z156.object({
+  id: z156.string(),
+  user_id: z156.string().nullable(),
+  team_id: z156.string(),
+  domain: z156.string(),
+  username: z156.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z155.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z155.object({
-  id: z155.string(),
-  user_id: z155.string().nullable(),
-  team_id: z155.string().nullable(),
-  domain: z155.string(),
-  username: z155.string().nullable(),
+var browserLoginsListResponseSchema = z156.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z156.object({
+  id: z156.string(),
+  user_id: z156.string().nullable(),
+  team_id: z156.string().nullable(),
+  domain: z156.string(),
+  username: z156.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z155.array(
+var revisionLoginsListResponseSchema = z156.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z155.array(secretSchema);
-var successResponseSchema2 = z155.object({
-  success: z155.boolean()
+var revisionSecretsListResponseSchema = z156.array(secretSchema);
+var successResponseSchema2 = z156.object({
+  success: z156.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -53662,13 +53951,13 @@ function registerInviteBulk(invite) {
 __name(registerInviteBulk, "registerInviteBulk");
 
 // src/api/invite-schemas.ts
-import { z as z156 } from "zod";
-var updateTeamInviteResponseSchema = z156.object({
-  id: z156.string(),
-  role: z156.string()
+import { z as z157 } from "zod";
+var updateTeamInviteResponseSchema = z157.object({
+  id: z157.string(),
+  role: z157.string()
 });
-var inviteSuccessResponseSchema = z156.object({
-  success: z156.literal(true)
+var inviteSuccessResponseSchema = z157.object({
+  success: z157.literal(true)
 });
 
 // src/commands/invite/send-invitation-email.ts
@@ -58578,7 +58867,11 @@ function registerQueuesGet(queues) {
         { label: "Name", value: queue.name },
         { label: "Description", value: queue.description ?? "" },
         { label: "Folder", value: queue.folder_id ?? "" },
-        { label: "Created", value: queue.created_at ?? "" }
+        { label: "Created", value: queue.created_at ?? "" },
+        {
+          label: "Created by",
+          value: queue.created_by ? `${queue.created_by.name ?? queue.created_by.email} (${queue.created_by.id})` : ""
+        }
       ])
     );
   }, "getAction"));
@@ -58951,7 +59244,14 @@ var TABLE_COLUMNS43 = [
     cell: /* @__PURE__ */ __name((row) => row.description ?? "", "cell"),
     maxWidth: 40
   },
-  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
+  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") },
+  {
+    header: "CREATED BY",
+    // Name when the profile has one, email otherwise. Blank for a queue with
+    // no recorded creator, such as one an automation install created.
+    cell: /* @__PURE__ */ __name((row) => row.created_by?.name ?? row.created_by?.email ?? "", "cell"),
+    maxWidth: 30
+  }
 ];
 function registerQueuesList(queues) {
   queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT19}-${MAX_LIMIT17})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -59763,91 +60063,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z157 } from "zod";
-var publicRunSchema = z157.object({
-  id: z157.string(),
-  agent_id: z157.string(),
-  build_id: z157.string(),
-  status: z157.string(),
-  source: z157.string().nullish(),
-  sandbox_id: z157.string().nullish(),
-  started_at: z157.string().nullish(),
-  completed_at: z157.string().nullish(),
-  created_at: z157.string(),
-  updated_at: z157.string().nullish(),
-  human_in_the_loop_enabled: z157.boolean().nullish()
-});
-var startRunResponseSchema = z157.object({
+import { z as z158 } from "zod";
+var publicRunSchema = z158.object({
+  id: z158.string(),
+  agent_id: z158.string(),
+  build_id: z158.string(),
+  status: z158.string(),
+  source: z158.string().nullish(),
+  sandbox_id: z158.string().nullish(),
+  started_at: z158.string().nullish(),
+  completed_at: z158.string().nullish(),
+  created_at: z158.string(),
+  updated_at: z158.string().nullish(),
+  human_in_the_loop_enabled: z158.boolean().nullish()
+});
+var startRunResponseSchema = z158.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z157.object({
-  label: z157.string(),
-  description: z157.string().nullish()
-});
-var questionSchema = z157.object({
-  question: z157.string(),
-  header: z157.string().nullish(),
-  options: z157.array(questionOptionSchema).nullish(),
-  multi_select: z157.boolean().nullish()
-});
-var pendingHumanRequestSchema = z157.object({
-  id: z157.string(),
-  title: z157.string(),
-  description: z157.string().nullish(),
-  created_at: z157.string(),
-  type: z157.string(),
-  questions: z157.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z157.object({
+var questionOptionSchema = z158.object({
+  label: z158.string(),
+  description: z158.string().nullish()
+});
+var questionSchema = z158.object({
+  question: z158.string(),
+  header: z158.string().nullish(),
+  options: z158.array(questionOptionSchema).nullish(),
+  multi_select: z158.boolean().nullish()
+});
+var pendingHumanRequestSchema = z158.object({
+  id: z158.string(),
+  title: z158.string(),
+  description: z158.string().nullish(),
+  created_at: z158.string(),
+  type: z158.string(),
+  questions: z158.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z158.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z157.object({
-  success: z157.boolean(),
-  message: z157.string().nullish()
-});
-var runMessageSchema = z157.object({
-  id: z157.string(),
-  type: z157.string(),
-  role: z157.string(),
-  timestamp: z157.string(),
-  text_content: z157.string().nullish(),
-  tool_call: z157.object({
-    id: z157.string(),
-    name: z157.string(),
-    arguments: z157.record(z157.string(), z157.unknown()).nullish()
+var stopRunResponseSchema = z158.object({
+  success: z158.boolean(),
+  message: z158.string().nullish()
+});
+var runMessageSchema = z158.object({
+  id: z158.string(),
+  type: z158.string(),
+  role: z158.string(),
+  timestamp: z158.string(),
+  text_content: z158.string().nullish(),
+  tool_call: z158.object({
+    id: z158.string(),
+    name: z158.string(),
+    arguments: z158.record(z158.string(), z158.unknown()).nullish()
   }).nullish(),
-  tool_result: z157.object({
-    tool_call_id: z157.string(),
-    result: z157.unknown().nullish(),
-    error: z157.string().nullish()
+  tool_result: z158.object({
+    tool_call_id: z158.string(),
+    result: z158.unknown().nullish(),
+    error: z158.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z157.object({
-  messages: z157.array(runMessageSchema),
-  total: z157.number().nullish(),
-  limit: z157.number().nullish(),
-  offset: z157.number().nullish()
+var listRunMessagesResponseSchema = z158.object({
+  messages: z158.array(runMessageSchema),
+  total: z158.number().nullish(),
+  limit: z158.number().nullish(),
+  offset: z158.number().nullish()
 });
-var postedMessageSchema = z157.object({
-  id: z157.string(),
-  type: z157.string(),
-  role: z157.string(),
-  timestamp: z157.string(),
-  text_content: z157.string()
+var postedMessageSchema = z158.object({
+  id: z158.string(),
+  type: z158.string(),
+  role: z158.string(),
+  timestamp: z158.string(),
+  text_content: z158.string()
 });
-var postRunMessageResponseSchema = z157.object({
+var postRunMessageResponseSchema = z158.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z157.object({
-  human_request: z157.object({
-    id: z157.string(),
-    run_id: z157.string(),
-    title: z157.string(),
-    description: z157.string().nullish(),
-    response: z157.string().nullish(),
-    responded_at: z157.string().nullish(),
-    created_at: z157.string()
+var respondHumanRequestResponseSchema = z158.object({
+  human_request: z158.object({
+    id: z158.string(),
+    run_id: z158.string(),
+    title: z158.string(),
+    description: z158.string().nullish(),
+    response: z158.string().nullish(),
+    responded_at: z158.string().nullish(),
+    created_at: z158.string()
   })
 });
 
@@ -60568,28 +60868,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z158 } from "zod";
-var createSandboxResponseSchema = z158.object({
-  sandbox_id: z158.string(),
-  expires_at: z158.string()
+import { z as z159 } from "zod";
+var createSandboxResponseSchema = z159.object({
+  sandbox_id: z159.string(),
+  expires_at: z159.string()
 });
-var createSandboxUploadUrlResponseSchema = z158.object({
-  upload_url: z158.string(),
-  path: z158.string(),
-  expires_in_seconds: z158.number()
+var createSandboxUploadUrlResponseSchema = z159.object({
+  upload_url: z159.string(),
+  path: z159.string(),
+  expires_in_seconds: z159.number()
 });
-var sandboxFileSchema = z158.object({
-  name: z158.string(),
-  path: z158.string(),
-  type: z158.enum(["file", "dir"]),
-  size_bytes: z158.number()
+var sandboxFileSchema = z159.object({
+  name: z159.string(),
+  path: z159.string(),
+  type: z159.enum(["file", "dir"]),
+  size_bytes: z159.number()
 });
-var listSandboxFilesResponseSchema = z158.object({
-  files: z158.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z159.object({
+  files: z159.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z158.object({
-  path: z158.string(),
-  size_bytes: z158.number()
+var uploadSandboxFileResponseSchema = z159.object({
+  path: z159.string(),
+  size_bytes: z159.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -61200,13 +61500,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync6 } from "node:fs";
-import { z as z159 } from "zod";
-var createSkillResponseSchema = z159.object({
-  skill: z159.object({
-    id: z159.string(),
-    name: z159.string(),
-    description: z159.string(),
-    team_id: z159.string()
+import { z as z160 } from "zod";
+var createSkillResponseSchema = z160.object({
+  skill: z160.object({
+    id: z160.string(),
+    name: z160.string(),
+    description: z160.string(),
+    team_id: z160.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -61581,13 +61881,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z160 } from "zod";
-var installSkillResponseSchema = z160.object({
-  skill: z160.object({
-    id: z160.string(),
-    name: z160.string(),
-    description: z160.string(),
-    team_id: z160.string()
+import { z as z161 } from "zod";
+var installSkillResponseSchema = z161.object({
+  skill: z161.object({
+    id: z161.string(),
+    name: z161.string(),
+    description: z161.string(),
+    team_id: z161.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -61736,48 +62036,48 @@ function registerSkillsList(skills) {
 __name(registerSkillsList, "registerSkillsList");
 
 // src/api/skill-revision-schemas.ts
-import { z as z161 } from "zod";
-var skillRevisionSchema = z161.object({
-  id: z161.string(),
-  skill_id: z161.string(),
-  revision_number: z161.number().nullable(),
-  status: z161.enum(["draft", "live", "historic"]),
-  revision_name: z161.string().nullable(),
-  revision_description: z161.string().nullable(),
-  created_by: z161.string().nullable(),
-  created_by_name: z161.string().nullable(),
-  created_at: z161.string(),
-  updated_at: z161.string()
-});
-var listSkillRevisionsResponseSchema = z161.object({
-  revisions: z161.array(skillRevisionSchema),
-  total: z161.number().nullish(),
-  limit: z161.number().nullish(),
-  offset: z161.number().nullish()
-});
-var createSkillRevisionResponseSchema = z161.object({
+import { z as z163 } from "zod";
+var skillRevisionSchema = z163.object({
+  id: z163.string(),
+  skill_id: z163.string(),
+  revision_number: z163.number().nullable(),
+  status: z163.enum(["draft", "live", "historic"]),
+  revision_name: z163.string().nullable(),
+  revision_description: z163.string().nullable(),
+  created_by: z163.string().nullable(),
+  created_by_name: z163.string().nullable(),
+  created_at: z163.string(),
+  updated_at: z163.string()
+});
+var listSkillRevisionsResponseSchema = z163.object({
+  revisions: z163.array(skillRevisionSchema),
+  total: z163.number().nullish(),
+  limit: z163.number().nullish(),
+  offset: z163.number().nullish()
+});
+var createSkillRevisionResponseSchema = z163.object({
   revision: skillRevisionSchema,
-  created: z161.boolean()
+  created: z163.boolean()
 });
-var skillRevisionResponseSchema = z161.object({
+var skillRevisionResponseSchema = z163.object({
   revision: skillRevisionSchema
 });
-var deleteSkillRevisionResponseSchema = z161.object({
-  success: z161.boolean(),
-  message: z161.string()
+var deleteSkillRevisionResponseSchema = z163.object({
+  success: z163.boolean(),
+  message: z163.string()
 });
-var skillRevisionFileSchema = z161.object({
-  name: z161.string(),
-  path: z161.string(),
-  size: z161.number().optional(),
-  contentType: z161.string().optional(),
-  updatedAt: z161.string().optional()
+var skillRevisionFileSchema = z163.object({
+  name: z163.string(),
+  path: z163.string(),
+  size: z163.number().optional(),
+  contentType: z163.string().optional(),
+  updatedAt: z163.string().optional()
 });
-var listSkillRevisionFilesResponseSchema = z161.object({
-  files: z161.array(skillRevisionFileSchema),
-  limit: z161.number().nullish(),
-  has_more: z161.boolean().nullish(),
-  next_cursor: z161.string().nullish()
+var listSkillRevisionFilesResponseSchema = z163.object({
+  files: z163.array(skillRevisionFileSchema),
+  limit: z163.number().nullish(),
+  has_more: z163.boolean().nullish(),
+  next_cursor: z163.string().nullish()
 });
 
 // src/commands/skills/revisions/create.ts
@@ -62253,13 +62553,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile14, stat as stat6 } from "node:fs/promises";
 import { basename as basename6 } from "node:path";
-import { z as z163 } from "zod";
-var uploadSkillResponseSchema = z163.object({
-  skill: z163.object({
-    id: z163.string(),
-    name: z163.string(),
-    description: z163.string(),
-    team_id: z163.string()
+import { z as z164 } from "zod";
+var uploadSkillResponseSchema = z164.object({
+  skill: z164.object({
+    id: z164.string(),
+    name: z164.string(),
+    description: z164.string(),
+    team_id: z164.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -62495,13 +62795,13 @@ function registerSuggestionsGet(suggestions) {
 __name(registerSuggestionsGet, "registerSuggestionsGet");
 
 // src/commands/suggestions/list.ts
-import { z as z164 } from "zod";
+import { z as z165 } from "zod";
 var DEFAULT_LIMIT22 = 100;
 var MIN_LIMIT24 = 1;
 var MAX_LIMIT22 = 250;
-var listEnvelopeSchema = z164.object({
-  data: z164.array(z164.unknown()),
-  pending_count: z164.number().int().nonnegative()
+var listEnvelopeSchema = z165.object({
+  data: z165.array(z165.unknown()),
+  pending_count: z165.number().int().nonnegative()
 });
 var STATUS_FILTERS = ["pending", "history"];
 var TITLE_PREVIEW_WIDTH2 = 50;
@@ -62919,9 +63219,9 @@ function registerTeamSetRole(team) {
 __name(registerTeamSetRole, "registerTeamSetRole");
 
 // src/commands/team/use.ts
-import { z as z165 } from "zod";
+import { z as z166 } 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 = z165.string().regex(TEAM_ID_SHAPE);
+var teamIdSchema = z166.string().regex(TEAM_ID_SHAPE);
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
     "Set the default team for the active profile (overridable per-command via --team or DUVO_TEAM_ID)"
@@ -63006,10 +63306,10 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/create-org-team.ts
-import { z as z166 } from "zod";
-var createOrgTeamResponseSchema = z166.object({
-  id: z166.guid(),
-  name: z166.string()
+import { z as z167 } from "zod";
+var createOrgTeamResponseSchema = z167.object({
+  id: z167.guid(),
+  name: z167.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) {
@@ -63047,14 +63347,14 @@ function registerTeamsCreateOrgTeam(teams) {
 __name(registerTeamsCreateOrgTeam, "registerTeamsCreateOrgTeam");
 
 // src/commands/teams/list.ts
-import { z as z167 } from "zod";
-var teamApiSchema3 = z167.object({
-  id: z167.string(),
-  name: z167.string(),
-  organization_id: z167.string().nullable()
+import { z as z168 } from "zod";
+var teamApiSchema3 = z168.object({
+  id: z168.string(),
+  name: z168.string(),
+  organization_id: z168.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z167.object({
-  teams: z167.array(teamApiSchema3)
+var listMyTeamsResponseSchema3 = z168.object({
+  teams: z168.array(teamApiSchema3)
 });
 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) {
@@ -63097,29 +63397,29 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org-agents.ts
-import { z as z168 } from "zod";
+import { z as z169 } from "zod";
 var DEFAULT_LIMIT24 = 20;
 var MIN_LIMIT26 = 1;
 var MAX_LIMIT24 = 100;
 var NAME_PREVIEW_WIDTH = 32;
-var orgAgentSchema = z168.object({
-  id: z168.string(),
-  name: z168.string(),
-  team_id: z168.string(),
-  team_name: z168.string(),
-  created_at: z168.string().nullable(),
-  updated_at: z168.string().nullable(),
-  last_run_at: z168.string().nullable(),
-  last_run_status: z168.string().nullable(),
-  schedule_enabled: z168.boolean(),
-  auto_disabled_at: z168.string().nullable(),
-  auto_disabled_reason: z168.string().nullable()
-});
-var orgAgentsResponseSchema = z168.object({
-  agents: z168.array(orgAgentSchema),
-  total: z168.number(),
-  limit: z168.number(),
-  offset: z168.number()
+var orgAgentSchema = z169.object({
+  id: z169.string(),
+  name: z169.string(),
+  team_id: z169.string(),
+  team_name: z169.string(),
+  created_at: z169.string().nullable(),
+  updated_at: z169.string().nullable(),
+  last_run_at: z169.string().nullable(),
+  last_run_status: z169.string().nullable(),
+  schedule_enabled: z169.boolean(),
+  auto_disabled_at: z169.string().nullable(),
+  auto_disabled_reason: z169.string().nullable()
+});
+var orgAgentsResponseSchema = z169.object({
+  agents: z169.array(orgAgentSchema),
+  total: z169.number(),
+  limit: z169.number(),
+  offset: z169.number()
 });
 function formatSchedule(agent) {
   if (agent.schedule_enabled) {
@@ -63229,21 +63529,21 @@ Showing ${agents.length} of ${total} agents (offset ${offset})`
 __name(registerTeamsOrgAgents, "registerTeamsOrgAgents");
 
 // src/commands/teams/org-insights.ts
-import { z as z169 } from "zod";
-var headlineSchema = z169.object({
-  total_runs: z169.number(),
-  completed_runs: z169.number(),
-  failed_runs: z169.number(),
-  success_rate: z169.number().nullable(),
-  active_agents: z169.number(),
-  active_users: z169.number(),
-  start_date: z169.string(),
-  end_date: z169.string(),
-  truncated: z169.boolean(),
-  aggregated_teams: z169.number(),
-  total_teams: z169.number()
-});
-var orgInsightsHeadlineResponseSchema = z169.object({
+import { z as z170 } from "zod";
+var headlineSchema = z170.object({
+  total_runs: z170.number(),
+  completed_runs: z170.number(),
+  failed_runs: z170.number(),
+  success_rate: z170.number().nullable(),
+  active_agents: z170.number(),
+  active_users: z170.number(),
+  start_date: z170.string(),
+  end_date: z170.string(),
+  truncated: z170.boolean(),
+  aggregated_teams: z170.number(),
+  total_teams: z170.number()
+});
+var orgInsightsHeadlineResponseSchema = z170.object({
   headline: headlineSchema
 });
 function formatRate(rate) {
@@ -63311,26 +63611,26 @@ function registerTeamsOrgInsights(teams) {
 __name(registerTeamsOrgInsights, "registerTeamsOrgInsights");
 
 // src/commands/teams/org-metrics.ts
-import { z as z170 } from "zod";
-var teamMetricSchema = z170.object({
-  team_id: z170.string(),
-  team_name: z170.string(),
-  is_deleted: z170.boolean(),
-  member_count: z170.number(),
-  assignment_count: z170.number(),
-  scheduled_job_count: z170.number(),
-  total_jobs: z170.number(),
-  completed_jobs: z170.number(),
-  failed_jobs: z170.number(),
-  total_runs: z170.number()
-});
-var orgInsightsMetricsResponseSchema = z170.object({
-  teams: z170.array(teamMetricSchema),
-  start_date: z170.string(),
-  end_date: z170.string(),
-  truncated: z170.boolean(),
-  total_teams: z170.number(),
-  org_member_count: z170.number()
+import { z as z171 } from "zod";
+var teamMetricSchema = z171.object({
+  team_id: z171.string(),
+  team_name: z171.string(),
+  is_deleted: z171.boolean(),
+  member_count: z171.number(),
+  assignment_count: z171.number(),
+  scheduled_job_count: z171.number(),
+  total_jobs: z171.number(),
+  completed_jobs: z171.number(),
+  failed_jobs: z171.number(),
+  total_runs: z171.number()
+});
+var orgInsightsMetricsResponseSchema = z171.object({
+  teams: z171.array(teamMetricSchema),
+  start_date: z171.string(),
+  end_date: z171.string(),
+  truncated: z171.boolean(),
+  total_teams: z171.number(),
+  org_member_count: z171.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) {
@@ -63393,7 +63693,7 @@ ${total_teams} teams${suffix} \xB7 ${org_member_count} org members`
 __name(registerTeamsOrgMetrics, "registerTeamsOrgMetrics");
 
 // src/commands/teams/org-runs.ts
-import { z as z171 } from "zod";
+import { z as z173 } from "zod";
 var DEFAULT_LIMIT25 = 20;
 var MIN_LIMIT27 = 1;
 var MAX_LIMIT25 = 500;
@@ -63405,32 +63705,32 @@ var RUN_STATUSES = [
   "needs_attention"
 ];
 var HAS_ISSUES_VALUES2 = ["true", "false"];
-var orgRunSchema = z171.object({
-  id: z171.string(),
-  status: z171.string(),
-  source: z171.string().nullable(),
-  team_id: z171.string(),
-  team_name: z171.string().nullable(),
-  agent_id: z171.string(),
-  agent_name: z171.string(),
-  build_id: z171.string().nullable(),
-  automation_id: z171.string().nullable(),
-  automation_name: z171.string().nullable(),
-  user_id: z171.string().nullable(),
-  created_at: z171.string(),
-  updated_at: z171.string(),
-  started_at: z171.string().nullable(),
-  completed_at: z171.string().nullable()
-});
-var orgRunsResponseSchema = z171.object({
-  runs: z171.array(orgRunSchema),
-  total: z171.number().nullable(),
-  limit: z171.number(),
+var orgRunSchema = z173.object({
+  id: z173.string(),
+  status: z173.string(),
+  source: z173.string().nullable(),
+  team_id: z173.string(),
+  team_name: z173.string().nullable(),
+  agent_id: z173.string(),
+  agent_name: z173.string(),
+  build_id: z173.string().nullable(),
+  automation_id: z173.string().nullable(),
+  automation_name: z173.string().nullable(),
+  user_id: z173.string().nullable(),
+  created_at: z173.string(),
+  updated_at: z173.string(),
+  started_at: z173.string().nullable(),
+  completed_at: z173.string().nullable()
+});
+var orgRunsResponseSchema = z173.object({
+  runs: z173.array(orgRunSchema),
+  total: z173.number().nullable(),
+  limit: z173.number(),
   // Optional so the CLI keeps working against an API that predates them.
-  created_after: z171.string().nullable().optional(),
-  default_window_applied: z171.boolean().optional(),
-  has_more: z171.boolean().optional(),
-  next_cursor: z171.string().nullable().optional()
+  created_after: z173.string().nullable().optional(),
+  default_window_applied: z173.boolean().optional(),
+  has_more: z173.boolean().optional(),
+  next_cursor: z173.string().nullable().optional()
 });
 var DEFAULT_WINDOW_NOTE = "default window: last 7 days \u2014 pass --created-after (or any time bound) to widen";
 function buildOrgRunsQuery(options, limit) {
@@ -63609,20 +63909,20 @@ Showing ${runs.length} runs${windowNote}; pass --include-total for the total`
 __name(registerTeamsOrgRuns, "registerTeamsOrgRuns");
 
 // src/commands/teams/org-usage.ts
-import { z as z173 } from "zod";
+import { z as z174 } from "zod";
 var GRANULARITIES = ["day", "week", "month"];
 var DEFAULT_LOOKBACK_MS = 30 * 24 * 60 * 60 * 1e3;
-var bucketSchema = z173.object({
-  period: z173.string(),
-  total_runs: z173.number(),
-  scheduled_runs: z173.number(),
-  on_demand_runs: z173.number()
-});
-var usageChartResponseSchema = z173.object({
-  buckets: z173.array(bucketSchema),
-  granularity: z173.enum(GRANULARITIES),
-  truncated: z173.boolean(),
-  total_teams: z173.number()
+var bucketSchema = z174.object({
+  period: z174.string(),
+  total_runs: z174.number(),
+  scheduled_runs: z174.number(),
+  on_demand_runs: z174.number()
+});
+var usageChartResponseSchema = z174.object({
+  buckets: z174.array(bucketSchema),
+  granularity: z174.enum(GRANULARITIES),
+  truncated: z174.boolean(),
+  total_teams: z174.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(
@@ -63681,17 +63981,17 @@ function registerTeamsOrgUsage(teams) {
 __name(registerTeamsOrgUsage, "registerTeamsOrgUsage");
 
 // src/commands/teams/org.ts
-import { z as z174 } from "zod";
-var orgTeamSchema = z174.object({
-  id: z174.string(),
-  name: z174.string(),
-  userIsMember: z174.boolean(),
-  userRole: z174.string().nullable(),
-  memberCount: z174.number()
+import { z as z175 } from "zod";
+var orgTeamSchema = z175.object({
+  id: z175.string(),
+  name: z175.string(),
+  userIsMember: z175.boolean(),
+  userRole: z175.string().nullable(),
+  memberCount: z175.number()
 });
-var listOrgTeamsResponseSchema = z174.object({
-  teams: z174.array(orgTeamSchema),
-  total: z174.number()
+var listOrgTeamsResponseSchema = z175.object({
+  teams: z175.array(orgTeamSchema),
+  total: z175.number()
 });
 var SORT_BY_VALUES = ["createdAt", "name"];
 function registerTeamsOrg(teams) {
@@ -63752,17 +64052,17 @@ function registerTeamsOrg(teams) {
 __name(registerTeamsOrg, "registerTeamsOrg");
 
 // src/commands/teams/orgs.ts
-import { z as z175 } from "zod";
-var orgMembershipSchema = z175.object({
-  organization: z175.object({
-    id: z175.string(),
-    name: z175.string()
+import { z as z176 } from "zod";
+var orgMembershipSchema = z176.object({
+  organization: z176.object({
+    id: z176.string(),
+    name: z176.string()
   }),
-  role: z175.string(),
-  memberCount: z175.number()
+  role: z176.string(),
+  memberCount: z176.number()
 });
-var listMyOrganizationsResponseSchema = z175.object({
-  memberships: z175.array(orgMembershipSchema)
+var listMyOrganizationsResponseSchema = z176.object({
+  memberships: z176.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) {
@@ -63941,7 +64241,7 @@ __name(isStandaloneBinary, "isStandaloneBinary");
 import { createRequire } from "node:module";
 function getPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.72.0" };
+    return { name: "@duvoai/cli", version: "1.73.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../../package.json");