@duvoai/cli 1.21.0 → 1.24.0

package/dist/bin/duvo.js

@@ -6,7 +6,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 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 } from "commander";
+import { Command, Option as Option2 } from "commander";
 
 // src/api/agent-folder-schemas.ts
 import { z } from "zod";
@@ -2201,6 +2201,23 @@ var evalCountsSchema = z9.object({
 var evalCountsByAgentResponseSchema = z9.object({
   by_agent: z9.record(z9.string(), evalCountsSchema)
 });
+var agentRunStatsSchema = z9.object({
+  success: z9.int(),
+  critical: z9.int(),
+  medium: z9.int(),
+  failed: z9.int(),
+  need_input: z9.int(),
+  /** Total runs in the current lookback window. */
+  total: z9.int(),
+  /** Week-over-week change in total runs (current window minus previous). */
+  delta: z9.int()
+});
+var agentRunStatsByAgentResponseSchema = z9.object({
+  run_stats_by_agent: z9.record(z9.string(), agentRunStatsSchema)
+});
+var evalCountsAndRunStatsResponseSchema = evalCountsByAgentResponseSchema.extend(
+  agentRunStatsByAgentResponseSchema.shape
+);
 var summarizeEvalScoresBodySchema = z9.object({
   since: z9.iso.datetime(),
   /** `"custom"` restricts to the target revision's runs + `custom__*` flags only. */
@@ -2630,6 +2647,11 @@ var DEFAULT_AGENT_CONFIG = {
     browserProvider: DEFAULT_BROWSER_PROVIDER
   }
 };
+var AUTOMATION_REVISION_STATUS = {
+  DRAFT: "draft",
+  LIVE: "live",
+  HISTORIC: "historic"
+};
 var BUILD_STATUS = {
   DRAFT: "draft",
   LIVE: "live",
@@ -5076,7 +5098,8 @@ var listClarityProcessSnapshotsQuerySchema = z222.object({
   offset: z222.coerce.number().int().min(0).default(0)
 });
 var listClarityProcessSnapshotsResponseSchema = z222.object({
-  snapshots: z222.array(clarityProcessSnapshotVersionApiSchema)
+  snapshots: z222.array(clarityProcessSnapshotVersionApiSchema),
+  total: z222.number().int().nonnegative().describe("Total number of snapshots of this kind for the process")
 });
 var getClarityProcessSnapshotParamsSchema = listClarityProcessSnapshotsParamsSchema.extend({
   snapshot_id: z222.guid().describe("Snapshot id")
@@ -5748,7 +5771,7 @@ __name(buildClarityProcessLanguageBlock, "buildClarityProcessLanguageBlock");
 __name2(buildClarityProcessLanguageBlock, "buildClarityProcessLanguageBlock");
 function buildClarityNarrativeLanguageBlock() {
   return `# OUTPUT LANGUAGE
-Write every narrative artifact field you produce (summary, SWOT analysis entries, projected impact, assumptions, recommendations, and supporting prose) in the original language already used by the snapshot. If the snapshot mixes languages, follow the dominant user-facing language in the existing narrative and step text. Keep JSON field keys, enum values, ids, integration or system identifiers, file paths, shell commands, and product names in English/exactly as given; do not translate them.`;
+Write every narrative artifact field you produce (summary, SWOT analysis entries, projected impact, assumptions, recommendations, and supporting prose) in the language of the snapshot's step titles and descriptions. Judge that language from the step titles and descriptions only; ignore the language of source excerpts, evidence quotes, transcript excerpts, and previously generated narrative fields such as summary, swot, or projectedImpact. If the step titles and descriptions are in English, or their language is mixed or ambiguous, write in English. Keep JSON field keys, enum values, ids, integration or system identifiers, file paths, shell commands, and product names in English/exactly as given; do not translate them.`;
 }
 __name(buildClarityNarrativeLanguageBlock, "buildClarityNarrativeLanguageBlock");
 __name2(buildClarityNarrativeLanguageBlock, "buildClarityNarrativeLanguageBlock");
@@ -6681,6 +6704,7 @@ var INTEGRATION_SLUGS = [
   "googlesheets",
   "googledrive",
   "firecrawl",
+  // Deprecated 2026-07: catalog rows purged, retained for API contract + historical payloads
   "exa",
   "exa-search",
   "exa-company-search",
@@ -6925,8 +6949,20 @@ var updateIntegrationRequestSchema = z27.object({
   shared: z27.boolean().optional()
 });
 var testIntegrationRequestSchema = z27.object({
-  server_url: z27.url().describe("MCP server URL to test"),
-  headers: z27.record(z27.string(), z27.string()).optional().describe("Optional HTTP headers for authentication")
+  server_url: z27.url().optional().describe("Raw MCP server URL to probe (for custom MCP servers)"),
+  integration_slug: IntegrationSlugSchema.optional().describe(
+    "Catalog integration slug. The backend resolves the MCP server URL and dummy auth headers server-side \u2014 no server_url or headers needed."
+  ),
+  headers: z27.record(z27.string(), z27.string()).optional().describe(
+    "Optional HTTP headers for authentication (raw server_url mode only)"
+  )
+}).refine(
+  (data) => Boolean(data.server_url) !== Boolean(data.integration_slug),
+  {
+    message: "Provide exactly one of server_url or integration_slug"
+  }
+).refine((data) => !(data.integration_slug && data.headers), {
+  message: "headers are not allowed with integration_slug \u2014 the backend builds dummy auth headers server-side"
 });
 var SUGGESTION_TYPES = [
   "aop",
@@ -7194,12 +7230,12 @@ var artifactDetailResponseSchema = z31.object({
   // teammates when the Pulse is published to the team with `edit` permission,
   // and for a member individually granted `edit` via a per-member share. Drives
   // the chat/version affordances; ownership actions stay gated on `is_creator`.
-  can_edit: z31.boolean(),
-  messages: z31.array(artifactMessageSchema)
+  can_edit: z31.boolean()
 });
 var artifactMessageListResponseSchema = z31.object({
   data: z31.array(artifactMessageSchema),
-  total: z31.number().int().nonnegative()
+  total: z31.number().int().nonnegative(),
+  has_more: z31.boolean()
 });
 var artifactRevisionSchema = z31.object({
   id: z31.guid(),
@@ -8830,6 +8866,117 @@ var updateAutomationResponseApiSchema = z50.object({
 var deleteAutomationResponseApiSchema = z50.object({
   success: z50.boolean()
 });
+var automationRevisionStatusApiSchema = z50.enum(
+  AUTOMATION_REVISION_STATUS
+);
+var automationRevisionSummaryApiSchema = z50.object({
+  id: z50.guid().describe("Unique revision identifier"),
+  automation_id: z50.guid().describe("ID of the automation this revision belongs to"),
+  revision_number: z50.int().nullable().describe(
+    "Sequential revision number, assigned on activation (null for a draft)"
+  ),
+  status: automationRevisionStatusApiSchema.describe(
+    "Lifecycle status: draft, live, or historic"
+  ),
+  base_revision_id: z50.guid().nullable().describe(
+    "Revision this draft was branched from (null when it has no base)"
+  ),
+  name: z50.string().nullable().describe("Optional human-readable revision name"),
+  description: z50.string().nullable().describe("Optional revision description"),
+  is_live: z50.boolean().describe("True when this is the automation's active revision"),
+  is_stale_base: z50.boolean().describe(
+    "True when a draft's base is no longer the active revision and must be resolved before activation"
+  ),
+  agent_count: z50.int().describe("Number of agent bindings in the revision"),
+  queue_count: z50.int().describe("Number of queue bindings in the revision"),
+  trigger_count: z50.int().describe("Number of trigger bindings in the revision"),
+  modified_agent_ids: z50.array(z50.guid()).describe("Agents whose referenced build differs from the base revision"),
+  created_at: z50.string().describe("ISO 8601 creation timestamp"),
+  updated_at: z50.string().describe("ISO 8601 last-modified timestamp")
+});
+var automationRevisionsListApiSchema = z50.object({
+  revisions: z50.array(automationRevisionSummaryApiSchema).describe("Revisions for the automation, newest first"),
+  /**
+   * True when older revisions exist beyond the returned window. The list is
+   * capped (newest-first); older revisions remain inspectable individually via
+   * `GET /automations/:automation_id/revisions/:revision_id`.
+   */
+  has_more: z50.boolean().describe("True when older revisions exist beyond the returned window")
+});
+var automationRevisionAgentBindingApiSchema = z50.object({
+  agent_id: z50.guid().describe("Agent identifier"),
+  build_id: z50.guid().describe("Build referenced for the agent in this revision")
+});
+var automationRevisionQueueBindingApiSchema = z50.object({
+  case_queue_id: z50.guid().describe("Queue identifier"),
+  agent_id: z50.guid().nullable().describe(
+    "Agent the queue routes to in this revision (null when unrouted)"
+  ),
+  enabled: z50.boolean().describe("Whether the queue's routing is enabled"),
+  concurrency: z50.int().nullable().describe("Per-revision concurrency limit (null for the queue default)"),
+  name: z50.string().nullable().describe(
+    "Per-revision queue name override (null to keep the queue's own name)"
+  ),
+  description: z50.string().nullable().describe("Per-revision queue description override")
+});
+var automationRevisionTriggerBindingApiSchema = z50.object({
+  trigger_id: z50.guid().describe("Stable trigger identity"),
+  enabled: z50.boolean().describe("Whether the trigger is enabled in this revision"),
+  filter_config: z50.record(z50.string(), z50.unknown()).describe("Per-revision trigger filter configuration")
+});
+var automationRevisionDetailApiSchema = automationRevisionSummaryApiSchema.extend({
+  agents: z50.array(automationRevisionAgentBindingApiSchema).describe("Agent bindings in the revision"),
+  queues: z50.array(automationRevisionQueueBindingApiSchema).describe("Queue routing bindings in the revision"),
+  triggers: z50.array(automationRevisionTriggerBindingApiSchema).describe("Trigger config bindings in the revision")
+});
+var automationRevisionDetailResponseApiSchema = z50.object({
+  revision: automationRevisionDetailApiSchema.describe(
+    "The revision with its full manifest"
+  )
+});
+var automationRevisionResponseApiSchema = z50.object({
+  revision: automationRevisionSummaryApiSchema.describe("The revision summary")
+});
+var AUTOMATION_REVISION_NAME_MAX_LENGTH = 200;
+var AUTOMATION_REVISION_DESCRIPTION_MAX_LENGTH = 2e3;
+var revisionNameFieldSchema = z50.string().trim().min(1).max(AUTOMATION_REVISION_NAME_MAX_LENGTH);
+var revisionDescriptionFieldSchema = z50.string().trim().max(AUTOMATION_REVISION_DESCRIPTION_MAX_LENGTH);
+var createAutomationRevisionBodyApiSchema = z50.object({
+  base_revision_id: z50.guid().optional().describe("Revision to branch from (defaults to the active revision)"),
+  name: revisionNameFieldSchema.optional().describe("Optional draft name"),
+  description: revisionDescriptionFieldSchema.optional().describe("Optional draft description")
+});
+var setAutomationRevisionAgentBodyApiSchema = z50.object({
+  agent_id: z50.guid().describe("Agent to bind in the revision"),
+  build_id: z50.guid().describe("Build to reference for the agent")
+});
+var setAutomationRevisionQueueBodyApiSchema = z50.object({
+  case_queue_id: z50.guid().describe("Queue to route in the revision"),
+  agent_id: z50.guid().nullable().optional().describe(
+    "Agent the queue routes to (null clears routing; omit to keep current)"
+  ),
+  enabled: z50.boolean().optional().describe(
+    "Whether routing is enabled (omit to keep current; default true when new)"
+  ),
+  concurrency: z50.int().nonnegative().nullable().optional().describe(
+    "Per-revision concurrency limit (null for queue default; omit to keep current)"
+  ),
+  name: revisionNameFieldSchema.nullable().optional().describe("Per-revision name override (null clears; omit to keep current)"),
+  description: revisionDescriptionFieldSchema.nullable().optional().describe(
+    "Per-revision description override (null clears; omit to keep current)"
+  )
+});
+var activateAutomationRevisionBodyApiSchema = z50.object({
+  repin_pending_cases: z50.boolean().optional().describe(
+    "Re-pin the automation's pending, unclaimed cases onto the newly activated revision"
+  )
+});
+var activateAutomationRevisionResponseApiSchema = z50.object({
+  revision: automationRevisionSummaryApiSchema.describe(
+    "The newly activated revision"
+  ),
+  repinned_case_count: z50.int().describe("Number of pending cases re-pinned onto the activated revision")
+});
 var DataResidencySchema = z51.enum(["us", "eu", "apac"]);
 var DataHandlingSchema = z51.enum(["standard", "zdr"]);
 var browserPageSchema = z52.object({
@@ -9623,11 +9770,6 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Exposes the versioned Automations migration entry point. When on, Managers see a 'Migrate to automations' action on the Agents page that sorts the team's standalone agents and queues into Automations (one per connected closure, via the same closure logic as the cross-team move) and stamps team.automations_migrated_at. The stamped timestamp \u2014 not this flag \u2014 drives the Automations sidebar entry. Resolved by team/org (user-level overrides are ignored by the migration gate). Off-by-default for staged, per-team rollout."
   },
-  PULSE: {
-    key: "pulse",
-    defaultValue: false,
-    description: "Enables Duvo Pulse \u2014 the agent-generated visualization Artifacts surface. When disabled, the side-nav entry is hidden and every /v1/artifacts/* endpoint returns 404; the cc-server ingestion callback is unaffected."
-  },
   AGENT_SELF_SCHEDULING: {
     key: "agent_self_scheduling",
     defaultValue: false,
@@ -9668,6 +9810,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the case approval feature end-to-end: AOP authors can @-mention team members in the agent AOP textarea (serialized as <DUVO:USER> tags), agents can request human approval on cases via the request_case_approval tool, and approvers see and respond to pending requests on the case. Off-by-default for staged rollout."
   },
+  CLARITY_AGENT_CHAT: {
+    key: "clarity_agent_chat",
+    defaultValue: false,
+    description: "Routes Clarity process edits through Ask Duvo (Meta Agent) on Clarity v2 detail pages: shows the Agent Chat rail there and hides the artifact-chat composer for new edit requests while keeping artifact-chat history readable. Off-by-default for staged rollout."
+  },
   CLARITY_ARTIFACT_CHAT: {
     key: "clarity_artifact_chat",
     defaultValue: false,
@@ -12314,6 +12461,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 var CONFIG_DIR_NAME = "duvo";
 var CONFIG_FILE_NAME = "config.json";
+var UPDATE_CHECK_CACHE_FILE_NAME = "update-check.json";
 function getConfigDir() {
   const xdg = process.env.XDG_CONFIG_HOME;
   if (xdg && xdg.length > 0) {
@@ -12326,6 +12474,10 @@ function getConfigPath() {
   return join(getConfigDir(), CONFIG_FILE_NAME);
 }
 __name(getConfigPath, "getConfigPath");
+function getUpdateCheckCachePath() {
+  return join(getConfigDir(), UPDATE_CHECK_CACHE_FILE_NAME);
+}
+__name(getUpdateCheckCachePath, "getUpdateCheckCachePath");
 
 // src/config/store.ts
 var FILE_MODE = 384;
@@ -13548,6 +13700,55 @@ var createAgentResponseSchema = z84.object({
 var deleteAgentResponseSchema = z84.object({
   success: z84.literal(true)
 });
+var namedRefSchema = z84.object({
+  id: z84.string(),
+  name: z84.string()
+});
+var moveQueueRefSchema = z84.object({
+  id: z84.string(),
+  name: z84.string(),
+  item_count: z84.number()
+});
+var connectionDecisionSchema = z84.object({
+  agent_id: z84.string(),
+  agent_name: z84.string(),
+  integration_type: z84.string(),
+  integration_name: z84.string(),
+  instance_name: z84.string(),
+  decision: z84.string()
+});
+var customRebuildSchema = z84.object({
+  agent_id: z84.string(),
+  agent_name: z84.string(),
+  custom_integration_name: z84.string()
+});
+var moveAgentResponseSchema = z84.object({
+  source_team_id: z84.string(),
+  target_team_id: z84.string(),
+  root_agent_id: z84.string(),
+  agents: z84.array(namedRefSchema),
+  queues: z84.array(moveQueueRefSchema),
+  total_case_items: z84.number(),
+  total_runs: z84.number(),
+  skills_to_clone: z84.array(namedRefSchema),
+  files_to_copy: z84.array(z84.object({ path: z84.string() })),
+  warnings: z84.object({
+    outcome: z84.object({
+      instances_reconnected: z84.array(connectionDecisionSchema),
+      instances_disconnected: z84.array(connectionDecisionSchema),
+      custom_integrations_to_rebuild: z84.array(customRebuildSchema),
+      catalog_rows_created_on_target: z84.number()
+    }),
+    dropped_folders: z84.array(namedRefSchema),
+    dropped_memory_count: z84.number(),
+    files_copied_count: z84.number(),
+    files_skipped_conflict: z84.array(z84.string())
+  }),
+  options: z84.object({
+    move_learnings: z84.boolean()
+  }),
+  applied: z84.boolean()
+});
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
 var DEFAULT_BUILD_NAME = "Initial build";
@@ -14535,6 +14736,151 @@ function registerAgentsModels(agents) {
 }
 __name(registerAgentsModels, "registerAgentsModels");
 
+// src/commands/agents/move.ts
+var NOT_STANDALONE_CODE = "ASSIGNMENT_NOT_STANDALONE";
+function registerAgentsMove(agents) {
+  agents.command("move <id>").description("Move an agent (and its connected workspace) to another team").requiredOption("--to-team <id>", "ID of the team to move the agent into").option(
+    "--all-together",
+    "move connected queues, triggers, and handover peers along with the agent"
+  ).option(
+    "--skip-learnings",
+    "drop the agent's accumulated learnings instead of carrying them across"
+  ).option("--dry-run", "preview the move without applying any changes").option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function moveAction(id, options) {
+    const agentId = trimRequired(id, "<id>");
+    const targetTeamId = trimRequired(options.toTeam ?? "", "--to-team");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const isDryRun = options.dryRun === true;
+    if (!isDryRun) {
+      await confirmDestructive({
+        message: `Move agent "${agentId}" to team "${targetTeamId}"?`,
+        skip: options.yes === true
+      });
+    }
+    const body = {
+      target_team_id: targetTeamId,
+      move_learnings: options.skipLearnings !== true,
+      bypass_standalone_gate: options.allTogether === true
+    };
+    const searchParams = new URLSearchParams();
+    if (isDryRun) {
+      searchParams.append("dry_run", "true");
+    }
+    const raw = await requestMove({
+      agentId,
+      apiKey,
+      apiBaseUrl,
+      body,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = moveAgentResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    renderPlan(parsed.data, isDryRun);
+  }, "moveAction"));
+}
+__name(registerAgentsMove, "registerAgentsMove");
+async function requestMove(args) {
+  try {
+    return await httpRequest({
+      method: "POST",
+      path: `/v2/agents/${encodeURIComponent(args.agentId)}/move`,
+      apiKey: args.apiKey,
+      apiBaseUrl: args.apiBaseUrl,
+      body: args.body,
+      searchParams: args.searchParams
+    });
+  } catch (error) {
+    if (error instanceof CliHttpError && error.apiErrorCode === NOT_STANDALONE_CODE) {
+      throw new CliError(
+        "This agent is connected to queues or other agents. Re-run with --all-together to move everything as a group."
+      );
+    }
+    throw error;
+  }
+}
+__name(requestMove, "requestMove");
+function renderPlan(plan, isDryRun) {
+  const otherAgents = plan.agents.filter((a) => a.id !== plan.root_agent_id);
+  const outcome = plan.warnings.outcome;
+  console.log(green(isDryRun ? "Move preview" : "Agent moved!"));
+  console.log(
+    renderKeyValue([
+      { label: "Target team", value: plan.target_team_id },
+      { label: "Agents moving", value: String(plan.agents.length) },
+      { label: "Queues", value: String(plan.queues.length) },
+      { label: "Cases", value: String(plan.total_case_items) },
+      { label: "Runs", value: String(plan.total_runs) },
+      {
+        label: "Move learnings",
+        value: plan.options.move_learnings ? "yes" : "no"
+      }
+    ])
+  );
+  if (otherAgents.length > 0) {
+    console.log(`
+Connected agents coming along (${otherAgents.length}):`);
+    for (const agent of otherAgents) {
+      console.log(`  - ${agent.name} (${agent.id})`);
+    }
+  }
+  if (plan.queues.length > 0) {
+    console.log(`
+Queues (${plan.queues.length}):`);
+    for (const queue of plan.queues) {
+      console.log(`  - ${queue.name} \u2014 ${queue.item_count} case(s)`);
+    }
+  }
+  if (plan.skills_to_clone.length > 0) {
+    const names = plan.skills_to_clone.map((s) => s.name).join(", ");
+    console.log(`
+Skills copied to target: ${names}`);
+  }
+  if (plan.files_to_copy.length > 0) {
+    const paths = plan.files_to_copy.map((f) => f.path).join(", ");
+    console.log(`
+Files copied to target: ${paths}`);
+  }
+  if (outcome.instances_disconnected.length > 0) {
+    console.log("\nConnections to reconnect on the target team:");
+    for (const c of outcome.instances_disconnected) {
+      console.log(`  - ${c.integration_name} (${c.agent_name})`);
+    }
+  }
+  if (outcome.custom_integrations_to_rebuild.length > 0) {
+    console.log("\nCustom connections to rebuild on the target team:");
+    for (const c of outcome.custom_integrations_to_rebuild) {
+      console.log(`  - ${c.custom_integration_name} (${c.agent_name})`);
+    }
+  }
+  if (plan.warnings.files_skipped_conflict.length > 0) {
+    const paths = plan.warnings.files_skipped_conflict.join(", ");
+    console.log(`
+Files not copied (already exist on target): ${paths}`);
+  }
+  if (plan.warnings.dropped_folders.length > 0) {
+    const names = plan.warnings.dropped_folders.map((f) => f.name).join(", ");
+    console.log(`
+Queues will be moved out of their folders: ${names}`);
+  }
+  if (plan.warnings.dropped_memory_count > 0) {
+    console.log(
+      `
+${plan.warnings.dropped_memory_count} AOP exception(s) will be cleared for users who aren't in the target team.`
+    );
+  }
+  if (isDryRun) {
+    console.log("\nNothing was changed. Re-run without --dry-run to apply.");
+  }
+}
+__name(renderPlan, "renderPlan");
+
 // src/api/schedule-schemas.ts
 import { z as z86 } from "zod";
 var publicScheduleSchema = z86.object({
@@ -15352,6 +15698,7 @@ function registerAgents(program) {
   registerAgentsGet(agents);
   registerAgentsCreate(agents);
   registerAgentsUpdate(agents);
+  registerAgentsMove(agents);
   registerAgentsModels(agents);
   registerAgentsSetModel(agents);
   registerAgentsDelete(agents);
@@ -19209,6 +19556,19 @@ var CLARITY_READ_TOOLS = [
     endpoints: [{ method: "GET", path: "/v2/clarity/processes/:processId" }],
     description: "Read old v1 Clarity processes with legacy analysis, transformation guidance, and captures."
   },
+  {
+    name: "listClarityProcessSnapshots",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity list-snapshots"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/snapshots/:kind"
+      }
+    ],
+    description: "List lightweight v2 snapshot versions of one kind (current_process or transformation_proposal) with limit/offset pagination."
+  },
   {
     name: "getClarityProcessSnapshot",
     scope: "v2",
@@ -21442,6 +21802,103 @@ function registerClarityProcessSummaries(clarity) {
 }
 __name(registerClarityProcessSummaries, "registerClarityProcessSummaries");
 
+// src/commands/clarity/list-snapshots.ts
+import { z as z99 } from "zod";
+var SNAPSHOT_KINDS = ["current_process", "transformation_proposal"];
+var DEFAULT_LIMIT7 = 50;
+var MIN_LIMIT7 = 1;
+var MAX_LIMIT7 = 100;
+var snapshotListItemSchema = z99.looseObject({
+  id: z99.string(),
+  status: z99.string(),
+  creator_type: z99.string(),
+  created_at: z99.string(),
+  parent_id: z99.string().nullable().optional(),
+  source_snapshot_id: z99.string().nullable().optional()
+});
+var listSnapshotsResponseSchema = z99.looseObject({
+  snapshots: z99.array(snapshotListItemSchema),
+  total: z99.number().int().optional()
+});
+var TABLE_COLUMNS21 = [
+  {
+    header: "ID",
+    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
+  },
+  {
+    header: "STATUS",
+    cell: /* @__PURE__ */ __name((row) => row.status, "cell")
+  },
+  {
+    header: "CREATOR",
+    cell: /* @__PURE__ */ __name((row) => row.creator_type, "cell")
+  },
+  {
+    header: "PARENT",
+    cell: /* @__PURE__ */ __name((row) => row.parent_id ?? "", "cell")
+  },
+  {
+    header: "CREATED",
+    cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
+  }
+];
+function registerClarityListSnapshots(clarity) {
+  clarity.command("list-snapshots <process-id> <kind>").description(
+    `List lightweight v2 snapshot versions of one kind (${SNAPSHOT_KINDS.join(" or ")}) for a Clarity process`
+  ).option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of snapshots to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, rawKind, options) {
+    const kind = parseSnapshotKind2(rawKind);
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT7,
+      min: MIN_LIMIT7,
+      max: MAX_LIMIT7
+    });
+    const offset = parseOffset(options.offset);
+    const config = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await getClarityJson(config, {
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/snapshots/${kind}`,
+      resource: "Clarity process snapshots",
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = listSnapshotsResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (response.snapshots.length === 0) {
+      console.log("No snapshots found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS21, response.snapshots));
+    console.log(renderPaginationSummary(response, offset));
+  }, "action"));
+}
+__name(registerClarityListSnapshots, "registerClarityListSnapshots");
+function parseSnapshotKind2(raw) {
+  const kind = SNAPSHOT_KINDS.find((candidate) => candidate === raw);
+  if (kind === void 0) {
+    throw new CliError(`kind must be one of: ${SNAPSHOT_KINDS.join(", ")}`);
+  }
+  return kind;
+}
+__name(parseSnapshotKind2, "parseSnapshotKind");
+function renderPaginationSummary(response, offset) {
+  if (response.total === void 0) {
+    return `Showing ${response.snapshots.length} \xB7 offset ${offset}`;
+  }
+  return `Showing ${response.snapshots.length} of ${response.total} \xB7 offset ${offset}`;
+}
+__name(renderPaginationSummary, "renderPaginationSummary");
+
 // src/commands/clarity/postprocess.ts
 var SNAPSHOT_TYPES = ["current_process", "transformation_proposal"];
 function registerClarityPostprocess(clarity) {
@@ -21473,9 +21930,9 @@ function registerClarityPostprocess(clarity) {
 __name(registerClarityPostprocess, "registerClarityPostprocess");
 
 // src/commands/clarity/process-labels.ts
-var MIN_LIMIT7 = 1;
-var MAX_LIMIT7 = 100;
-var DEFAULT_LIMIT7 = 50;
+var MIN_LIMIT8 = 1;
+var MAX_LIMIT8 = 100;
+var DEFAULT_LIMIT8 = 50;
 var ORG_FLAG_DESCRIPTION2 = "organization id for the org-scoped process tag palette (overrides DUVO_ORG_ID)";
 var PROCESS_LABELS_RESOURCE_PATH = "/clarity/process-labels";
 var LABELS_WITH_COUNT_COLUMNS = [
@@ -21512,7 +21969,7 @@ function registerClarityProcessLabels(clarity) {
 }
 __name(registerClarityProcessLabels, "registerClarityProcessLabels");
 function registerList(processLabels) {
-  processLabels.command("list", { isDefault: true }).description("List process tags in the current organization").option("--org <org-id>", ORG_FLAG_DESCRIPTION2).option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of tags to skip").option("--search <text>", "only show tags whose value contains this text").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  processLabels.command("list", { isDefault: true }).description("List process tags in the current organization").option("--org <org-id>", ORG_FLAG_DESCRIPTION2).option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of tags to skip").option("--search <text>", "only show tags whose value contains this text").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "GET",
@@ -21610,7 +22067,7 @@ function registerListProcess(processLabels) {
 }
 __name(registerListProcess, "registerListProcess");
 function registerAvailable(processLabels) {
-  processLabels.command("available").description("List tags available to assign to a process").requiredOption("--process <process-id>", "ID of the process").option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of tags to skip").option("--search <text>", "only show tags whose value contains this text").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function availableAction(options) {
+  processLabels.command("available").description("List tags available to assign to a process").requiredOption("--process <process-id>", "ID of the process").option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of tags to skip").option("--search <text>", "only show tags whose value contains this text").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function availableAction(options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "GET",
@@ -21697,9 +22154,9 @@ function buildAssignBody(options) {
 __name(buildAssignBody, "buildAssignBody");
 function buildListSearchParams(options) {
   const limit = parseLimit(options.limit, {
-    defaultValue: DEFAULT_LIMIT7,
-    min: MIN_LIMIT7,
-    max: MAX_LIMIT7
+    defaultValue: DEFAULT_LIMIT8,
+    min: MIN_LIMIT8,
+    max: MAX_LIMIT8
   });
   const offset = parseOffset(options.offset);
   const searchParams = new URLSearchParams({
@@ -21778,40 +22235,40 @@ function renderLabelSummary(label) {
 __name(renderLabelSummary, "renderLabelSummary");
 
 // src/commands/clarity/process-links.ts
-import { z as z99 } from "zod";
-var MIN_LIMIT8 = 1;
-var MAX_LIMIT8 = 500;
-var DEFAULT_LIMIT8 = 100;
+import { z as z100 } from "zod";
+var MIN_LIMIT9 = 1;
+var MAX_LIMIT9 = 500;
+var DEFAULT_LIMIT9 = 100;
 var ORG_FLAG_DESCRIPTION3 = "organization id for the org-scoped process landscape (overrides DUVO_ORG_ID)";
 var PROCESS_LINKS_RESOURCE_PATH = "/clarity/hierarchy/process-links";
-var processLinkTypeSchema = z99.enum([
+var processLinkTypeSchema = z100.enum([
   "hands_off_to",
   "shares_step_with",
   "variant_of"
 ]);
-var processLinkStateSchema = z99.enum(["suggested", "confirmed"]);
-var processLinkSchema = z99.object({
-  id: z99.string(),
-  source_node_id: z99.string(),
-  target_node_id: z99.string(),
+var processLinkStateSchema = z100.enum(["suggested", "confirmed"]);
+var processLinkSchema = z100.object({
+  id: z100.string(),
+  source_node_id: z100.string(),
+  target_node_id: z100.string(),
   type: processLinkTypeSchema,
   state: processLinkStateSchema,
-  confidence: z99.number().nullable(),
-  created_at: z99.string(),
-  updated_at: z99.string()
+  confidence: z100.number().nullable(),
+  created_at: z100.string(),
+  updated_at: z100.string()
 });
-var listProcessLinksResponseSchema = z99.object({
-  process_links: z99.array(processLinkSchema),
-  total: z99.number(),
-  limit: z99.number(),
-  offset: z99.number()
+var listProcessLinksResponseSchema = z100.object({
+  process_links: z100.array(processLinkSchema),
+  total: z100.number(),
+  limit: z100.number(),
+  offset: z100.number()
 });
-var processLinkMutationResponseSchema = z99.object({
+var processLinkMutationResponseSchema = z100.object({
   process_link: processLinkSchema,
-  created: z99.boolean().optional()
+  created: z100.boolean().optional()
 });
-var deleteProcessLinkResponseSchema = z99.object({
-  deleted: z99.boolean()
+var deleteProcessLinkResponseSchema = z100.object({
+  deleted: z100.boolean()
 });
 var PROCESS_LINK_COLUMNS = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
@@ -21834,7 +22291,7 @@ var PROCESS_LINK_COLUMNS = [
 ];
 function registerClarityProcessLinks(clarity) {
   const processLinks = clarity.command("process-links").description("Manage Clarity process links");
-  processLinks.command("list", { isDefault: true }).description("List process links in the current organization").option("--org <org-id>", ORG_FLAG_DESCRIPTION3).option("--node <node-id>", "only show links touching this process node").option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of links to skip").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function listAction(options) {
+  processLinks.command("list", { isDefault: true }).description("List process links in the current organization").option("--org <org-id>", ORG_FLAG_DESCRIPTION3).option("--node <node-id>", "only show links touching this process node").option("--limit <n>", `page size (${MIN_LIMIT9}-${MAX_LIMIT9})`).option("--offset <n>", "number of links to skip").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function listAction(options) {
     const config = await requireAuthenticatedConfig(this);
     const path = await resolveProcessLinksPath(this);
     const response = await listProcessLinks(config, path, options);
@@ -21904,9 +22361,9 @@ function registerClarityProcessLinks(clarity) {
 __name(registerClarityProcessLinks, "registerClarityProcessLinks");
 async function listProcessLinks(config, path, options) {
   const limit = parseLimit(options.limit, {
-    defaultValue: DEFAULT_LIMIT8,
-    min: MIN_LIMIT8,
-    max: MAX_LIMIT8
+    defaultValue: DEFAULT_LIMIT9,
+    min: MIN_LIMIT9,
+    max: MAX_LIMIT9
   });
   const offset = parseOffset(options.offset);
   const searchParams = new URLSearchParams({
@@ -22004,14 +22461,14 @@ function renderProcessLinks(response) {
 __name(renderProcessLinks, "renderProcessLinks");
 
 // src/commands/clarity/promote-current-process.ts
-import { z as z100 } from "zod";
-var snapshotSchema3 = z100.object({
-  snapshot: z100.object({
-    id: z100.string(),
-    status: z100.string(),
-    creator_type: z100.string(),
-    created_at: z100.string(),
-    updated_at: z100.string()
+import { z as z101 } from "zod";
+var snapshotSchema3 = z101.object({
+  snapshot: z101.object({
+    id: z101.string(),
+    status: z101.string(),
+    creator_type: z101.string(),
+    created_at: z101.string(),
+    updated_at: z101.string()
   })
 });
 function registerClarityPromoteCurrentProcess(clarity) {
@@ -22048,14 +22505,14 @@ function registerClarityPromoteCurrentProcess(clarity) {
 __name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
 
 // src/commands/clarity/promote-transformation-proposal.ts
-import { z as z101 } from "zod";
-var snapshotSchema4 = z101.object({
-  snapshot: z101.object({
-    id: z101.string(),
-    status: z101.string(),
-    creator_type: z101.string(),
-    created_at: z101.string(),
-    updated_at: z101.string()
+import { z as z102 } from "zod";
+var snapshotSchema4 = z102.object({
+  snapshot: z102.object({
+    id: z102.string(),
+    status: z102.string(),
+    creator_type: z102.string(),
+    created_at: z102.string(),
+    updated_at: z102.string()
   })
 });
 function registerClarityPromoteTransformationProposal(clarity) {
@@ -22131,8 +22588,8 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import { z as z102 } from "zod";
-var snapshotFileSchema = z102.union([
+import { z as z103 } from "zod";
+var snapshotFileSchema = z103.union([
   saveClarityProcessSnapshotBodySchema.shape.steps,
   saveClarityProcessSnapshotBodySchema.pick({
     steps: true,
@@ -22291,9 +22748,9 @@ function registerClarityStopTransformationProposal(clarity) {
 __name(registerClarityStopTransformationProposal, "registerClarityStopTransformationProposal");
 
 // src/commands/clarity/index.ts
-var DEFAULT_LIMIT9 = 50;
-var MIN_LIMIT9 = 1;
-var MAX_LIMIT9 = 100;
+var DEFAULT_LIMIT10 = 50;
+var MIN_LIMIT10 = 1;
+var MAX_LIMIT10 = 100;
 var CLARITY_V2_REQUIRED_MESSAGE = "This command requires Clarity v2. Use `duvo clarity overview <process-id>` to read legacy v1 context.";
 function registerClarity(program) {
   const clarity = program.command("clarity").description("Manage and read Clarity processes in the Duvo public API");
@@ -22319,6 +22776,7 @@ function registerClarity(program) {
   registerClarityGetTransformationProposal(clarity);
   registerClarityListExtraCaptureRequests(clarity);
   registerClarityProcessSummaries(clarity);
+  registerClarityListSnapshots(clarity);
   registerClarityArtifactChatConversations(clarity);
   registerClarityArtifactChatMessages(clarity);
   registerClaritySendArtifactChatMessage(clarity);
@@ -22344,7 +22802,7 @@ function registerClarity(program) {
 }
 __name(registerClarity, "registerClarity");
 function registerList2(clarity) {
-  clarity.command("list", { isDefault: true }).description("List Clarity processes for the current team").option("--limit <n>", `page size (${MIN_LIMIT9}-${MAX_LIMIT9})`).option("--offset <n>", "number of processes to skip").option("--search <query>", "case-insensitive search across process names").option("--status <status>", "filter by lifecycle status").option(
+  clarity.command("list", { isDefault: true }).description("List Clarity processes for the current team").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of processes to skip").option("--search <query>", "case-insensitive search across process names").option("--status <status>", "filter by lifecycle status").option(
     "--process-version <1|2>",
     "filter by Clarity process schema version"
   ).option("--json", "output JSON").option("--csv", "output CSV").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -22354,7 +22812,7 @@ function registerList2(clarity) {
 }
 __name(registerList2, "registerList");
 function registerSearch(clarity) {
-  clarity.command("search <query>").description("Search Clarity processes by name").option("--limit <n>", `page size (${MIN_LIMIT9}-${MAX_LIMIT9})`).option("--offset <n>", "number of processes to skip").option("--status <status>", "filter by lifecycle status").option(
+  clarity.command("search <query>").description("Search Clarity processes by name").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of processes to skip").option("--status <status>", "filter by lifecycle status").option(
     "--process-version <1|2>",
     "filter by Clarity process schema version"
   ).option("--json", "output JSON").option("--csv", "output CSV").action(/* @__PURE__ */ __name(async function searchAction(query, options) {
@@ -22699,9 +23157,9 @@ function registerExport(clarity) {
 __name(registerExport, "registerExport");
 async function loadProcessList(command, options) {
   const limit = parseLimit(options.limit, {
-    defaultValue: DEFAULT_LIMIT9,
-    min: MIN_LIMIT9,
-    max: MAX_LIMIT9
+    defaultValue: DEFAULT_LIMIT10,
+    min: MIN_LIMIT10,
+    max: MAX_LIMIT10
   });
   const offset = parseOffset(options.offset);
   const version2 = parseProcessVersion(options.processVersion);
@@ -23085,7 +23543,7 @@ function registerConnectionsGet(connections) {
 __name(registerConnectionsGet, "registerConnectionsGet");
 
 // src/commands/connections/list.ts
-var TABLE_COLUMNS21 = [
+var TABLE_COLUMNS22 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -23125,26 +23583,26 @@ function registerConnectionsList(connections) {
       console.log("No connections found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS21, rows));
+    console.log(renderTable(TABLE_COLUMNS22, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z103 } from "zod";
-var toolSchema = z103.object({
-  name: z103.string(),
-  description: z103.string().optional(),
-  input_schema: z103.record(z103.string(), z103.unknown()).optional()
+import { z as z104 } from "zod";
+var toolSchema = z104.object({
+  name: z104.string(),
+  description: z104.string().optional(),
+  input_schema: z104.record(z104.string(), z104.unknown()).optional()
 });
-var probeResponseSchema = z103.object({
-  success: z103.boolean(),
-  tools: z103.array(toolSchema).optional(),
-  error: z103.string().optional()
+var probeResponseSchema = z104.object({
+  success: z104.boolean(),
+  tools: z104.array(toolSchema).optional(),
+  error: z104.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
-var TABLE_COLUMNS22 = [
+var TABLE_COLUMNS23 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
     header: "DESCRIPTION",
@@ -23153,7 +23611,12 @@ var TABLE_COLUMNS22 = [
   }
 ];
 function registerConnectionsProbe(connections) {
-  connections.command("probe").description("Probe an MCP server URL and list its available tools").requiredOption("--url <url>", "MCP server URL to probe").option(
+  connections.command("probe").description(
+    "Probe an MCP server and list its available tools. Use --url for custom MCP servers or --slug for catalog integrations (the backend resolves the URL)."
+  ).option("--url <url>", "MCP server URL to probe (for custom MCP servers)").option(
+    "--slug <slug>",
+    "Catalog integration slug (backend resolves the URL and auth headers)"
+  ).option(
     "--header <KEY=VALUE>",
     "HTTP header to send (repeatable)",
     (value, previous) => [
@@ -23161,14 +23624,13 @@ function registerConnectionsProbe(connections) {
       value
     ]
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function probeAction(options) {
-    const url = options.url.trim();
-    if (url.length === 0) {
-      throw new CliError("--url must not be empty");
+    const url = options.url?.trim();
+    const slug = options.slug?.trim();
+    if (Boolean(url) === Boolean(slug)) {
+      throw new CliError("Provide exactly one of --url or --slug");
     }
-    const body = {
-      server_url: url
-    };
-    if (options.header && options.header.length > 0) {
+    const body = slug ? { integration_slug: slug } : { server_url: url };
+    if (!slug && options.header && options.header.length > 0) {
       body.headers = parseHeaderPairs("--header", options.header);
     }
     const config = await requireAuthenticatedConfig(this);
@@ -23204,7 +23666,7 @@ function registerConnectionsProbe(connections) {
       console.log("No tools found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS22, tools));
+    console.log(renderTable(TABLE_COLUMNS23, tools));
     console.log(
       `Showing ${tools.length} tool${tools.length === 1 ? "" : "s"}`
     );
@@ -23360,48 +23822,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z104 } from "zod";
-var dateLike = z104.string();
-var secretSchema = z104.object({
-  id: z104.string(),
-  team_id: z104.string(),
-  user_id: z104.string().nullable(),
-  name: z104.string(),
-  service_slug: z104.string().nullable(),
-  env_var_keys: z104.array(z104.string()),
-  created_by: z104.string(),
+import { z as z105 } from "zod";
+var dateLike = z105.string();
+var secretSchema = z105.object({
+  id: z105.string(),
+  team_id: z105.string(),
+  user_id: z105.string().nullable(),
+  name: z105.string(),
+  service_slug: z105.string().nullable(),
+  env_var_keys: z105.array(z105.string()),
+  created_by: z105.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z104.array(secretSchema);
+var secretsListResponseSchema = z105.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z104.object({
-  id: z104.string(),
-  user_id: z104.string().nullable(),
-  team_id: z104.string(),
-  domain: z104.string(),
-  username: z104.string().nullable(),
+var browserLoginSchema = z105.object({
+  id: z105.string(),
+  user_id: z105.string().nullable(),
+  team_id: z105.string(),
+  domain: z105.string(),
+  username: z105.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z104.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z104.object({
-  id: z104.string(),
-  user_id: z104.string().nullable(),
-  team_id: z104.string().nullable(),
-  domain: z104.string(),
-  username: z104.string().nullable(),
+var browserLoginsListResponseSchema = z105.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z105.object({
+  id: z105.string(),
+  user_id: z105.string().nullable(),
+  team_id: z105.string().nullable(),
+  domain: z105.string(),
+  username: z105.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z104.array(
+var revisionLoginsListResponseSchema = z105.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z104.array(secretSchema);
-var successResponseSchema2 = z104.object({
-  success: z104.boolean()
+var revisionSecretsListResponseSchema = z105.array(secretSchema);
+var successResponseSchema2 = z105.object({
+  success: z105.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -23595,7 +24057,7 @@ function registerCredentialsGet(credentials) {
 __name(registerCredentialsGet, "registerCredentialsGet");
 
 // src/commands/credentials/list.ts
-var TABLE_COLUMNS23 = [
+var TABLE_COLUMNS24 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -23654,7 +24116,7 @@ function registerCredentialsList(credentials) {
       console.log("No credentials found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS23, rows));
+    console.log(renderTable(TABLE_COLUMNS24, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -23934,7 +24396,7 @@ function registerFilesDownloadUrl(files) {
 __name(registerFilesDownloadUrl, "registerFilesDownloadUrl");
 
 // src/commands/files/list.ts
-var TABLE_COLUMNS24 = [
+var TABLE_COLUMNS25 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -23977,7 +24439,7 @@ function registerFilesList(files) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS24, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS25, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "listAction"));
 }
@@ -24404,7 +24866,7 @@ function registerIntegrationsCustom(integrations) {
 __name(registerIntegrationsCustom, "registerIntegrationsCustom");
 
 // src/commands/integrations/list.ts
-var TABLE_COLUMNS25 = [
+var TABLE_COLUMNS26 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -24446,7 +24908,7 @@ function registerIntegrationsList(integrations) {
       console.log("No integrations found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS25, rows));
+    console.log(renderTable(TABLE_COLUMNS26, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -25289,7 +25751,7 @@ function parseHeaders(raw) {
   return result;
 }
 __name(parseHeaders, "parseHeaders");
-var TABLE_COLUMNS26 = [
+var TABLE_COLUMNS27 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
 ];
@@ -25347,7 +25809,7 @@ function registerOauthMcpProbe(mcp) {
       console.log("No tools advertised by this MCP server.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS26, rows));
+    console.log(renderTable(TABLE_COLUMNS27, rows));
     console.log(`Showing ${rows.length}`);
   }, "probeMcpAction"));
 }
@@ -25429,7 +25891,7 @@ function registerOauth(program) {
 __name(registerOauth, "registerOauth");
 
 // src/commands/plugins/list.ts
-var TABLE_COLUMNS27 = [
+var TABLE_COLUMNS28 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   {
@@ -25463,7 +25925,7 @@ function registerPluginsList(plugins) {
       console.log("No plugins found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS27, parsed.data.plugins));
+    console.log(renderTable(TABLE_COLUMNS28, parsed.data.plugins));
     console.log(`Showing ${parsed.data.plugins.length}`);
   }, "listAction"));
 }
@@ -25738,7 +26200,7 @@ function registerPulseAnswer(pulse) {
 __name(registerPulseAnswer, "registerPulseAnswer");
 
 // src/commands/pulse/connections.ts
-var TABLE_COLUMNS28 = [
+var TABLE_COLUMNS29 = [
   {
     header: "CONNECTION ID",
     cell: /* @__PURE__ */ __name((row) => row.connection_id, "cell")
@@ -25770,7 +26232,7 @@ function registerList4(connections) {
       console.log("No connections attached.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, parsed.data.connections));
+    console.log(renderTable(TABLE_COLUMNS29, parsed.data.connections));
   }, "listAction"));
 }
 __name(registerList4, "registerList");
@@ -26006,10 +26468,10 @@ function registerPulseHtml(pulse) {
 __name(registerPulseHtml, "registerPulseHtml");
 
 // src/commands/pulse/list.ts
-var DEFAULT_LIMIT10 = 20;
-var MIN_LIMIT10 = 1;
-var MAX_LIMIT10 = 100;
-var TABLE_COLUMNS29 = [
+var DEFAULT_LIMIT11 = 20;
+var MIN_LIMIT11 = 1;
+var MAX_LIMIT11 = 100;
+var TABLE_COLUMNS30 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   {
     header: "TITLE",
@@ -26036,11 +26498,11 @@ function registerPulseList(pulse) {
   pulse.command("list", { isDefault: true }).description("List your Pulse dashboards").option(
     "--team",
     "list dashboards a teammate published to your whole team instead of your own"
-  ).option("--shared", "deprecated: always returns no dashboards").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of dashboards to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  ).option("--shared", "deprecated: always returns no dashboards").option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of dashboards to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT10,
-      min: MIN_LIMIT10,
-      max: MAX_LIMIT10
+      defaultValue: DEFAULT_LIMIT11,
+      min: MIN_LIMIT11,
+      max: MAX_LIMIT11
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -26071,7 +26533,7 @@ function registerPulseList(pulse) {
       console.log("No Pulse dashboards found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, response.artifacts));
+    console.log(renderTable(TABLE_COLUMNS30, response.artifacts));
     console.log(
       `Showing ${response.artifacts.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -26080,10 +26542,10 @@ function registerPulseList(pulse) {
 __name(registerPulseList, "registerPulseList");
 
 // src/commands/pulse/messages.ts
-var DEFAULT_LIMIT11 = 100;
-var MIN_LIMIT11 = 1;
-var MAX_LIMIT11 = 500;
-var TABLE_COLUMNS30 = [
+var DEFAULT_LIMIT12 = 100;
+var MIN_LIMIT12 = 1;
+var MAX_LIMIT12 = 500;
+var TABLE_COLUMNS31 = [
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   {
     header: "CONTENT",
@@ -26093,18 +26555,22 @@ var TABLE_COLUMNS30 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at, "cell") }
 ];
 function registerPulseMessages(pulse) {
-  pulse.command("messages <id>").description("List a Pulse dashboard's chat transcript (creator only)").option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of messages to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+  pulse.command("messages <id>").description("List a Pulse dashboard's chat transcript (creator only)").option("--limit <n>", `page size (${MIN_LIMIT12}-${MAX_LIMIT12})`).option(
+    "--before <messageId>",
+    "return the page of messages older than this message id (omit for the most recent page)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
     const pulseId = trimRequired(id, "<id>");
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT11,
-      min: MIN_LIMIT11,
-      max: MAX_LIMIT11
+      defaultValue: DEFAULT_LIMIT12,
+      min: MIN_LIMIT12,
+      max: MAX_LIMIT12
     });
-    const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
-    searchParams.append("offset", String(offset));
+    if (options.before) {
+      searchParams.append("before", trimRequired(options.before, "--before"));
+    }
     const raw = await httpRequest({
       method: "GET",
       path: `/v2/artifacts/${encodeURIComponent(pulseId)}/messages`,
@@ -26122,13 +26588,18 @@ function registerPulseMessages(pulse) {
         `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    const { data, total } = parsed.data;
+    const { data, total, has_more: hasMore } = parsed.data;
     if (data.length === 0) {
       console.log("No messages yet.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS30, data));
-    console.log(`Showing ${data.length} of ${total} \xB7 offset ${offset}`);
+    console.log(renderTable(TABLE_COLUMNS31, data));
+    console.log(`Showing ${data.length} of ${total}`);
+    if (hasMore) {
+      console.log(
+        `Older messages available. Rerun with --before ${data[0]?.id} to load them.`
+      );
+    }
     console.log(
       "Run with --json to see full message payloads, including the tool call id `duvo pulse answer` needs."
     );
@@ -26520,7 +26991,7 @@ function registerPulse(program) {
 __name(registerPulse, "registerPulse");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS31 = [
+var TABLE_COLUMNS32 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -26574,7 +27045,7 @@ function registerList5(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS31, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS32, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
@@ -27325,10 +27796,10 @@ function registerQueuesLinkAgent(queues) {
 __name(registerQueuesLinkAgent, "registerQueuesLinkAgent");
 
 // src/commands/queues/list.ts
-var DEFAULT_LIMIT12 = 20;
-var MIN_LIMIT12 = 1;
-var MAX_LIMIT12 = 100;
-var TABLE_COLUMNS32 = [
+var DEFAULT_LIMIT13 = 20;
+var MIN_LIMIT13 = 1;
+var MAX_LIMIT13 = 100;
+var TABLE_COLUMNS33 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -27339,11 +27810,11 @@ var TABLE_COLUMNS32 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerQueuesList(queues) {
-  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT12}-${MAX_LIMIT12})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT13}-${MAX_LIMIT13})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT12,
-      min: MIN_LIMIT12,
-      max: MAX_LIMIT12
+      defaultValue: DEFAULT_LIMIT13,
+      min: MIN_LIMIT13,
+      max: MAX_LIMIT13
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -27376,7 +27847,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS32, response.queues));
+    console.log(renderTable(TABLE_COLUMNS33, response.queues));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.queues.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.queues.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -27634,7 +28105,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS33 = [
+var TABLE_COLUMNS34 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -27670,7 +28141,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS33, rows));
+    console.log(renderTable(TABLE_COLUMNS34, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -27743,7 +28214,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS34 = [
+var TABLE_COLUMNS35 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -27781,7 +28252,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS34, rows));
+    console.log(renderTable(TABLE_COLUMNS35, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -27797,91 +28268,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z105 } from "zod";
-var publicRunSchema = z105.object({
-  id: z105.string(),
-  agent_id: z105.string(),
-  build_id: z105.string(),
-  status: z105.string(),
-  source: z105.string().nullish(),
-  sandbox_id: z105.string().nullish(),
-  started_at: z105.string().nullish(),
-  completed_at: z105.string().nullish(),
-  created_at: z105.string(),
-  updated_at: z105.string().nullish(),
-  human_in_the_loop_enabled: z105.boolean().nullish()
-});
-var startRunResponseSchema = z105.object({
+import { z as z106 } from "zod";
+var publicRunSchema = z106.object({
+  id: z106.string(),
+  agent_id: z106.string(),
+  build_id: z106.string(),
+  status: z106.string(),
+  source: z106.string().nullish(),
+  sandbox_id: z106.string().nullish(),
+  started_at: z106.string().nullish(),
+  completed_at: z106.string().nullish(),
+  created_at: z106.string(),
+  updated_at: z106.string().nullish(),
+  human_in_the_loop_enabled: z106.boolean().nullish()
+});
+var startRunResponseSchema = z106.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z105.object({
-  label: z105.string(),
-  description: z105.string().nullish()
-});
-var questionSchema = z105.object({
-  question: z105.string(),
-  header: z105.string().nullish(),
-  options: z105.array(questionOptionSchema).nullish(),
-  multi_select: z105.boolean().nullish()
-});
-var pendingHumanRequestSchema = z105.object({
-  id: z105.string(),
-  title: z105.string(),
-  description: z105.string().nullish(),
-  created_at: z105.string(),
-  type: z105.string(),
-  questions: z105.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z105.object({
+var questionOptionSchema = z106.object({
+  label: z106.string(),
+  description: z106.string().nullish()
+});
+var questionSchema = z106.object({
+  question: z106.string(),
+  header: z106.string().nullish(),
+  options: z106.array(questionOptionSchema).nullish(),
+  multi_select: z106.boolean().nullish()
+});
+var pendingHumanRequestSchema = z106.object({
+  id: z106.string(),
+  title: z106.string(),
+  description: z106.string().nullish(),
+  created_at: z106.string(),
+  type: z106.string(),
+  questions: z106.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z106.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z105.object({
-  success: z105.boolean(),
-  message: z105.string().nullish()
-});
-var runMessageSchema = z105.object({
-  id: z105.string(),
-  type: z105.string(),
-  role: z105.string(),
-  timestamp: z105.string(),
-  text_content: z105.string().nullish(),
-  tool_call: z105.object({
-    id: z105.string(),
-    name: z105.string(),
-    arguments: z105.record(z105.string(), z105.unknown()).nullish()
+var stopRunResponseSchema = z106.object({
+  success: z106.boolean(),
+  message: z106.string().nullish()
+});
+var runMessageSchema = z106.object({
+  id: z106.string(),
+  type: z106.string(),
+  role: z106.string(),
+  timestamp: z106.string(),
+  text_content: z106.string().nullish(),
+  tool_call: z106.object({
+    id: z106.string(),
+    name: z106.string(),
+    arguments: z106.record(z106.string(), z106.unknown()).nullish()
   }).nullish(),
-  tool_result: z105.object({
-    tool_call_id: z105.string(),
-    result: z105.unknown().nullish(),
-    error: z105.string().nullish()
+  tool_result: z106.object({
+    tool_call_id: z106.string(),
+    result: z106.unknown().nullish(),
+    error: z106.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z105.object({
-  messages: z105.array(runMessageSchema),
-  total: z105.number().nullish(),
-  limit: z105.number().nullish(),
-  offset: z105.number().nullish()
+var listRunMessagesResponseSchema = z106.object({
+  messages: z106.array(runMessageSchema),
+  total: z106.number().nullish(),
+  limit: z106.number().nullish(),
+  offset: z106.number().nullish()
 });
-var postedMessageSchema = z105.object({
-  id: z105.string(),
-  type: z105.string(),
-  role: z105.string(),
-  timestamp: z105.string(),
-  text_content: z105.string()
+var postedMessageSchema = z106.object({
+  id: z106.string(),
+  type: z106.string(),
+  role: z106.string(),
+  timestamp: z106.string(),
+  text_content: z106.string()
 });
-var postRunMessageResponseSchema = z105.object({
+var postRunMessageResponseSchema = z106.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z105.object({
-  human_request: z105.object({
-    id: z105.string(),
-    run_id: z105.string(),
-    title: z105.string(),
-    description: z105.string().nullish(),
-    response: z105.string().nullish(),
-    responded_at: z105.string().nullish(),
-    created_at: z105.string()
+var respondHumanRequestResponseSchema = z106.object({
+  human_request: z106.object({
+    id: z106.string(),
+    run_id: z106.string(),
+    title: z106.string(),
+    description: z106.string().nullish(),
+    response: z106.string().nullish(),
+    responded_at: z106.string().nullish(),
+    created_at: z106.string()
   })
 });
 
@@ -28026,13 +28497,13 @@ function registerRunsGet(runs) {
 __name(registerRunsGet, "registerRunsGet");
 
 // src/commands/runs/list.ts
-var DEFAULT_LIMIT13 = 20;
-var MIN_LIMIT13 = 1;
-var MAX_LIMIT13 = 100;
+var DEFAULT_LIMIT14 = 20;
+var MIN_LIMIT14 = 1;
+var MAX_LIMIT14 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS35 = [
+var TABLE_COLUMNS36 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "RUN#", cell: /* @__PURE__ */ __name((row) => String(row.run_number), "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -28056,7 +28527,7 @@ function isHasIssuesValue(value) {
 }
 __name(isHasIssuesValue, "isHasIssuesValue");
 function registerRunsList(runs) {
-  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT13}-${MAX_LIMIT13})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
+  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT14}-${MAX_LIMIT14})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
     "--status <status>",
     "filter by status (e.g. running, completed, failed, waiting, interrupted, stopped, needs_attention)"
   ).option("--agent <id>", "filter by agent ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
@@ -28064,9 +28535,9 @@ function registerRunsList(runs) {
     `show only runs with (or without) issues (${HAS_ISSUES_VALUES.join("|")})`
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT13,
-      min: MIN_LIMIT13,
-      max: MAX_LIMIT13
+      defaultValue: DEFAULT_LIMIT14,
+      min: MIN_LIMIT14,
+      max: MAX_LIMIT14
     });
     const offset = parseOffset(options.offset);
     if (options.sortOrder !== void 0 && !isSortOrder(options.sortOrder)) {
@@ -28133,7 +28604,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS35, response.data));
+    console.log(renderTable(TABLE_COLUMNS36, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -28239,11 +28710,11 @@ function getContent(msg) {
 __name(getContent, "getContent");
 
 // src/commands/runs/messages.ts
-var DEFAULT_LIMIT14 = 20;
-var MIN_LIMIT14 = 1;
-var MAX_LIMIT14 = 50;
+var DEFAULT_LIMIT15 = 20;
+var MIN_LIMIT15 = 1;
+var MAX_LIMIT15 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS36 = [
+var TABLE_COLUMNS37 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -28268,7 +28739,7 @@ function previewCell(row) {
 }
 __name(previewCell, "previewCell");
 function registerRunsMessages(runs) {
-  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT14}-${MAX_LIMIT14})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT15}-${MAX_LIMIT15})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     if (options.follow) {
@@ -28279,9 +28750,9 @@ function registerRunsMessages(runs) {
       return;
     }
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT14,
-      min: MIN_LIMIT14,
-      max: MAX_LIMIT14
+      defaultValue: DEFAULT_LIMIT15,
+      min: MIN_LIMIT15,
+      max: MAX_LIMIT15
     });
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
@@ -28308,7 +28779,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS36, response.messages));
+    console.log(renderTable(TABLE_COLUMNS37, response.messages));
     const resolvedOffset = response.offset ?? offset;
     const summary = response.total === null || response.total === void 0 ? `Showing ${response.messages.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.messages.length} of ${response.total} \xB7 offset ${resolvedOffset}`;
     console.log(summary);
@@ -28576,28 +29047,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z106 } from "zod";
-var createSandboxResponseSchema = z106.object({
-  sandbox_id: z106.string(),
-  expires_at: z106.string()
+import { z as z107 } from "zod";
+var createSandboxResponseSchema = z107.object({
+  sandbox_id: z107.string(),
+  expires_at: z107.string()
 });
-var createSandboxUploadUrlResponseSchema = z106.object({
-  upload_url: z106.string(),
-  path: z106.string(),
-  expires_in_seconds: z106.number()
+var createSandboxUploadUrlResponseSchema = z107.object({
+  upload_url: z107.string(),
+  path: z107.string(),
+  expires_in_seconds: z107.number()
 });
-var sandboxFileSchema = z106.object({
-  name: z106.string(),
-  path: z106.string(),
-  type: z106.enum(["file", "dir"]),
-  size_bytes: z106.number()
+var sandboxFileSchema = z107.object({
+  name: z107.string(),
+  path: z107.string(),
+  type: z107.enum(["file", "dir"]),
+  size_bytes: z107.number()
 });
-var listSandboxFilesResponseSchema = z106.object({
-  files: z106.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z107.object({
+  files: z107.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z106.object({
-  path: z106.string(),
-  size_bytes: z106.number()
+var uploadSandboxFileResponseSchema = z107.object({
+  path: z107.string(),
+  size_bytes: z107.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -28634,7 +29105,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS37 = [
+var TABLE_COLUMNS38 = [
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
@@ -28672,7 +29143,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS37, files));
+    console.log(renderTable(TABLE_COLUMNS38, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -29017,7 +29488,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS38 = [
+var TABLE_COLUMNS39 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -29061,7 +29532,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS38, rows));
+    console.log(renderTable(TABLE_COLUMNS39, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -29172,7 +29643,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS39 = [
+var TABLE_COLUMNS40 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -29200,7 +29671,7 @@ function registerSkillsAssignments(skills) {
       console.log("No agents use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS39, assignments));
+    console.log(renderTable(TABLE_COLUMNS40, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -29208,13 +29679,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import { z as z107 } from "zod";
-var createSkillResponseSchema = z107.object({
-  skill: z107.object({
-    id: z107.string(),
-    name: z107.string(),
-    description: z107.string(),
-    team_id: z107.string()
+import { z as z108 } from "zod";
+var createSkillResponseSchema = z108.object({
+  skill: z108.object({
+    id: z108.string(),
+    name: z108.string(),
+    description: z108.string(),
+    team_id: z108.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -29482,7 +29953,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS40 = [
+var TABLE_COLUMNS41 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -29521,7 +29992,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS40, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS41, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -29578,13 +30049,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z108 } from "zod";
-var installSkillResponseSchema = z108.object({
-  skill: z108.object({
-    id: z108.string(),
-    name: z108.string(),
-    description: z108.string(),
-    team_id: z108.string()
+import { z as z109 } from "zod";
+var installSkillResponseSchema = z109.object({
+  skill: z109.object({
+    id: z109.string(),
+    name: z109.string(),
+    description: z109.string(),
+    team_id: z109.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -29774,13 +30245,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile9, stat as stat2 } from "node:fs/promises";
 import { basename as basename3 } from "node:path";
-import { z as z109 } from "zod";
-var uploadSkillResponseSchema = z109.object({
-  skill: z109.object({
-    id: z109.string(),
-    name: z109.string(),
-    description: z109.string(),
-    team_id: z109.string()
+import { z as z110 } from "zod";
+var uploadSkillResponseSchema = z110.object({
+  skill: z110.object({
+    id: z110.string(),
+    name: z110.string(),
+    description: z110.string(),
+    team_id: z110.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -29899,12 +30370,12 @@ function registerSuggestionsConsume(suggestions) {
 __name(registerSuggestionsConsume, "registerSuggestionsConsume");
 
 // src/commands/suggestions/list.ts
-var DEFAULT_LIMIT15 = 100;
-var MIN_LIMIT15 = 1;
-var MAX_LIMIT15 = 250;
+var DEFAULT_LIMIT16 = 100;
+var MIN_LIMIT16 = 1;
+var MAX_LIMIT16 = 250;
 var STATUS_FILTERS = ["pending", "history"];
 var TITLE_PREVIEW_WIDTH2 = 50;
-var TABLE_COLUMNS41 = [
+var TABLE_COLUMNS42 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -29925,11 +30396,11 @@ function registerSuggestionsList(suggestions) {
   ).option(
     "--status <filter>",
     `which inbox to show (${STATUS_FILTERS.join("|")}, default: pending)`
-  ).option("--limit <n>", `page size (${MIN_LIMIT15}-${MAX_LIMIT15})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT16}-${MAX_LIMIT16})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT15,
-      min: MIN_LIMIT15,
-      max: MAX_LIMIT15
+      defaultValue: DEFAULT_LIMIT16,
+      min: MIN_LIMIT16,
+      max: MAX_LIMIT16
     });
     const offset = parseOffset(options.offset);
     if (options.status !== void 0 && !isStatusFilter(options.status)) {
@@ -29967,7 +30438,7 @@ function registerSuggestionsList(suggestions) {
       console.log(`Pending total: ${pendingCount}`);
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS41, data));
+    console.log(renderTable(TABLE_COLUMNS42, data));
     console.log(
       `Showing ${data.length} \xB7 offset ${offset} \xB7 pending total ${pendingCount}`
     );
@@ -30091,10 +30562,10 @@ function registerTeamGet(team) {
 __name(registerTeamGet, "registerTeamGet");
 
 // src/commands/team/members.ts
-var DEFAULT_LIMIT16 = 50;
-var MIN_LIMIT16 = 1;
-var MAX_LIMIT16 = 100;
-var TABLE_COLUMNS42 = [
+var DEFAULT_LIMIT17 = 50;
+var MIN_LIMIT17 = 1;
+var MAX_LIMIT17 = 100;
+var TABLE_COLUMNS43 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name ?? "", "cell") },
   { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
@@ -30108,11 +30579,11 @@ function registerTeamMembers(team) {
   team.command("members").description("List members of a team").option(
     "--team <id>",
     "team ID (defaults to the team scoped to your credentials)"
-  ).option("--limit <n>", `page size (${MIN_LIMIT16}-${MAX_LIMIT16})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT17}-${MAX_LIMIT17})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT16,
-      min: MIN_LIMIT16,
-      max: MAX_LIMIT16
+      defaultValue: DEFAULT_LIMIT17,
+      min: MIN_LIMIT17,
+      max: MAX_LIMIT17
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -30145,7 +30616,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS42, response.members));
+    console.log(renderTable(TABLE_COLUMNS43, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -30154,9 +30625,9 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z110 } from "zod";
+import { z as z111 } from "zod";
 var TEAM_ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var teamIdSchema = z110.string().regex(TEAM_ID_SHAPE);
+var teamIdSchema = z111.string().regex(TEAM_ID_SHAPE);
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
     "Set the default team for the active OAuth profile (overridable per-command via --team or DUVO_TEAM_ID)"
@@ -30242,14 +30713,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z111 } from "zod";
-var teamApiSchema2 = z111.object({
-  id: z111.string(),
-  name: z111.string(),
-  organization_id: z111.string().nullable()
+import { z as z112 } from "zod";
+var teamApiSchema2 = z112.object({
+  id: z112.string(),
+  name: z112.string(),
+  organization_id: z112.string().nullable()
 });
-var listMyTeamsResponseSchema3 = z111.object({
-  teams: z111.array(teamApiSchema2)
+var listMyTeamsResponseSchema3 = z112.object({
+  teams: z112.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) {
@@ -30292,21 +30763,21 @@ function registerTeamsList(teams) {
 __name(registerTeamsList, "registerTeamsList");
 
 // src/commands/teams/org-insights.ts
-import { z as z112 } from "zod";
-var headlineSchema = z112.object({
-  total_runs: z112.number(),
-  completed_runs: z112.number(),
-  failed_runs: z112.number(),
-  success_rate: z112.number().nullable(),
-  active_agents: z112.number(),
-  active_users: z112.number(),
-  start_date: z112.string(),
-  end_date: z112.string(),
-  truncated: z112.boolean(),
-  aggregated_teams: z112.number(),
-  total_teams: z112.number()
-});
-var orgInsightsHeadlineResponseSchema = z112.object({
+import { z as z113 } from "zod";
+var headlineSchema = z113.object({
+  total_runs: z113.number(),
+  completed_runs: z113.number(),
+  failed_runs: z113.number(),
+  success_rate: z113.number().nullable(),
+  active_agents: z113.number(),
+  active_users: z113.number(),
+  start_date: z113.string(),
+  end_date: z113.string(),
+  truncated: z113.boolean(),
+  aggregated_teams: z113.number(),
+  total_teams: z113.number()
+});
+var orgInsightsHeadlineResponseSchema = z113.object({
   headline: headlineSchema
 });
 function formatRate(rate) {
@@ -30374,26 +30845,26 @@ function registerTeamsOrgInsights(teams) {
 __name(registerTeamsOrgInsights, "registerTeamsOrgInsights");
 
 // src/commands/teams/org-metrics.ts
-import { z as z113 } from "zod";
-var teamMetricSchema = z113.object({
-  team_id: z113.string(),
-  team_name: z113.string(),
-  is_deleted: z113.boolean(),
-  member_count: z113.number(),
-  assignment_count: z113.number(),
-  scheduled_job_count: z113.number(),
-  total_jobs: z113.number(),
-  completed_jobs: z113.number(),
-  failed_jobs: z113.number(),
-  total_runs: z113.number()
-});
-var orgInsightsMetricsResponseSchema = z113.object({
-  teams: z113.array(teamMetricSchema),
-  start_date: z113.string(),
-  end_date: z113.string(),
-  truncated: z113.boolean(),
-  total_teams: z113.number(),
-  org_member_count: z113.number()
+import { z as z114 } from "zod";
+var teamMetricSchema = z114.object({
+  team_id: z114.string(),
+  team_name: z114.string(),
+  is_deleted: z114.boolean(),
+  member_count: z114.number(),
+  assignment_count: z114.number(),
+  scheduled_job_count: z114.number(),
+  total_jobs: z114.number(),
+  completed_jobs: z114.number(),
+  failed_jobs: z114.number(),
+  total_runs: z114.number()
+});
+var orgInsightsMetricsResponseSchema = z114.object({
+  teams: z114.array(teamMetricSchema),
+  start_date: z114.string(),
+  end_date: z114.string(),
+  truncated: z114.boolean(),
+  total_teams: z114.number(),
+  org_member_count: z114.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) {
@@ -30456,20 +30927,20 @@ ${total_teams} teams${suffix} \xB7 ${org_member_count} org members`
 __name(registerTeamsOrgMetrics, "registerTeamsOrgMetrics");
 
 // src/commands/teams/org-usage.ts
-import { z as z114 } from "zod";
+import { z as z115 } from "zod";
 var GRANULARITIES = ["day", "week", "month"];
 var DEFAULT_LOOKBACK_MS = 30 * 24 * 60 * 60 * 1e3;
-var bucketSchema = z114.object({
-  period: z114.string(),
-  total_runs: z114.number(),
-  scheduled_runs: z114.number(),
-  on_demand_runs: z114.number()
-});
-var usageChartResponseSchema = z114.object({
-  buckets: z114.array(bucketSchema),
-  granularity: z114.enum(GRANULARITIES),
-  truncated: z114.boolean(),
-  total_teams: z114.number()
+var bucketSchema = z115.object({
+  period: z115.string(),
+  total_runs: z115.number(),
+  scheduled_runs: z115.number(),
+  on_demand_runs: z115.number()
+});
+var usageChartResponseSchema = z115.object({
+  buckets: z115.array(bucketSchema),
+  granularity: z115.enum(GRANULARITIES),
+  truncated: z115.boolean(),
+  total_teams: z115.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(
@@ -30528,17 +30999,17 @@ function registerTeamsOrgUsage(teams) {
 __name(registerTeamsOrgUsage, "registerTeamsOrgUsage");
 
 // src/commands/teams/org.ts
-import { z as z115 } from "zod";
-var orgTeamSchema = z115.object({
-  id: z115.string(),
-  name: z115.string(),
-  userIsMember: z115.boolean(),
-  userRole: z115.string().nullable(),
-  memberCount: z115.number()
-});
-var listOrgTeamsResponseSchema = z115.object({
-  teams: z115.array(orgTeamSchema),
-  total: z115.number()
+import { z as z116 } from "zod";
+var orgTeamSchema = z116.object({
+  id: z116.string(),
+  name: z116.string(),
+  userIsMember: z116.boolean(),
+  userRole: z116.string().nullable(),
+  memberCount: z116.number()
+});
+var listOrgTeamsResponseSchema = z116.object({
+  teams: z116.array(orgTeamSchema),
+  total: z116.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) {
@@ -30643,7 +31114,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.21.0";
+    return "1.24.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -30661,6 +31132,11 @@ function createProgram() {
   ).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",
@@ -30709,25 +31185,130 @@ function createProgram() {
 __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 updateNotifier from "update-notifier";
+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 pkg = loadPackageMeta();
-    const notifier = updateNotifier({
-      pkg,
-      updateCheckInterval: ONE_DAY_MS,
-      shouldNotifyInNpmScript: false
+    const latestVersion = await fetchLatestVersion(pkg.name);
+    await writeCache({ lastCheckedAtMs: Date.now(), latestVersion });
+  } catch {
+    await writeCache({
+      lastCheckedAtMs: Date.now(),
+      latestVersion: previous?.latestVersion ?? pkg.version
     });
-    notifier.notify({ defer: false, isGlobal: true });
+  }
+}
+__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(checkForUpdate, "checkForUpdate");
+__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.21.0" };
+    return { name: "@duvoai/cli", version: "1.24.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");
@@ -30740,7 +31321,7 @@ function loadPackageMeta() {
 __name(loadPackageMeta, "loadPackageMeta");
 
 // src/bin/duvo.ts
-checkForUpdate();
+void checkForUpdate();
 createProgram().parseAsync(process.argv).catch((error) => {
   handleCliError(error);
 });