@duvoai/cli 1.28.1 → 1.31.0

package/dist/bin/duvo.js

@@ -3,9 +3,6 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/bin/create-program.ts
-import { readFileSync as readFileSync8 } from "node:fs";
-import { dirname as dirname3, join as join3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Command, Option as Option2 } from "commander";
 
 // src/api/agent-folder-schemas.ts
@@ -2676,6 +2673,34 @@ var BUILD_STATUS = {
   LIVE: "live",
   HISTORIC: "historic"
 };
+var CASE_PRIORITY = {
+  NONE: "none",
+  MEDIUM: "medium",
+  HIGH: "high"
+};
+var CASE_PRIORITY_VALUES = {
+  none: 0,
+  medium: 10,
+  high: 50
+};
+var DEFAULT_CASE_PRIORITY = CASE_PRIORITY.NONE;
+var DEFAULT_CASE_PRIORITY_VALUE = CASE_PRIORITY_VALUES.none;
+function casePriorityToValue(priority) {
+  return CASE_PRIORITY_VALUES[priority];
+}
+__name(casePriorityToValue, "casePriorityToValue");
+__name2(casePriorityToValue, "casePriorityToValue");
+function casePriorityFromValue(value) {
+  if (value >= CASE_PRIORITY_VALUES.high) {
+    return CASE_PRIORITY.HIGH;
+  }
+  if (value >= CASE_PRIORITY_VALUES.medium) {
+    return CASE_PRIORITY.MEDIUM;
+  }
+  return CASE_PRIORITY.NONE;
+}
+__name(casePriorityFromValue, "casePriorityFromValue");
+__name2(casePriorityFromValue, "casePriorityFromValue");
 var INGESTION_BODY_LIMIT_BYTES = 5 * 1024 * 1024;
 var CLARITY_WEBHOOK_BODY_LIMIT_BYTES = 25 * 1024 * 1024;
 var SENSITIVE_FIELD_KEYWORDS = [
@@ -3672,12 +3697,27 @@ var portfolioIntelligenceStatusSchema = z15.enum(
   PORTFOLIO_INTELLIGENCE_STATUSES
 );
 var EXECUTION_MODES = ["human-led", "hybrid", "agent-led"];
+var BENEFIT_BASES = ["evidenced", "estimate"];
+var operatingModelBenefitSchema = z15.object({
+  statement: z15.string().min(1),
+  basis: z15.enum(BENEFIT_BASES),
+  assumption: z15.string().nullable(),
+  dataToFirmUp: z15.string().nullable()
+}).refine(
+  (benefit) => benefit.basis !== "estimate" || Boolean(benefit.assumption && benefit.assumption.trim().length > 0),
+  {
+    message: "Estimate benefits require a stated assumption",
+    path: ["assumption"]
+  }
+);
 var operatingModelValueStreamSchema = z15.object({
   name: z15.string().min(1),
   description: z15.string().min(1),
   currentPainPoints: z15.array(z15.string()),
   targetOutcome: z15.string().min(1),
-  kpis: z15.array(z15.string())
+  kpis: z15.array(z15.string()),
+  gap: z15.string().nullable().default(null),
+  benefits: z15.array(operatingModelBenefitSchema).min(1).nullable().default(null)
 });
 var operatingModelOrgElementSchema = z15.object({
   element: z15.string().min(1),
@@ -3717,8 +3757,11 @@ var operatingModelTransformationPrioritySchema = z15.object({
   impact: z15.enum(PRIORITY_RATING_LEVELS),
   effort: z15.enum(PRIORITY_RATING_LEVELS),
   readiness: z15.enum(PRIORITY_RATING_LEVELS),
+  // Displayed as "Evidence" in the UI; JSON key kept for stored-analysis
+  // back-compat.
   confidence: z15.enum(PRIORITY_RATING_LEVELS),
-  quickWin: z15.boolean()
+  quickWin: z15.boolean(),
+  whyThisApproach: z15.string().nullable().default(null)
 });
 var ERP_GAP_DIMENSIONS = [
   "processes",
@@ -3793,6 +3836,11 @@ var operatingModelAnalysisSchema = z15.object({
   erpTransformationInsights: operatingModelErpInsightsSchema.nullable().default(null),
   objectionsAndChangeManagement: operatingModelObjectionsSchema.nullable().default(null),
   businessCase: z15.string().nullable(),
+  transformationGoal: z15.object({
+    objective: z15.string().min(1),
+    targetEndState: z15.string().min(1),
+    expectedBenefits: z15.array(operatingModelBenefitSchema).min(1)
+  }).nullable().default(null),
   generatedAt: z15.string()
 });
 var portfolioProcessLinkSchema = z15.object({
@@ -6601,7 +6649,7 @@ var backgroundJobNotificationSchema = z25.object({
   jobType: backgroundJobTypeSchema,
   outcome: z25.enum(BACKGROUND_JOB_OUTCOMES),
   sourceId: z25.guid(),
-  processId: z25.string().nullable()
+  processId: z25.string().nullable().default(null)
 });
 var RECONNECT_BROKEN_REASONS = [
   "oauth_grant_revoked",
@@ -6632,6 +6680,20 @@ var notificationSchema = z25.discriminatedUnion("type", [
   connectionBrokenNotificationSchema,
   scheduleIssueNotificationSchema
 ]);
+var fallbackNotificationSchema = z25.object({
+  ...notificationBaseShape,
+  type: z25.string(),
+  fallback: z25.literal(true)
+});
+var notificationWireSchema = z25.union([
+  notificationSchema,
+  fallbackNotificationSchema
+]);
+function isFallbackNotification(n) {
+  return "fallback" in n && n.fallback === true;
+}
+__name(isFallbackNotification, "isFallbackNotification");
+__name2(isFallbackNotification, "isFallbackNotification");
 var NOTIFICATION_LIST_DEFAULT_LIMIT = 30;
 var NOTIFICATION_LIST_MAX_LIMIT = 100;
 var notificationListQuerySchema = z25.object({
@@ -6642,7 +6704,7 @@ var notificationListQuerySchema = z25.object({
   cursor: z25.string().optional()
 });
 var notificationListResponseSchema = z25.object({
-  items: z25.array(notificationSchema),
+  items: z25.array(notificationWireSchema),
   nextCursor: z25.string().nullable()
 });
 var notificationUnreadCountResponseSchema = z25.object({
@@ -6669,8 +6731,14 @@ var agentNotificationSettingsResponseSchema = z25.object({
 });
 var notificationsRoomPayloadSchema = z26.object({ userId: z26.guid() });
 var notificationsEventPayloadSchema = z26.discriminatedUnion("type", [
-  z26.object({ type: z26.literal("created"), notification: notificationSchema }),
-  z26.object({ type: z26.literal("updated"), notification: notificationSchema }),
+  z26.object({
+    type: z26.literal("created"),
+    notification: notificationWireSchema
+  }),
+  z26.object({
+    type: z26.literal("updated"),
+    notification: notificationWireSchema
+  }),
   z26.object({ type: z26.literal("deleted"), notificationId: z26.guid() }),
   z26.object({ type: z26.literal("bulk_read") }),
   z26.object({ type: z26.literal("bulk_deleted") }),
@@ -8120,10 +8188,18 @@ var adminDreamEditReferenceSchema = z38.object({
   source_refs: z38.array(memorySourceRefSchema),
   created_at: z38.string()
 });
+var adminDreamTraceEntrySchema = z38.object({
+  type: z38.string().max(128),
+  role: z38.string().max(64).optional(),
+  toolName: z38.string().max(512).optional(),
+  contentPreview: z38.string().max(2e3).optional(),
+  ts: z38.string()
+});
 var adminDreamingRunDetailSchema = adminDreamingRunSummarySchema.extend({
   input: z38.record(z38.string(), z38.unknown()),
   resolvedInputs: z38.array(adminDreamResolvedInputSchema),
-  editReferences: z38.array(adminDreamEditReferenceSchema)
+  editReferences: z38.array(adminDreamEditReferenceSchema),
+  sessionTrace: z38.array(adminDreamTraceEntrySchema)
 });
 var adminDreamingRunDetailResponseSchema = z38.object({
   dream: adminDreamingRunDetailSchema
@@ -9698,12 +9774,19 @@ var humanRequestContextSchema = z59.discriminatedUnion("kind", [
     caseTitle: z59.string()
   })
 ]);
+var casePrioritySchema = z60.enum([
+  CASE_PRIORITY.NONE,
+  CASE_PRIORITY.MEDIUM,
+  CASE_PRIORITY.HIGH
+]);
 var caseQueueItemSchema = z60.object({
   id: z60.guid(),
   queue_id: z60.guid(),
   title: z60.string(),
   data: z60.string(),
   status: z60.enum(["pending", "completed", "failed"]),
+  /** Case priority level. `none` = default (no priority). */
+  priority: casePrioritySchema,
   /**
    * Derived display bucket combining the settlement status with ownership,
    * open HITL tokens, and scheduling. See CASE_DISPLAY_STATUS in
@@ -9798,6 +9881,9 @@ var caseCreateInputSchema = z60.object({
     })
   ).max(50).optional().describe(
     "Optional labels to assign to the case at creation. Labels are created on the queue if they don't already exist."
+  ),
+  priority: casePrioritySchema.optional().describe(
+    "Case priority. `medium` or `high` raise the case above the default in the queue; omit (or `none`) for normal priority. Only set this when the AOP or the user explicitly instructs prioritization \u2014 do not infer it on your own."
   )
 });
 var caseCreateRequestSchema = z60.object({
@@ -9921,6 +10007,10 @@ var caseBulkStatusUpdateResponseSchema = z60.object({
   skippedCount: z60.number(),
   interruptedRunIds: z60.array(z60.guid())
 });
+var caseBulkPriorityUpdateResponseSchema = z60.object({
+  updatedCount: z60.number(),
+  skippedCount: z60.number()
+});
 var deleteQueueResponseSchema = z60.object({
   success: z60.boolean(),
   deleted_case_count: z60.number(),
@@ -10009,7 +10099,9 @@ var exportCasesResponseSchema = z60.object({
   cases: z60.array(
     z60.object({
       title: z60.string(),
-      data: z60.string().optional()
+      data: z60.string().optional(),
+      /** Priority level; omitted for default (`none`) priority cases. */
+      priority: casePrioritySchema.optional()
     })
   )
 });
@@ -11401,6 +11493,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
+var casePriorityFilterSchema = casePrioritySchema;
 var caseFilterStatusSchema = z81.enum([
   "pending",
   "claimed",
@@ -11411,6 +11504,7 @@ var caseFilterStatusSchema = z81.enum([
 ]);
 var casesFiltersSchema = z81.object({
   status: z81.array(caseFilterStatusSchema).optional(),
+  priority: z81.array(casePriorityFilterSchema).optional(),
   created_at_from: z81.string().optional(),
   updated_at_from: z81.string().optional(),
   labels: z81.record(z81.string(), z81.array(z81.string())).optional()
@@ -11496,6 +11590,9 @@ function getFilterValuesByCategoryKey(filters, categoryKey) {
   if (categoryKey === "status") {
     return filters.status ?? [];
   }
+  if (categoryKey === "priority") {
+    return filters.priority ?? [];
+  }
   if (categoryKey === "created_at_from") {
     return filters.created_at_from ? [filters.created_at_from] : [];
   }
@@ -11522,6 +11619,17 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
     }
     return { ...filters, status: parsed.data };
   }
+  if (categoryKey === "priority") {
+    if (values.length === 0) {
+      const { priority: _, ...rest } = filters;
+      return rest;
+    }
+    const parsed = z81.array(casePriorityFilterSchema).safeParse(values);
+    if (!parsed.success) {
+      return filters;
+    }
+    return { ...filters, priority: parsed.data };
+  }
   if (categoryKey === "created_at_from") {
     if (values.length === 0 || !values[0]) {
       const { created_at_from: _, ...rest } = filters;
@@ -11560,7 +11668,7 @@ function removeFilterByCategoryKey(filters, categoryKey) {
 __name(removeFilterByCategoryKey, "removeFilterByCategoryKey");
 __name2(removeFilterByCategoryKey, "removeFilterByCategoryKey");
 function isCasesFiltersEmpty(filters) {
-  return !filters.status?.length && !filters.created_at_from && !filters.updated_at_from && (!filters.labels || Object.keys(filters.labels).length === 0);
+  return !filters.status?.length && !filters.priority?.length && !filters.created_at_from && !filters.updated_at_from && (!filters.labels || Object.keys(filters.labels).length === 0);
 }
 __name(isCasesFiltersEmpty, "isCasesFiltersEmpty");
 __name2(isCasesFiltersEmpty, "isCasesFiltersEmpty");
@@ -11569,6 +11677,9 @@ function countCasesFilters(filters) {
   if (filters.status?.length) {
     count += 1;
   }
+  if (filters.priority?.length) {
+    count += 1;
+  }
   if (filters.created_at_from) {
     count += 1;
   }
@@ -12280,6 +12391,7 @@ var green = /* @__PURE__ */ __name((text3) => wrap(ANSI.green, text3), "green");
 var red = /* @__PURE__ */ __name((text3) => wrap(ANSI.red, text3), "red");
 var cyan = /* @__PURE__ */ __name((text3) => wrap(ANSI.cyan, text3), "cyan");
 var bold = /* @__PURE__ */ __name((text3) => wrap(ANSI.bold, text3), "bold");
+var dim = /* @__PURE__ */ __name((text3) => wrap(ANSI.dim, text3), "dim");
 var yellow = /* @__PURE__ */ __name((text3) => wrap(ANSI.yellow, text3), "yellow");
 
 // src/output/deprecation-notice.ts
@@ -17345,6 +17457,62 @@ function registerCasesBulkReprocess(cases) {
 }
 __name(registerCasesBulkReprocess, "registerCasesBulkReprocess");
 
+// src/commands/cases/bulk-update-priority.ts
+function registerCasesBulkUpdatePriority(cases) {
+  cases.command("bulk-update-priority").description(
+    "Set the priority of multiple cases (1-100). Due postponed cases are picked up first; otherwise higher priority is picked up first. Use 'none' to clear."
+  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption("--ids <list>", "comma-separated case IDs (1-100)").requiredOption(
+    "--priority <level>",
+    `priority level (${casePrioritySchema.options.join(", ")})`
+  ).option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkUpdatePriorityAction(options) {
+    const caseIds = parseCaseIds(options.ids);
+    const priority = parsePriority(options.priority);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    await confirmDestructive({
+      message: `Set the priority of ${caseIds.length} case(s) in queue "${options.queue}" to "${priority}"?`,
+      skip: Boolean(options.yes)
+    });
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-update-priority`,
+      apiKey,
+      apiBaseUrl,
+      body: { case_ids: caseIds, priority }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = caseBulkPriorityUpdateResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const result = parsed.data;
+    console.log(green("Bulk priority update complete."));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Updated", value: String(result.updatedCount) },
+        { label: "Skipped", value: String(result.skippedCount) }
+      ])
+    );
+  }, "bulkUpdatePriorityAction"));
+}
+__name(registerCasesBulkUpdatePriority, "registerCasesBulkUpdatePriority");
+function parsePriority(raw) {
+  if (!casePrioritySchema.options.includes(
+    raw
+  )) {
+    throw new CliError(
+      `Invalid --priority value "${raw}". Allowed: ${casePrioritySchema.options.join(", ")}.`
+    );
+  }
+  return raw;
+}
+__name(parsePriority, "parsePriority");
+
 // src/commands/cases/bulk-update-status.ts
 var CASE_TERMINAL_STATUSES = ["completed", "failed"];
 function registerCasesBulkUpdateStatus(cases) {
@@ -17503,6 +17671,9 @@ function registerCasesCreate(cases) {
   cases.command("create").description(
     "Create one or more cases in a queue. Provide --title for one case or --from-file with a JSON array for many."
   ).requiredOption("--queue <id>", "ID of the queue to create cases in").option("--title <text>", "case title (max 500 chars)").option("--data <text>", "free-form data passed to the assignment on claim").option(
+    "--priority <level>",
+    `case priority (${casePrioritySchema.options.join(", ")}); only set when instructed`
+  ).option(
     "--label <key=value>",
     "label to assign to the case (omit key for a simple tag, repeat for multiple)",
     collectLabel,
@@ -17547,9 +17718,9 @@ function collectLabel(value, previous) {
 __name(collectLabel, "collectLabel");
 async function buildRequestBody(options) {
   if (options.fromFile !== void 0) {
-    if (options.title !== void 0 || options.data !== void 0 || (options.label?.length ?? 0) > 0) {
+    if (options.title !== void 0 || options.data !== void 0 || options.priority !== void 0 || (options.label?.length ?? 0) > 0) {
       throw new CliError(
-        "--from-file cannot be combined with --title, --data, or --label."
+        "--from-file cannot be combined with --title, --data, --priority, or --label."
       );
     }
     return readCasesFromFile(options.fromFile);
@@ -17565,9 +17736,22 @@ async function buildRequestBody(options) {
   if (labels) {
     single.labels = labels;
   }
+  if (options.priority !== void 0) {
+    single.priority = parsePriority2(options.priority, "--priority");
+  }
   return { case: single };
 }
 __name(buildRequestBody, "buildRequestBody");
+function parsePriority2(raw, location) {
+  const parsed = casePrioritySchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Invalid ${location} value "${raw}". Allowed: ${casePrioritySchema.options.join(", ")}.`
+    );
+  }
+  return parsed.data;
+}
+__name(parsePriority2, "parsePriority");
 async function readCasesFromFile(path) {
   let raw;
   try {
@@ -17627,6 +17811,12 @@ function coerceCase(value, location) {
       (l, i) => coerceLabel(l, `${location}.labels[${i}]`)
     );
   }
+  if (obj.priority !== void 0) {
+    if (typeof obj.priority !== "string") {
+      throw new CliError(`${location}.priority must be a string when present.`);
+    }
+    out.priority = parsePriority2(obj.priority, `${location}.priority`);
+  }
   return out;
 }
 __name(coerceCase, "coerceCase");
@@ -17964,12 +18154,16 @@ var TABLE_COLUMNS18 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TITLE", cell: /* @__PURE__ */ __name((row) => row.title, "cell"), maxWidth: 50 },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.display_status, "cell") },
+  { header: "PRIORITY", cell: /* @__PURE__ */ __name((row) => row.priority, "cell") },
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerCasesList(cases) {
   cases.command("list", { isDefault: true }).description("List cases in a queue").requiredOption("--queue <id>", "ID of the queue to list cases for").option("--limit <n>", `page size (${MIN_LIMIT3}-${MAX_LIMIT3})`).option("--offset <n>", "number of cases to skip").option(
     "--status <statuses>",
     `comma-separated case statuses (${caseFilterStatusSchema.options.join(", ")})`
+  ).option(
+    "--priority <levels>",
+    `comma-separated priority levels (${casePriorityFilterSchema.options.join(", ")})`
   ).option("--search <text>", "full-text search across title and data").option(
     "--created-at-from <iso>",
     "include cases created on or after this ISO-8601 timestamp"
@@ -17987,6 +18181,7 @@ function registerCasesList(cases) {
     });
     const offset = parseOffset(options.offset);
     const statuses = parseStatuses(options.status);
+    const priorities = parsePriorities(options.priority);
     const sortBy = parseSortBy(options.sortBy);
     const sortOrder = parseSortOrder(options.sortOrder);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -17996,6 +18191,9 @@ function registerCasesList(cases) {
     if (statuses) {
       searchParams.append("status", statuses.join(","));
     }
+    if (priorities) {
+      searchParams.append("priority", priorities.join(","));
+    }
     if (options.search !== void 0) {
       searchParams.append("search", options.search);
     }
@@ -18061,6 +18259,26 @@ function parseStatuses(raw) {
   return parts;
 }
 __name(parseStatuses, "parseStatuses");
+function parsePriorities(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (parts.length === 0) {
+    throw new CliError(
+      `Invalid --priority value "${raw}". Allowed: ${casePriorityFilterSchema.options.join(", ")}.`
+    );
+  }
+  const allowed = new Set(casePriorityFilterSchema.options);
+  const invalid = parts.filter((p) => !allowed.has(p));
+  if (invalid.length > 0) {
+    throw new CliError(
+      `Invalid --priority value(s): ${invalid.join(", ")}. Allowed: ${casePriorityFilterSchema.options.join(", ")}.`
+    );
+  }
+  return parts;
+}
+__name(parsePriorities, "parsePriorities");
 function parseSortBy(raw) {
   if (raw === void 0) {
     return void 0;
@@ -18238,6 +18456,7 @@ function registerCases(program) {
   registerCasesBulkDelete(cases);
   registerCasesBulkReprocess(cases);
   registerCasesBulkUpdateStatus(cases);
+  registerCasesBulkUpdatePriority(cases);
   registerCasesRuns(cases);
   registerCasesLabels(cases);
 }
@@ -31186,15 +31405,128 @@ function registerTeam(program) {
 }
 __name(registerTeam, "registerTeam");
 
-// src/commands/teams/list.ts
+// src/commands/teams/create-org-team.ts
 import { z as z113 } from "zod";
-var teamApiSchema2 = z113.object({
-  id: z113.string(),
-  name: z113.string(),
-  organization_id: z113.string().nullable()
+var createOrgTeamResponseSchema = z113.object({
+  id: z113.guid(),
+  name: z113.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) {
+    if (options.name === void 0 || options.name.trim().length === 0) {
+      throw new CliError("--name must not be empty");
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/organizations/${encodeURIComponent(orgId)}/teams`,
+      apiKey,
+      apiBaseUrl,
+      body: { name: options.name.trim() }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = createOrgTeamResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from POST /v2/organizations/:orgId/teams: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Team created!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: parsed.data.id },
+        { label: "Name", value: parsed.data.name }
+      ])
+    );
+  }, "createOrgTeamAction"));
+}
+__name(registerTeamsCreateOrgTeam, "registerTeamsCreateOrgTeam");
+
+// src/commands/teams/invite-org-member.ts
+var ORG_ROLES2 = Object.values(ORG_ROLE);
+var DEFAULT_ROLE = ORG_ROLE.MEMBER;
+function registerTeamsInviteOrgMember(teams) {
+  teams.command("invite-org-member <org-id>").description(
+    "Invite a person to an organization, optionally onto one of its teams"
+  ).requiredOption("--email <email>", "email address of the person to invite").option(
+    "--role <role>",
+    `organization role to grant: ${ORG_ROLES2.join(", ")} (default ${DEFAULT_ROLE})`,
+    DEFAULT_ROLE
+  ).option("--team-id <id>", "assign the invitee to this team in the org").option(
+    "--frontend-url <url>",
+    "base URL used to build the invitation email link (email is skipped if omitted)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function inviteOrgMemberAction(orgId, options) {
+    const email = options.email?.trim();
+    if (email === void 0 || email.length === 0) {
+      throw new CliError("--email must not be empty");
+    }
+    const role = options.role ?? DEFAULT_ROLE;
+    if (!ORG_ROLES2.includes(role)) {
+      throw new CliError(
+        `Invalid --role "${role}"; expected one of: ${ORG_ROLES2.join(", ")}`
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const body = { email, role };
+    if (options.teamId !== void 0) {
+      const teamId = options.teamId.trim();
+      if (teamId.length === 0) {
+        throw new CliError("--team-id must not be empty");
+      }
+      body.teamId = teamId;
+    }
+    if (options.frontendUrl !== void 0) {
+      const frontendUrl = options.frontendUrl.trim();
+      if (frontendUrl.length === 0) {
+        throw new CliError("--frontend-url must not be empty");
+      }
+      body.frontendUrl = frontendUrl;
+    }
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/organizations/${encodeURIComponent(orgId)}/members`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = inviteOrgMemberResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from POST /v2/organizations/:orgId/members: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Invitation created!"));
+    console.log();
+    console.log(
+      renderKeyValue([
+        { label: "Invitation ID", value: parsed.data.invitationId },
+        { label: "Email", value: email },
+        { label: "Role", value: role },
+        { label: "Team", value: body.teamId ?? "\u2014" },
+        { label: "Email sent", value: parsed.data.emailSent ? "yes" : "no" }
+      ])
+    );
+  }, "inviteOrgMemberAction"));
+}
+__name(registerTeamsInviteOrgMember, "registerTeamsInviteOrgMember");
+
+// src/commands/teams/list.ts
+import { z as z114 } from "zod";
+var teamApiSchema2 = z114.object({
+  id: z114.string(),
+  name: z114.string(),
+  organization_id: z114.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z113.object({
-  teams: z113.array(teamApiSchema2)
+var listMyTeamsResponseSchema3 = z114.object({
+  teams: z114.array(teamApiSchema2)
 });
 function registerTeamsList(teams) {
   teams.command("list", { isDefault: true }).description("List every team you can act on").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -31237,21 +31569,21 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org-insights.ts
-import { z as z114 } from "zod";
-var headlineSchema = z114.object({
-  total_runs: z114.number(),
-  completed_runs: z114.number(),
-  failed_runs: z114.number(),
-  success_rate: z114.number().nullable(),
-  active_agents: z114.number(),
-  active_users: z114.number(),
-  start_date: z114.string(),
-  end_date: z114.string(),
-  truncated: z114.boolean(),
-  aggregated_teams: z114.number(),
-  total_teams: z114.number()
-});
-var orgInsightsHeadlineResponseSchema = z114.object({
+import { z as z115 } from "zod";
+var headlineSchema = z115.object({
+  total_runs: z115.number(),
+  completed_runs: z115.number(),
+  failed_runs: z115.number(),
+  success_rate: z115.number().nullable(),
+  active_agents: z115.number(),
+  active_users: z115.number(),
+  start_date: z115.string(),
+  end_date: z115.string(),
+  truncated: z115.boolean(),
+  aggregated_teams: z115.number(),
+  total_teams: z115.number()
+});
+var orgInsightsHeadlineResponseSchema = z115.object({
   headline: headlineSchema
 });
 function formatRate(rate) {
@@ -31319,26 +31651,26 @@ function registerTeamsOrgInsights(teams) {
 __name(registerTeamsOrgInsights, "registerTeamsOrgInsights");
 
 // src/commands/teams/org-metrics.ts
-import { z as z115 } from "zod";
-var teamMetricSchema = z115.object({
-  team_id: z115.string(),
-  team_name: z115.string(),
-  is_deleted: z115.boolean(),
-  member_count: z115.number(),
-  assignment_count: z115.number(),
-  scheduled_job_count: z115.number(),
-  total_jobs: z115.number(),
-  completed_jobs: z115.number(),
-  failed_jobs: z115.number(),
-  total_runs: z115.number()
-});
-var orgInsightsMetricsResponseSchema = z115.object({
-  teams: z115.array(teamMetricSchema),
-  start_date: z115.string(),
-  end_date: z115.string(),
-  truncated: z115.boolean(),
-  total_teams: z115.number(),
-  org_member_count: z115.number()
+import { z as z116 } from "zod";
+var teamMetricSchema = z116.object({
+  team_id: z116.string(),
+  team_name: z116.string(),
+  is_deleted: z116.boolean(),
+  member_count: z116.number(),
+  assignment_count: z116.number(),
+  scheduled_job_count: z116.number(),
+  total_jobs: z116.number(),
+  completed_jobs: z116.number(),
+  failed_jobs: z116.number(),
+  total_runs: z116.number()
+});
+var orgInsightsMetricsResponseSchema = z116.object({
+  teams: z116.array(teamMetricSchema),
+  start_date: z116.string(),
+  end_date: z116.string(),
+  truncated: z116.boolean(),
+  total_teams: z116.number(),
+  org_member_count: z116.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) {
@@ -31401,20 +31733,20 @@ ${total_teams} teams${suffix} \xB7 ${org_member_count} org members`
 __name(registerTeamsOrgMetrics, "registerTeamsOrgMetrics");
 
 // src/commands/teams/org-usage.ts
-import { z as z116 } from "zod";
+import { z as z117 } from "zod";
 var GRANULARITIES = ["day", "week", "month"];
 var DEFAULT_LOOKBACK_MS = 30 * 24 * 60 * 60 * 1e3;
-var bucketSchema = z116.object({
-  period: z116.string(),
-  total_runs: z116.number(),
-  scheduled_runs: z116.number(),
-  on_demand_runs: z116.number()
-});
-var usageChartResponseSchema = z116.object({
-  buckets: z116.array(bucketSchema),
-  granularity: z116.enum(GRANULARITIES),
-  truncated: z116.boolean(),
-  total_teams: z116.number()
+var bucketSchema = z117.object({
+  period: z117.string(),
+  total_runs: z117.number(),
+  scheduled_runs: z117.number(),
+  on_demand_runs: z117.number()
+});
+var usageChartResponseSchema = z117.object({
+  buckets: z117.array(bucketSchema),
+  granularity: z117.enum(GRANULARITIES),
+  truncated: z117.boolean(),
+  total_teams: z117.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(
@@ -31473,17 +31805,17 @@ function registerTeamsOrgUsage(teams) {
 __name(registerTeamsOrgUsage, "registerTeamsOrgUsage");
 
 // src/commands/teams/org.ts
-import { z as z117 } from "zod";
-var orgTeamSchema = z117.object({
-  id: z117.string(),
-  name: z117.string(),
-  userIsMember: z117.boolean(),
-  userRole: z117.string().nullable(),
-  memberCount: z117.number()
+import { z as z118 } from "zod";
+var orgTeamSchema = z118.object({
+  id: z118.string(),
+  name: z118.string(),
+  userIsMember: z118.boolean(),
+  userRole: z118.string().nullable(),
+  memberCount: z118.number()
 });
-var listOrgTeamsResponseSchema = z117.object({
-  teams: z117.array(orgTeamSchema),
-  total: z117.number()
+var listOrgTeamsResponseSchema = z118.object({
+  teams: z118.array(orgTeamSchema),
+  total: z118.number()
 });
 function registerTeamsOrg(teams) {
   teams.command("org <org-id>").description("List all teams in an organization you belong to").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function orgAction(orgId, options) {
@@ -31525,17 +31857,17 @@ function registerTeamsOrg(teams) {
 __name(registerTeamsOrg, "registerTeamsOrg");
 
 // src/commands/teams/orgs.ts
-import { z as z118 } from "zod";
-var orgMembershipSchema = z118.object({
-  organization: z118.object({
-    id: z118.string(),
-    name: z118.string()
+import { z as z119 } from "zod";
+var orgMembershipSchema = z119.object({
+  organization: z119.object({
+    id: z119.string(),
+    name: z119.string()
   }),
-  role: z118.string(),
-  memberCount: z118.number()
+  role: z119.string(),
+  memberCount: z119.number()
 });
-var listMyOrganizationsResponseSchema = z118.object({
-  memberships: z118.array(orgMembershipSchema)
+var listMyOrganizationsResponseSchema = z119.object({
+  memberships: z119.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) {
@@ -31581,141 +31913,448 @@ function registerTeams(program) {
   registerTeamsList(teams);
   registerTeamsOrg(teams);
   registerTeamsOrgs(teams);
+  registerTeamsCreateOrgTeam(teams);
+  registerTeamsInviteOrgMember(teams);
   registerTeamsOrgInsights(teams);
   registerTeamsOrgMetrics(teams);
   registerTeamsOrgUsage(teams);
 }
 __name(registerTeams, "registerTeams");
 
-// src/commands/whoami.ts
-function registerWhoami(program) {
-  program.command("whoami").description(
-    "Print the active profile, the authenticated user's name and email, the team ID that subsequent commands will act on, and the auth type"
-  ).action(/* @__PURE__ */ __name(async function whoamiAction() {
-    const resolved = await requireAuthenticatedConfig(this);
-    const profileLabel = resolved.profileName ?? "(env-only, no stored profile)";
-    console.log(`Profile   ${profileLabel}`);
-    const userLine = await fetchUserLine(resolved);
-    if (userLine !== null) {
-      console.log(`User      ${userLine}`);
-    }
-    const teamId = await resolveActiveTeamId(resolved, getTeamFlag(this));
-    if (teamId !== null) {
-      console.log(`Team      ${teamId}`);
-    }
-    const authTypeLabel = resolved.authType === "oauth" ? "OAuth" : "API key";
-    console.log(`Auth type ${authTypeLabel}`);
-  }, "whoamiAction"));
+// src/version/fetch-latest-binary-version.ts
+var CLI_RELEASES_BASE_URL = "https://storage.googleapis.com/duvo-cli-releases";
+var LATEST_POINTER_TIMEOUT_MS = 5e3;
+async function fetchLatestBinaryVersion() {
+  const response = await fetch(`${CLI_RELEASES_BASE_URL}/latest`, {
+    signal: AbortSignal.timeout(LATEST_POINTER_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`releases bucket responded with ${response.status}`);
+  }
+  const version2 = (await response.text()).trim().replace(/^v/, "");
+  if (!/^\d+\.\d+\.\d+$/.test(version2)) {
+    throw new Error(`releases bucket returned an invalid version: ${version2}`);
+  }
+  return version2;
 }
-__name(registerWhoami, "registerWhoami");
-async function fetchUserLine(config) {
-  try {
-    const raw = await httpRequest({
-      method: "GET",
-      path: "/v2/profile",
-      apiKey: config.apiKey,
-      apiBaseUrl: config.apiBaseUrl
-    });
-    const parsed = publicProfileResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      return null;
+__name(fetchLatestBinaryVersion, "fetchLatestBinaryVersion");
+
+// src/version/fetch-latest-npm-version.ts
+var REGISTRY_TIMEOUT_MS = 5e3;
+async function fetchLatestNpmVersion(packageName, timeoutMs = REGISTRY_TIMEOUT_MS) {
+  const response = await fetch(
+    `https://registry.npmjs.org/-/package/${packageName}/dist-tags`,
+    {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { accept: "application/json" }
     }
-    const { name, email } = parsed.data.profile;
-    return name ? `${name} <${email}>` : email;
-  } catch {
-    return null;
+  );
+  if (!response.ok) {
+    throw new Error(`npm registry responded with ${response.status}`);
+  }
+  const body = await response.json();
+  if (body === null || typeof body !== "object" || typeof body.latest !== "string") {
+    throw new Error("npm registry response is missing the latest dist-tag");
   }
+  return body.latest;
 }
-__name(fetchUserLine, "fetchUserLine");
-async function resolveActiveTeamId(config, override) {
-  try {
-    return await resolveRequiredTeamId(config, { override });
-  } catch {
+__name(fetchLatestNpmVersion, "fetchLatestNpmVersion");
+
+// src/version/is-newer-version.ts
+function isSafeNumericIdentifier(value) {
+  return Number(value) <= Number.MAX_SAFE_INTEGER;
+}
+__name(isSafeNumericIdentifier, "isSafeNumericIdentifier");
+function parseVersion(version2) {
+  const match = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?$/.exec(
+    version2.trim()
+  );
+  if (!match) {
+    return null;
+  }
+  const prerelease = match[4] ? match[4].split(".") : [];
+  const numericIdentifiers = [
+    match[1],
+    match[2],
+    match[3],
+    ...prerelease.filter((identifier) => /^\d+$/.test(identifier))
+  ];
+  if (!numericIdentifiers.every(isSafeNumericIdentifier)) {
     return null;
   }
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease
+  };
 }
-__name(resolveActiveTeamId, "resolveActiveTeamId");
-
-// src/bin/create-program.ts
-var version = resolveVersion();
-function resolveVersion() {
-  if (true) {
-    return "1.28.1";
+__name(parseVersion, "parseVersion");
+function comparePrereleaseIdentifiers(a, b) {
+  const aIsNumeric = /^\d+$/.test(a);
+  const bIsNumeric = /^\d+$/.test(b);
+  if (aIsNumeric && bIsNumeric) {
+    return Math.sign(Number(a) - Number(b));
   }
-  const packageJsonPath = join3(
-    dirname3(fileURLToPath2(import.meta.url)),
-    "../../package.json"
-  );
-  const { version: v } = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
-  return v;
+  if (aIsNumeric !== bIsNumeric) {
+    return aIsNumeric ? -1 : 1;
+  }
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
 }
-__name(resolveVersion, "resolveVersion");
-function createProgram() {
-  const program = new Command();
-  program.name("duvo").description("Command-line interface for the Duvo public API").version(version).option(
-    "--profile <name>",
-    "use a specific profile for this invocation (overrides default profile)"
-  ).option(
-    "--team <id>",
-    "use a specific team for this invocation (overrides DUVO_TEAM_ID and profile default; API-key profiles are pinned to the key's team, so a different value is rejected by the server)"
-  ).addOption(
-    new Option2(
-      "--no-update-notifier",
-      "skip the update check for this invocation"
-    ).hideHelp()
+__name(comparePrereleaseIdentifiers, "comparePrereleaseIdentifiers");
+function compareVersions(a, b) {
+  for (let index = 0; index < 3; index += 1) {
+    if (a.core[index] !== b.core[index]) {
+      return Math.sign(a.core[index] - b.core[index]);
+    }
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return Math.sign(b.prerelease.length - a.prerelease.length);
+  }
+  const sharedLength = Math.min(a.prerelease.length, b.prerelease.length);
+  for (let index = 0; index < sharedLength; index += 1) {
+    const result = comparePrereleaseIdentifiers(
+      a.prerelease[index],
+      b.prerelease[index]
+    );
+    if (result !== 0) {
+      return result;
+    }
+  }
+  return Math.sign(a.prerelease.length - b.prerelease.length);
+}
+__name(compareVersions, "compareVersions");
+function isNewerVersion(candidate, current) {
+  const parsedCandidate = parseVersion(candidate);
+  const parsedCurrent = parseVersion(current);
+  if (!parsedCandidate || !parsedCurrent) {
+    return false;
+  }
+  return compareVersions(parsedCandidate, parsedCurrent) > 0;
+}
+__name(isNewerVersion, "isNewerVersion");
+
+// src/version/is-standalone-binary.ts
+function isStandaloneBinary(moduleUrl = import.meta.url) {
+  return moduleUrl.includes("$bunfs") || moduleUrl.includes("~BUN");
+}
+__name(isStandaloneBinary, "isStandaloneBinary");
+
+// src/version/package-meta.ts
+import { createRequire } from "node:module";
+function getPackageMeta() {
+  if (true) {
+    return { name: "@duvoai/cli", version: "1.31.0" };
+  }
+  const require2 = createRequire(import.meta.url);
+  const raw = require2("../../package.json");
+  if (typeof raw !== "object" || raw === null || !("name" in raw) || !("version" in raw) || typeof raw.name !== "string" || typeof raw.version !== "string") {
+    throw new Error("package.json is missing name or version");
+  }
+  const typed = raw;
+  return { name: typed.name, version: typed.version };
+}
+__name(getPackageMeta, "getPackageMeta");
+
+// src/commands/update/self-update-binary.ts
+import { createHash as createHash2 } from "node:crypto";
+import { rename, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+var DOWNLOAD_TIMEOUT_MS = 12e4;
+var EXECUTABLE_MODE = 493;
+var BINARY_ASSETS = {
+  "linux-x64": "duvo-linux-x64",
+  "linux-arm64": "duvo-linux-arm64",
+  "darwin-x64": "duvo-darwin-x64",
+  "darwin-arm64": "duvo-darwin-arm64"
+};
+function resolveBinaryAsset(platform2 = process.platform, arch = process.arch) {
+  const asset = BINARY_ASSETS[`${platform2}-${arch}`];
+  if (!asset) {
+    throw new CliError(
+      `no prebuilt duvo binary for ${platform2}-${arch} (supported: ${Object.keys(BINARY_ASSETS).join(", ")})`
+    );
+  }
+  return asset;
+}
+__name(resolveBinaryAsset, "resolveBinaryAsset");
+async function selfUpdateBinary({
+  version: version2,
+  asset,
+  execPath = process.execPath,
+  fetchImpl = fetch
+}) {
+  const url = `${CLI_RELEASES_BASE_URL}/v${version2}/${asset}`;
+  const [binaryResponse, checksumResponse] = await Promise.all([
+    fetchImpl(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }),
+    fetchImpl(`${url}.sha256`, {
+      signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+    })
+  ]);
+  if (!binaryResponse.ok) {
+    throw new CliError(
+      `failed to download ${url} (HTTP ${binaryResponse.status})`
+    );
+  }
+  if (!checksumResponse.ok) {
+    throw new CliError(
+      `failed to download ${url}.sha256 (HTTP ${checksumResponse.status})`
+    );
+  }
+  const bytes = Buffer.from(await binaryResponse.arrayBuffer());
+  const expected = (await checksumResponse.text()).trim().split(/\s+/)[0];
+  const actual = createHash2("sha256").update(bytes).digest("hex");
+  if (expected !== actual) {
+    throw new CliError(
+      `checksum mismatch for ${asset} (expected ${expected}, got ${actual}) \u2014 not installing`
+    );
+  }
+  const stagedPath = `${execPath}.update-${process.pid}`;
+  try {
+    await writeFile4(stagedPath, bytes, { mode: EXECUTABLE_MODE });
+    await rename(stagedPath, execPath);
+  } catch (error) {
+    await rm2(stagedPath, { force: true });
+    if (isPermissionError(error)) {
+      throw new CliError(
+        `cannot write to ${dirname3(execPath)} \u2014 re-run the installer, which handles sudo:
+  curl -fsSL https://duvo.ai/install-cli.sh | sh`
+      );
+    }
+    throw error;
+  }
+}
+__name(selfUpdateBinary, "selfUpdateBinary");
+function isPermissionError(error) {
+  if (!(error instanceof Error) || !("code" in error)) {
+    return false;
+  }
+  const { code } = error;
+  return code === "EACCES" || code === "EPERM" || code === "EROFS";
+}
+__name(isPermissionError, "isPermissionError");
+
+// src/commands/update/self-update-npm.ts
+import { spawn as spawn2 } from "node:child_process";
+function selfUpdateNpm(packageName, { quiet = false, spawnImpl = spawn2 } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl("npm", ["install", "-g", `${packageName}@latest`], {
+      stdio: quiet ? ["ignore", "ignore", "inherit"] : "inherit"
+    });
+    child.on("error", (error) => {
+      reject(
+        new CliError(
+          `failed to run npm: ${error.message} \u2014 is npm on your PATH?`
+        )
+      );
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new CliError(
+            `\`npm install -g ${packageName}@latest\` exited with code ${String(code)}`
+          )
+        );
+      }
+    });
+  });
+}
+__name(selfUpdateNpm, "selfUpdateNpm");
+
+// src/commands/update/index.ts
+function registerUpdate3(program) {
+  program.command("update").description(
+    "Update the duvo CLI to the latest version. Auto-detects the install method: npm installs run `npm install -g`, standalone binaries (curl installer) self-replace in place."
+  ).option("--check", "check for a newer version without installing it").option("--json", "output raw JSON").action(async (options) => {
+    await runUpdate(options);
+  });
+}
+__name(registerUpdate3, "registerUpdate");
+async function runUpdate(options) {
+  const pkg = getPackageMeta();
+  const installMethod = isStandaloneBinary() ? "binary" : "npm";
+  const latestVersion = await resolveLatestVersion(installMethod, pkg.name);
+  const updateAvailable = isNewerVersion(latestVersion, pkg.version);
+  if (options.check) {
+    printCheckResult(pkg.version, latestVersion, installMethod, options);
+    return;
+  }
+  if (!updateAvailable) {
+    if (options.json) {
+      printJson({
+        currentVersion: pkg.version,
+        latestVersion,
+        installMethod,
+        updated: false
+      });
+    } else {
+      console.log(`Already up to date (v${pkg.version}).`);
+    }
+    return;
+  }
+  if (installMethod === "binary") {
+    await updateStandaloneBinary(pkg.version, latestVersion, options);
+  } else {
+    await updateNpmInstall(pkg.name, pkg.version, latestVersion, options);
+  }
+}
+__name(runUpdate, "runUpdate");
+async function resolveLatestVersion(installMethod, packageName) {
+  try {
+    return installMethod === "binary" ? await fetchLatestBinaryVersion() : await fetchLatestNpmVersion(packageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(`failed to determine the latest version: ${message}`);
+  }
+}
+__name(resolveLatestVersion, "resolveLatestVersion");
+function printCheckResult(currentVersion, latestVersion, installMethod, options) {
+  const updateAvailable = isNewerVersion(latestVersion, currentVersion);
+  if (options.json) {
+    printJson({
+      currentVersion,
+      latestVersion,
+      installMethod,
+      updateAvailable
+    });
+    return;
+  }
+  console.log(`Current   ${currentVersion}`);
+  console.log(`Latest    ${latestVersion}`);
+  console.log(
+    `Install   ${installMethod === "binary" ? "standalone binary (curl installer)" : "npm"}`
   );
-  program.addHelpText(
-    "before",
-    [
-      "Start here (for AI agents):",
-      "  duvo guide get duvo",
-      "",
-      "Guides ship with the CLI (always version-matched) and cover auth,",
-      "workflows, and copy-paste examples. Prefer them over guessing",
-      "commands from flag docs alone. List them with `duvo guide list`.",
-      ""
-    ].join("\n")
+  console.log(
+    updateAvailable ? "Update available \u2014 run `duvo update` to install it." : "Already up to date."
   );
-  registerLogin(program);
-  registerLogout(program);
-  registerWhoami(program);
-  registerProfiles(program);
-  registerApi(program);
-  registerAgents(program);
-  registerAgentFolders(program);
-  registerBuilds(program);
-  registerBuildIntegrations(program);
-  registerIntegrations(program);
-  registerConnections(program);
-  registerOauth(program);
-  registerRuns(program);
-  registerQueues(program);
-  registerQueueLabels(program);
-  registerCases(program);
-  registerSandboxes(program);
-  registerFiles(program);
-  registerPlugins(program);
-  registerSkills(program);
-  registerGuide(program);
-  registerSuggestions(program);
-  registerTeam(program);
-  registerTeams(program);
-  registerSecrets(program);
-  registerCredentials(program);
-  registerRevisionSecrets(program);
-  registerRevisionLogins(program);
-  registerClarity(program);
-  registerPulse(program);
-  return program;
 }
-__name(createProgram, "createProgram");
+__name(printCheckResult, "printCheckResult");
+async function updateStandaloneBinary(currentVersion, latestVersion, options) {
+  const asset = resolveBinaryAsset();
+  if (!options.json) {
+    console.log(
+      `Updating duvo ${currentVersion} \u2192 ${latestVersion} (standalone binary)`
+    );
+    console.log(`Downloading ${asset}\u2026`);
+  }
+  await selfUpdateBinary({ version: latestVersion, asset });
+  if (options.json) {
+    printJson({
+      currentVersion,
+      latestVersion,
+      installMethod: "binary",
+      updated: true
+    });
+  } else {
+    console.log(`Updated ${process.execPath} to v${latestVersion}.`);
+  }
+}
+__name(updateStandaloneBinary, "updateStandaloneBinary");
+async function updateNpmInstall(packageName, currentVersion, latestVersion, options) {
+  if (!options.json) {
+    console.log(`Updating duvo ${currentVersion} \u2192 ${latestVersion} (npm)`);
+    console.log(`Running \`npm install -g ${packageName}@latest\`\u2026`);
+  }
+  await selfUpdateNpm(packageName, { quiet: options.json === true });
+  if (options.json) {
+    printJson({
+      currentVersion,
+      latestVersion,
+      installMethod: "npm",
+      updated: true
+    });
+  } else {
+    console.log(`Updated to v${latestVersion}.`);
+  }
+}
+__name(updateNpmInstall, "updateNpmInstall");
+
+// src/commands/whoami.ts
+function registerWhoami(program) {
+  program.command("whoami").description(
+    "Print the active profile, the authenticated user's name and email, the team ID that subsequent commands will act on, and the auth type"
+  ).action(/* @__PURE__ */ __name(async function whoamiAction() {
+    const resolved = await requireAuthenticatedConfig(this);
+    const profileLabel = resolved.profileName ?? "(env-only, no stored profile)";
+    console.log(`Profile   ${profileLabel}`);
+    const userLine = await fetchUserLine(resolved);
+    if (userLine !== null) {
+      console.log(`User      ${userLine}`);
+    }
+    const teamId = await resolveActiveTeamId(resolved, getTeamFlag(this));
+    if (teamId !== null) {
+      console.log(`Team      ${teamId}`);
+    }
+    const authTypeLabel = resolved.authType === "oauth" ? "OAuth" : "API key";
+    console.log(`Auth type ${authTypeLabel}`);
+  }, "whoamiAction"));
+}
+__name(registerWhoami, "registerWhoami");
+async function fetchUserLine(config) {
+  try {
+    const raw = await httpRequest({
+      method: "GET",
+      path: "/v2/profile",
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl
+    });
+    const parsed = publicProfileResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      return null;
+    }
+    const { name, email } = parsed.data.profile;
+    return name ? `${name} <${email}>` : email;
+  } catch {
+    return null;
+  }
+}
+__name(fetchUserLine, "fetchUserLine");
+async function resolveActiveTeamId(config, override) {
+  try {
+    return await resolveRequiredTeamId(config, { override });
+  } catch {
+    return null;
+  }
+}
+__name(resolveActiveTeamId, "resolveActiveTeamId");
 
 // src/update-check.ts
-import { mkdir as mkdir2, readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
-import { createRequire } from "node:module";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname4 } from "node:path";
+
+// src/output/notice-box.ts
+var ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var HORIZONTAL_PADDING = 3;
+function visibleLength(line) {
+  return line.replace(ANSI_PATTERN, "").length;
+}
+__name(visibleLength, "visibleLength");
+function renderNoticeBox(lines) {
+  const contentWidth = Math.max(...lines.map(visibleLength));
+  const innerWidth = contentWidth + HORIZONTAL_PADDING * 2;
+  const pad2 = " ".repeat(HORIZONTAL_PADDING);
+  const emptyRow = `${yellow("\u2502")}${" ".repeat(innerWidth)}${yellow("\u2502")}`;
+  const body = lines.map((line) => {
+    const fill = " ".repeat(contentWidth - visibleLength(line));
+    return `${yellow("\u2502")}${pad2}${line}${fill}${pad2}${yellow("\u2502")}`;
+  });
+  return [
+    yellow(`\u256D${"\u2500".repeat(innerWidth)}\u256E`),
+    emptyRow,
+    ...body,
+    emptyRow,
+    yellow(`\u2570${"\u2500".repeat(innerWidth)}\u256F`)
+  ].join("\n");
+}
+__name(renderNoticeBox, "renderNoticeBox");
+
+// src/update-check.ts
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var REGISTRY_TIMEOUT_MS = 2e3;
+var REGISTRY_TIMEOUT_MS2 = 2e3;
 var DIR_MODE2 = 448;
 function checkForUpdate() {
   if (isUpdateCheckDisabled()) {
@@ -31725,16 +32364,30 @@ function checkForUpdate() {
   });
 }
 __name(checkForUpdate, "checkForUpdate");
+function getPendingUpdateNotice() {
+  if (isUpdateCheckDisabled()) {
+    return null;
+  }
+  const pkg = getPackageMeta();
+  const cache = readCacheSync();
+  if (cache && isNewerVersion(cache.latestVersion, pkg.version)) {
+    return renderUpdateNotice(pkg, cache.latestVersion);
+  }
+  return null;
+}
+__name(getPendingUpdateNotice, "getPendingUpdateNotice");
 function isUpdateCheckDisabled() {
   const ci = process.env.CI;
   return process.env.NO_UPDATE_NOTIFIER !== void 0 || process.env.NODE_ENV === "test" || ci !== void 0 && ci !== "" && ci !== "false" && ci !== "0" || process.argv.includes("--no-update-notifier");
 }
 __name(isUpdateCheckDisabled, "isUpdateCheckDisabled");
 async function runUpdateCheck() {
-  const pkg = loadPackageMeta();
+  const pkg = getPackageMeta();
   const cache = await readCache();
   if (cache && isNewerVersion(cache.latestVersion, pkg.version)) {
-    printUpdateNotice(pkg, cache.latestVersion);
+    console.error(`
+${renderUpdateNotice(pkg, cache.latestVersion)}
+`);
   }
   const isFresh = cache && Date.now() - cache.lastCheckedAtMs < ONE_DAY_MS;
   if (isFresh) {
@@ -31745,7 +32398,10 @@ async function runUpdateCheck() {
 __name(runUpdateCheck, "runUpdateCheck");
 async function refreshCache(pkg, previous) {
   try {
-    const latestVersion = await fetchLatestVersion(pkg.name);
+    const latestVersion = await fetchLatestNpmVersion(
+      pkg.name,
+      REGISTRY_TIMEOUT_MS2
+    );
     await writeCache({ lastCheckedAtMs: Date.now(), latestVersion });
   } catch {
     await writeCache({
@@ -31755,96 +32411,112 @@ async function refreshCache(pkg, previous) {
   }
 }
 __name(refreshCache, "refreshCache");
-function printUpdateNotice(pkg, latestVersion) {
-  const updateCommand = resolveUpdateCommand(pkg.name, isStandaloneBinary());
-  console.error(
-    `
-Update available for ${pkg.name}: ${pkg.version} \u2192 ${latestVersion}
-Run \`${updateCommand}\` to update.
-`
-  );
-}
-__name(printUpdateNotice, "printUpdateNotice");
-function resolveUpdateCommand(packageName, isStandalone) {
-  return isStandalone ? "curl -fsSL https://duvo.ai/install-cli.sh | sh" : `npm install -g ${packageName}`;
-}
-__name(resolveUpdateCommand, "resolveUpdateCommand");
-function isStandaloneBinary() {
-  return import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN");
+function renderUpdateNotice(pkg, latestVersion) {
+  const fallbackCommand = isStandaloneBinary() ? "curl -fsSL https://duvo.ai/install-cli.sh | sh" : `npm install -g ${pkg.name}`;
+  return renderNoticeBox([
+    `Update available for ${bold(pkg.name)}: ${dim(pkg.version)} \u2192 ${green(latestVersion)}`,
+    `Run ${cyan("duvo update")} (or \`${fallbackCommand}\`) to update.`
+  ]);
 }
-__name(isStandaloneBinary, "isStandaloneBinary");
-async function fetchLatestVersion(packageName) {
-  const response = await fetch(
-    `https://registry.npmjs.org/-/package/${packageName}/dist-tags`,
-    {
-      signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS),
-      headers: { accept: "application/json" }
-    }
-  );
-  if (!response.ok) {
-    throw new Error(`npm registry responded with ${response.status}`);
-  }
-  const body = await response.json();
-  if (body === null || typeof body !== "object" || typeof body.latest !== "string") {
-    throw new Error("npm registry response is missing the latest dist-tag");
+__name(renderUpdateNotice, "renderUpdateNotice");
+function parseCache(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed === null || typeof parsed !== "object" || typeof parsed.lastCheckedAtMs !== "number" || typeof parsed.latestVersion !== "string") {
+    return null;
   }
-  return body.latest;
+  return parsed;
 }
-__name(fetchLatestVersion, "fetchLatestVersion");
+__name(parseCache, "parseCache");
 async function readCache() {
   try {
-    const raw = await readFile10(getUpdateCheckCachePath(), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || typeof parsed.lastCheckedAtMs !== "number" || typeof parsed.latestVersion !== "string") {
-      return null;
-    }
-    return parsed;
+    return parseCache(await readFile10(getUpdateCheckCachePath(), "utf8"));
   } catch {
     return null;
   }
 }
 __name(readCache, "readCache");
+function readCacheSync() {
+  try {
+    return parseCache(readFileSync8(getUpdateCheckCachePath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+__name(readCacheSync, "readCacheSync");
 async function writeCache(cache) {
   const path = getUpdateCheckCachePath();
   await mkdir2(dirname4(path), { recursive: true, mode: DIR_MODE2 });
-  await writeFile4(path, JSON.stringify(cache), "utf8");
+  await writeFile5(path, JSON.stringify(cache), "utf8");
 }
 __name(writeCache, "writeCache");
-function parseVersion(version2) {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version2.trim());
-  if (!match) {
-    return null;
-  }
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-__name(parseVersion, "parseVersion");
-function isNewerVersion(candidate, current) {
-  const parsedCandidate = parseVersion(candidate);
-  const parsedCurrent = parseVersion(current);
-  if (!parsedCandidate || !parsedCurrent) {
-    return false;
-  }
-  for (let index = 0; index < 3; index += 1) {
-    if (parsedCandidate[index] !== parsedCurrent[index]) {
-      return parsedCandidate[index] > parsedCurrent[index];
-    }
-  }
-  return false;
-}
-__name(isNewerVersion, "isNewerVersion");
-function loadPackageMeta() {
-  if (true) {
-    return { name: "@duvoai/cli", version: "1.28.1" };
-  }
-  const require2 = createRequire(import.meta.url);
-  const raw = require2("../package.json");
-  if (typeof raw !== "object" || raw === null || !("name" in raw) || !("version" in raw) || typeof raw.name !== "string" || typeof raw.version !== "string") {
-    throw new Error("package.json is missing name or version");
-  }
-  const typed = raw;
-  return { name: typed.name, version: typed.version };
+
+// src/bin/create-program.ts
+var { version } = getPackageMeta();
+function createProgram() {
+  const program = new Command();
+  program.name("duvo").description("Command-line interface for the Duvo public API").version(version).option(
+    "--profile <name>",
+    "use a specific profile for this invocation (overrides default profile)"
+  ).option(
+    "--team <id>",
+    "use a specific team for this invocation (overrides DUVO_TEAM_ID and profile default; API-key profiles are pinned to the key's team, so a different value is rejected by the server)"
+  ).addOption(
+    new Option2(
+      "--no-update-notifier",
+      "skip the update check for this invocation"
+    ).hideHelp()
+  );
+  program.addHelpText(
+    "before",
+    [
+      "Start here (for AI agents):",
+      "  duvo guide get duvo",
+      "",
+      "Guides ship with the CLI (always version-matched) and cover auth,",
+      "workflows, and copy-paste examples. Prefer them over guessing",
+      "commands from flag docs alone. List them with `duvo guide list`.",
+      ""
+    ].join("\n")
+  );
+  program.addHelpText("afterAll", () => {
+    const notice = getPendingUpdateNotice();
+    return notice ? `
+${notice}` : "";
+  });
+  registerLogin(program);
+  registerLogout(program);
+  registerWhoami(program);
+  registerProfiles(program);
+  registerApi(program);
+  registerAgents(program);
+  registerAgentFolders(program);
+  registerBuilds(program);
+  registerBuildIntegrations(program);
+  registerIntegrations(program);
+  registerConnections(program);
+  registerOauth(program);
+  registerRuns(program);
+  registerQueues(program);
+  registerQueueLabels(program);
+  registerCases(program);
+  registerSandboxes(program);
+  registerFiles(program);
+  registerPlugins(program);
+  registerSkills(program);
+  registerGuide(program);
+  registerSuggestions(program);
+  registerTeam(program);
+  registerTeams(program);
+  registerSecrets(program);
+  registerCredentials(program);
+  registerRevisionSecrets(program);
+  registerRevisionLogins(program);
+  registerClarity(program);
+  registerPulse(program);
+  registerUpdate3(program);
+  return program;
 }
-__name(loadPackageMeta, "loadPackageMeta");
+__name(createProgram, "createProgram");
 
 // src/bin/duvo.ts
 void checkForUpdate();