@duvoai/cli 1.30.0 → 1.32.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 = [
@@ -3580,7 +3605,7 @@ var legacyClarityProcessDetailSchema = legacyClarityProcessDetailApiSchema.exten
   analysis: legacyClarityAnalysisSchema.nullable()
 });
 var createClarityProcessSchema = z15.object({
-  name: z15.string().min(1).max(255).optional()
+  name: z15.string().min(1).max(255).optional().describe("Optional process name; server default applies when omitted")
 });
 var createClarityProcessResponseSchema = z15.object({
   id: z15.guid(),
@@ -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") }),
@@ -9706,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
@@ -9806,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({
@@ -9929,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(),
@@ -10017,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()
     })
   )
 });
@@ -11409,6 +11493,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
+var casePriorityFilterSchema = casePrioritySchema;
 var caseFilterStatusSchema = z81.enum([
   "pending",
   "claimed",
@@ -11419,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()
@@ -11504,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] : [];
   }
@@ -11530,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;
@@ -11568,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");
@@ -11577,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;
   }
@@ -12288,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
@@ -17353,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) {
@@ -17511,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,
@@ -17555,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);
@@ -17573,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 {
@@ -17635,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");
@@ -17972,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"
@@ -17995,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);
@@ -18004,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);
     }
@@ -18069,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;
@@ -18246,6 +18456,7 @@ function registerCases(program) {
   registerCasesBulkDelete(cases);
   registerCasesBulkReprocess(cases);
   registerCasesBulkUpdateStatus(cases);
+  registerCasesBulkUpdatePriority(cases);
   registerCasesRuns(cases);
   registerCasesLabels(cases);
 }
@@ -18292,6 +18503,16 @@ var createClarityInviteLinkResponseSchema = z93.object({
     })
   })
 });
+var createClarityProcessResponseSchema2 = z93.object({
+  id: z93.guid(),
+  name: z93.string(),
+  status: clarityProcessStatusSchema,
+  version: z93.union([z93.literal(1), z93.literal(2)]),
+  createdAt: z93.string()
+});
+var getClarityCaptureResponseSchema = z93.object({
+  capture: clarityCaptureSchema
+});
 var createArtifactImportUploadUrlResponseSchema = z93.object({
   signed_url: z93.url(),
   capture_id: z93.guid(),
@@ -18861,6 +19082,44 @@ function registerClarityCreateInviteLink(clarity) {
 }
 __name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
 
+// src/commands/clarity/create-process.ts
+function registerClarityCreateProcess(clarity) {
+  clarity.command("create").description("Create a new Clarity v2 process for the current team").option("--name <name>", "process name").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const teamId = await resolveRequiredTeamId(config, {
+      override: getTeamFlag(this)
+    });
+    const raw = await httpRequest({
+      method: "POST",
+      path: buildTeamPath(teamId, "/clarity/processes"),
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl,
+      body: options.name === void 0 ? {} : { name: options.name }
+    });
+    const parsed = createClarityProcessResponseSchema2.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const process2 = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: process2.id },
+        { label: "Name", value: process2.name },
+        { label: "Status", value: process2.status },
+        { label: "Version", value: String(process2.version) },
+        { label: "Created", value: process2.createdAt }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityCreateProcess, "registerClarityCreateProcess");
+
 // src/commands/clarity/doctor.ts
 import { z as z96 } from "zod";
 
@@ -19846,6 +20105,17 @@ async function getClarityV2Process(config, processId) {
   return parseResponse(clarityV2ProcessReadModelSchema, raw);
 }
 __name(getClarityV2Process, "getClarityV2Process");
+async function getClarityCapture(config, processId, captureId) {
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(
+      processId
+    )}/captures/${encodeURIComponent(captureId)}`,
+    resource: "Clarity capture"
+  });
+  return parseResponse(getClarityCaptureResponseSchema, raw).capture;
+}
+__name(getClarityCapture, "getClarityCapture");
 async function getLegacyClarityProcess(config, processId) {
   const raw = await getClarityJson(config, {
     method: "GET",
@@ -20021,6 +20291,19 @@ var CLARITY_READ_TOOLS = [
     endpoints: [{ method: "GET", path: "/v2/clarity-v2/processes/:processId" }],
     description: "Read the v2 process model: process metadata, captures, and lightweight current/proposal version lists."
   },
+  {
+    name: "getClarityCapture",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity capture"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/captures/:captureId"
+      }
+    ],
+    description: "Read one Clarity v2 capture including full transcript and video transcript."
+  },
   {
     name: "getLegacyClarityProcess",
     scope: "v1 fallback",
@@ -20240,6 +20523,16 @@ var CLARITY_READ_TOOLS = [
   }
 ];
 var CLARITY_WRITE_TOOLS = [
+  {
+    name: "createClarityProcess",
+    scope: "v1+v2",
+    read_only: false,
+    commands: ["duvo clarity create"],
+    endpoints: [
+      { method: "POST", path: "/v2/teams/:teamId/clarity/processes" }
+    ],
+    description: "Create a new Clarity v2 process for the current team (manager+)."
+  },
   {
     name: "sendClarityArtifactChatMessage",
     scope: "v2",
@@ -23277,6 +23570,7 @@ function registerClarity(program) {
   registerClarityStopTransformationProposal(clarity);
   registerClarityCreateInviteLink(clarity);
   registerClarityImportArtifact(clarity);
+  registerClarityCreateProcess(clarity);
 }
 __name(registerClarity, "registerClarity");
 function registerList2(clarity) {
@@ -23455,6 +23749,21 @@ function registerCapture(clarity) {
     "include capture transcripts and media URLs in JSON output"
   ).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function captureAction(processId, captureId, options) {
     const config = await requireAuthenticatedConfig(this);
+    if (options.includeTranscripts) {
+      try {
+        const capture2 = await getClarityCapture(config, processId, captureId);
+        if (options.json) {
+          printJson({ capture: buildCaptureOutput(capture2, options) });
+          return;
+        }
+        console.log(renderCapturesTable([capture2]));
+        return;
+      } catch (error) {
+        if (!isLegacyV2ReadError(error)) {
+          throw error;
+        }
+      }
+    }
     const { captures } = await loadProcessWithCaptures(config, processId);
     const capture = captures.find((item) => item.id === captureId);
     if (!capture) {
@@ -31710,6 +32019,357 @@ function registerTeams(program) {
 }
 __name(registerTeams, "registerTeams");
 
+// 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(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" }
+    }
+  );
+  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(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(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));
+  }
+  if (aIsNumeric !== bIsNumeric) {
+    return aIsNumeric ? -1 : 1;
+  }
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+__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.32.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"}`
+  );
+  console.log(
+    updateAvailable ? "Update available \u2014 run `duvo update` to install it." : "Already up to date."
+  );
+}
+__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(
@@ -31759,20 +32419,137 @@ async function resolveActiveTeamId(config, override) {
 }
 __name(resolveActiveTeamId, "resolveActiveTeamId");
 
-// src/bin/create-program.ts
-var version = resolveVersion();
-function resolveVersion() {
-  if (true) {
-    return "1.30.0";
+// src/update-check.ts
+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_MS2 = 2e3;
+var DIR_MODE2 = 448;
+function checkForUpdate() {
+  if (isUpdateCheckDisabled()) {
+    return Promise.resolve();
   }
-  const packageJsonPath = join3(
-    dirname3(fileURLToPath2(import.meta.url)),
-    "../../package.json"
-  );
-  const { version: v } = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
-  return v;
+  return runUpdateCheck().catch(() => {
+  });
+}
+__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 = getPackageMeta();
+  const cache = await readCache();
+  if (cache && isNewerVersion(cache.latestVersion, pkg.version)) {
+    console.error(`
+${renderUpdateNotice(pkg, cache.latestVersion)}
+`);
+  }
+  const isFresh = cache && Date.now() - cache.lastCheckedAtMs < ONE_DAY_MS;
+  if (isFresh) {
+    return;
+  }
+  await refreshCache(pkg, cache);
+}
+__name(runUpdateCheck, "runUpdateCheck");
+async function refreshCache(pkg, previous) {
+  try {
+    const latestVersion = await fetchLatestNpmVersion(
+      pkg.name,
+      REGISTRY_TIMEOUT_MS2
+    );
+    await writeCache({ lastCheckedAtMs: Date.now(), latestVersion });
+  } catch {
+    await writeCache({
+      lastCheckedAtMs: Date.now(),
+      latestVersion: previous?.latestVersion ?? pkg.version
+    });
+  }
+}
+__name(refreshCache, "refreshCache");
+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(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 parsed;
 }
-__name(resolveVersion, "resolveVersion");
+__name(parseCache, "parseCache");
+async function readCache() {
+  try {
+    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 writeFile5(path, JSON.stringify(cache), "utf8");
+}
+__name(writeCache, "writeCache");
+
+// 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(
@@ -31799,6 +32576,11 @@ function createProgram() {
       ""
     ].join("\n")
   );
+  program.addHelpText("afterAll", () => {
+    const notice = getPendingUpdateNotice();
+    return notice ? `
+${notice}` : "";
+  });
   registerLogin(program);
   registerLogout(program);
   registerWhoami(program);
@@ -31829,146 +32611,11 @@ function createProgram() {
   registerRevisionLogins(program);
   registerClarity(program);
   registerPulse(program);
+  registerUpdate3(program);
   return program;
 }
 __name(createProgram, "createProgram");
 
-// src/update-check.ts
-import { mkdir as mkdir2, readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { dirname as dirname4 } from "node:path";
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var REGISTRY_TIMEOUT_MS = 2e3;
-var DIR_MODE2 = 448;
-function checkForUpdate() {
-  if (isUpdateCheckDisabled()) {
-    return Promise.resolve();
-  }
-  return runUpdateCheck().catch(() => {
-  });
-}
-__name(checkForUpdate, "checkForUpdate");
-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 cache = await readCache();
-  if (cache && isNewerVersion(cache.latestVersion, pkg.version)) {
-    printUpdateNotice(pkg, cache.latestVersion);
-  }
-  const isFresh = cache && Date.now() - cache.lastCheckedAtMs < ONE_DAY_MS;
-  if (isFresh) {
-    return;
-  }
-  await refreshCache(pkg, cache);
-}
-__name(runUpdateCheck, "runUpdateCheck");
-async function refreshCache(pkg, previous) {
-  try {
-    const latestVersion = await fetchLatestVersion(pkg.name);
-    await writeCache({ lastCheckedAtMs: Date.now(), latestVersion });
-  } catch {
-    await writeCache({
-      lastCheckedAtMs: Date.now(),
-      latestVersion: previous?.latestVersion ?? pkg.version
-    });
-  }
-}
-__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");
-}
-__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");
-  }
-  return body.latest;
-}
-__name(fetchLatestVersion, "fetchLatestVersion");
-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;
-  } catch {
-    return null;
-  }
-}
-__name(readCache, "readCache");
-async function writeCache(cache) {
-  const path = getUpdateCheckCachePath();
-  await mkdir2(dirname4(path), { recursive: true, mode: DIR_MODE2 });
-  await writeFile4(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.30.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(loadPackageMeta, "loadPackageMeta");
-
 // src/bin/duvo.ts
 void checkForUpdate();
 createProgram().parseAsync(process.argv).catch((error) => {