@duvoai/cli 1.3.0 → 1.4.0

package/dist/bin/duvo.js

@@ -99,6 +99,7 @@ import { z as z61 } from "zod";
 import { z as z62 } from "zod";
 import { z as z63 } from "zod";
 import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -1659,7 +1660,8 @@ var evalSummarySchema = z8.object({
 });
 var evalFlagCountSchema = z8.object({
   flag: z8.string(),
-  count: z8.int()
+  count: z8.int(),
+  label: z8.string().nullable().optional()
 });
 var evalScoresResponseSchema = z8.object({
   total_evaluated: z8.int(),
@@ -1674,7 +1676,9 @@ var evalCountsByAgentResponseSchema = z8.object({
   by_agent: z8.record(z8.string(), evalCountsSchema)
 });
 var summarizeEvalScoresBodySchema = z8.object({
-  since: z8.iso.datetime()
+  since: z8.iso.datetime(),
+  /** `"custom"` restricts to live-build runs + `custom__*` flags only. */
+  scope: z8.enum(["all", "custom"]).optional()
 });
 var summarizeEvalScoresResponseSchema = z8.object({
   data: z8.object({
@@ -1714,6 +1718,7 @@ var AGENT_RUN_SOURCES = [
   "handover",
   "postpone",
   "delegate",
+  "reprocess",
   "trigger"
 ];
 var agentRunSourceSchema = z9.enum(AGENT_RUN_SOURCES);
@@ -1746,6 +1751,7 @@ var SOURCE_TO_INITIATOR = {
   handover: "handover",
   postpone: "case-queue",
   delegate: "case-queue",
+  reprocess: "case-queue",
   trigger: "trigger"
 };
 function mapSourceToInitiator(source) {
@@ -2044,24 +2050,6 @@ var BUILD_STATUS = {
   LIVE: "live",
   HISTORIC: "historic"
 };
-var CASE_QUEUE_ITEM_STATUS = {
-  PENDING: "pending",
-  CLAIMED: "claimed",
-  COMPLETED: "completed",
-  FAILED: "failed"
-};
-var RETRYABLE_CASE_STATUSES = [
-  CASE_QUEUE_ITEM_STATUS.COMPLETED,
-  CASE_QUEUE_ITEM_STATUS.FAILED,
-  CASE_QUEUE_ITEM_STATUS.CLAIMED
-];
-function isRetryableCaseStatus(status) {
-  return RETRYABLE_CASE_STATUSES.includes(
-    status
-  );
-}
-__name(isRetryableCaseStatus, "isRetryableCaseStatus");
-__name2(isRetryableCaseStatus, "isRetryableCaseStatus");
 var ALL_EVALUATION_RUBRIC_SEVERITIES = [
   "critical",
   "medium",
@@ -2339,6 +2327,7 @@ var ALL_EVALUATION_RUBRIC_KEYS = Object.keys(
 var PLATFORM_DEFAULT_EVAL_RUBRIC_KEYS = ALL_EVALUATION_RUBRIC_KEYS.filter(
   (k) => EVALUATION_RUBRIC_CATALOG[k].is_default
 );
+var EVALUATION_FINAL_COMMENT_KEY = "final_comment";
 var EVALUATION_SEVERITY_KEY_SUFFIX = "_severity";
 var EVALUATION_REASON_KEY_SUFFIX = "_reason";
 function getRubricSeverityKey(key) {
@@ -2361,6 +2350,23 @@ function isEvaluationRubricKey(value) {
 }
 __name(isEvaluationRubricKey, "isEvaluationRubricKey");
 __name2(isEvaluationRubricKey, "isEvaluationRubricKey");
+var CUSTOM_RUBRIC_KEY_PREFIX = "custom__";
+function isCustomRubricKey(key) {
+  return key.startsWith(CUSTOM_RUBRIC_KEY_PREFIX);
+}
+__name(isCustomRubricKey, "isCustomRubricKey");
+__name2(isCustomRubricKey, "isCustomRubricKey");
+function isFailingFlag(key, value) {
+  if (key === EVALUATION_FINAL_COMMENT_KEY) {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    return false;
+  }
+  return isCustomRubricKey(key) ? !value : value;
+}
+__name(isFailingFlag, "isFailingFlag");
+__name2(isFailingFlag, "isFailingFlag");
 var EVALUATION_RUBRIC_KEYS_BY_CAUSE = (() => {
   const mutable = {
     sop_gap: [],
@@ -2664,12 +2670,17 @@ var clarityProcessVersionSchema = z12.union([
   z12.literal(1),
   z12.literal(2)
 ]);
+var CLARITY_PROCESS_VISIBILITIES = ["team", "restricted"];
+var clarityProcessVisibilitySchema = z12.enum(
+  CLARITY_PROCESS_VISIBILITIES
+);
 var clarityProcessSchema = z12.object({
   id: z12.guid(),
   teamId: z12.guid(),
   userId: z12.guid(),
   name: z12.string(),
   status: clarityProcessStatusSchema,
+  visibility: clarityProcessVisibilitySchema,
   /** 1 = legacy, 2 = v2. */
   version: z12.number().int(),
   analysis: clarityAnalysisResponseSchema.nullable(),
@@ -2684,6 +2695,7 @@ var clarityProcessListItemSchema = z12.object({
   teamName: z12.string().optional(),
   name: z12.string(),
   status: clarityProcessStatusSchema,
+  visibility: clarityProcessVisibilitySchema,
   version: z12.number().int(),
   captureCount: z12.number(),
   captureCounts: z12.object({
@@ -2757,7 +2769,8 @@ var createClarityProcessResponseSchema = z12.object({
 });
 var updateClarityProcessSchema = z12.object({
   name: z12.string().min(1).max(255).optional(),
-  customPrompt: z12.string().max(5e3).nullable().optional()
+  customPrompt: z12.string().max(5e3).nullable().optional(),
+  visibility: clarityProcessVisibilitySchema.optional()
 });
 var INTERVIEW_LANGUAGES = [
   "en",
@@ -3510,6 +3523,9 @@ var clarityV2ProcessReadModelSchema = z15.object({
     user_id: z15.guid().describe("Creator user id"),
     name: z15.string().describe("Process name"),
     status: clarityProcessStatusSchema.describe("Lifecycle status"),
+    visibility: clarityProcessVisibilitySchema.describe(
+      "Process visibility. 'team' is workspace-visible to full members; 'restricted' is visible to the creator, org admins, workspace managers/admins, and accepted grant holders."
+    ),
     version: z15.number().int().describe("Schema version (always 2 here)"),
     generation_error: z15.string().nullable().describe("Error message from the most recent failed generation, if any"),
     generation_progress: generationProgressSchema.nullable().describe(
@@ -3660,6 +3676,31 @@ function getClarityProcessRoomName(processId) {
 }
 __name(getClarityProcessRoomName, "getClarityProcessRoomName");
 __name2(getClarityProcessRoomName, "getClarityProcessRoomName");
+var clarityExportStatusSchema = z17.enum([
+  "queued",
+  "running",
+  "succeeded",
+  "failed"
+]);
+var clarityExportResultSchema = z17.object({
+  diagramId: z17.string().optional(),
+  diagramName: z17.string().optional(),
+  folderId: z17.string().optional()
+});
+var clarityExportBaseSchema = z17.object({
+  processId: z17.guid(),
+  exportRunId: z17.guid()
+});
+var clarityExportProgressEventDataSchema = clarityExportBaseSchema.extend({
+  status: clarityExportStatusSchema,
+  label: z17.string().optional()
+});
+var clarityExportCompletedEventDataSchema = clarityExportBaseSchema.extend({
+  result: clarityExportResultSchema
+});
+var clarityExportFailedEventDataSchema = clarityExportBaseSchema.extend({
+  error: z17.string()
+});
 var clarityProcessChatConversationStatusSchema = z18.enum([
   "open",
   "running",
@@ -4041,6 +4082,138 @@ function makeSentryReporter(sentry) {
 }
 __name(makeSentryReporter, "makeSentryReporter");
 __name2(makeSentryReporter, "makeSentryReporter");
+var MAX_BLOCKED_DOMAINS = 1e3;
+var MAX_GUARDRAILS_TEXT_LENGTH = 2e4;
+var DOMAIN_LABEL = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+function stripToHost(value) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//.test(value)) {
+    try {
+      return new URL(value).hostname;
+    } catch {
+      return value;
+    }
+  }
+  const pathStart = ["/", "?", "#"].reduce((idx, ch) => {
+    const at = value.indexOf(ch);
+    return at !== -1 && (idx === -1 || at < idx) ? at : idx;
+  }, -1);
+  const withoutPath = pathStart === -1 ? value : value.slice(0, pathStart);
+  const portStart = withoutPath.indexOf(":");
+  return portStart === -1 ? withoutPath : withoutPath.slice(0, portStart);
+}
+__name(stripToHost, "stripToHost");
+__name2(stripToHost, "stripToHost");
+function normalizeBlockedDomain(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "Empty line" };
+  }
+  const host = stripToHost(trimmed);
+  if (host.includes("*")) {
+    return {
+      ok: false,
+      reason: "Wildcards are not needed \u2014 entering `acme.com` blocks acme.com and all subdomains"
+    };
+  }
+  const normalized = host.replace(/\.$/, "");
+  const wwwStripped = normalized.startsWith("www.") ? normalized.slice(4) : normalized;
+  const candidate = wwwStripped.includes(".") ? wwwStripped : normalized;
+  if (!candidate.includes(".")) {
+    return {
+      ok: false,
+      reason: "Not a valid domain \u2014 must contain at least one dot"
+    };
+  }
+  const labels = candidate.split(".");
+  for (const label of labels) {
+    if (!DOMAIN_LABEL.test(label)) {
+      return {
+        ok: false,
+        reason: `"${label}" is not a valid domain label`
+      };
+    }
+  }
+  return { ok: true, value: candidate };
+}
+__name(normalizeBlockedDomain, "normalizeBlockedDomain");
+__name2(normalizeBlockedDomain, "normalizeBlockedDomain");
+function parseBlockedDomainsList(text3) {
+  const seen = /* @__PURE__ */ new Set();
+  const domains = [];
+  const errors = [];
+  const lines = text3.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const raw = lines[i];
+    if (raw.trim().length === 0) {
+      continue;
+    }
+    const result = normalizeBlockedDomain(raw);
+    if (!result.ok) {
+      errors.push({ line: i + 1, input: raw, reason: result.reason });
+      continue;
+    }
+    if (seen.has(result.value)) {
+      continue;
+    }
+    seen.add(result.value);
+    domains.push(result.value);
+  }
+  return { domains, errors };
+}
+__name(parseBlockedDomainsList, "parseBlockedDomainsList");
+__name2(parseBlockedDomainsList, "parseBlockedDomainsList");
+function domainToCdpBlockPatterns(domain) {
+  return [
+    `*://${domain}/*`,
+    `*://${domain}:*/*`,
+    `*://${domain}./*`,
+    `*://${domain}.:*/*`,
+    `*://*.${domain}/*`,
+    `*://*.${domain}:*/*`,
+    `*://*.${domain}./*`,
+    `*://*.${domain}.:*/*`
+  ];
+}
+__name(domainToCdpBlockPatterns, "domainToCdpBlockPatterns");
+__name2(domainToCdpBlockPatterns, "domainToCdpBlockPatterns");
+function blockedDomainsToCdpPatterns(domains) {
+  return domains.flatMap(domainToCdpBlockPatterns);
+}
+__name(blockedDomainsToCdpPatterns, "blockedDomainsToCdpPatterns");
+__name2(blockedDomainsToCdpPatterns, "blockedDomainsToCdpPatterns");
+function isUrlBlocked(url, blockedDomains) {
+  if (blockedDomains.length === 0) {
+    return { blocked: false };
+  }
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return { blocked: false };
+  }
+  for (const domain of blockedDomains) {
+    if (host === domain || host.endsWith(`.${domain}`)) {
+      return { blocked: true, matchedDomain: domain, host };
+    }
+  }
+  return { blocked: false };
+}
+__name(isUrlBlocked, "isUrlBlocked");
+__name2(isUrlBlocked, "isUrlBlocked");
+function blockedDomainAgentErrorMessage(args) {
+  const { host, matchedDomain } = args;
+  const domainLine = host === matchedDomain ? `"${host}" is on this team's browser blocklist` : `"${host}" matches the blocklist entry "${matchedDomain}" (subdomain match)`;
+  return [
+    `A team admin has restricted access to this domain: ${domainLine}, so it cannot be accessed.`,
+    "",
+    "What to do:",
+    "- Check that you're using the correct URLs in your SOP \u2014 you may be pointing at the wrong site or have a typo in the domain.",
+    `- If you genuinely need this domain, contact your team admin to update Team Settings \u2192 Guardrails (currently blocks "${matchedDomain}").`,
+    "- Do NOT attempt to bypass this restriction by reformatting the URL, using a proxy, or other workarounds \u2014 the request will continue to fail."
+  ].join("\n");
+}
+__name(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
+__name2(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
 var ORG_ROLE = {
   EXECUTIVE: "organization:executive",
   OWNER: "organization:owner",
@@ -5873,6 +6046,7 @@ var caseQueueItemEventSchema = z43.object({
   agent_run_id: z43.guid().nullable(),
   human_request_id: z43.guid().nullable(),
   type: z43.string(),
+  reason: z43.string().nullable(),
   created_at: z43.string(),
   agent_id: z43.guid().nullable(),
   agent_name: z43.string().nullable(),
@@ -6006,13 +6180,22 @@ var caseBulkDeleteResponseSchema = z43.object({
   deletedCount: z43.number(),
   interruptedRunIds: z43.array(z43.guid())
 });
-var caseBulkRetryResponseSchema = z43.object({
-  retriedCount: z43.number(),
-  skippedCount: z43.number()
-});
-var caseBulkDelegateResponseSchema = z43.object({
-  delegatedCount: z43.number(),
-  skippedCount: z43.number()
+var caseBulkReprocessResponseSchema = z43.object({
+  reprocessedCount: z43.number(),
+  skippedCount: z43.number(),
+  // Deprecated aliases of `reprocessedCount`, both equal to it. Returned so
+  // clients 308-redirected here from the deprecated `bulk-delegate` /
+  // `bulk-retry` endpoints still find their original field. Optional +
+  // `deprecated` so consumers don't couple to them; removed with those aliases
+  // at the 2026-06-10 sunset.
+  delegatedCount: z43.number().meta({
+    deprecated: true,
+    description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-delegate. Removed on 2026-06-10."
+  }).optional(),
+  retriedCount: z43.number().meta({
+    deprecated: true,
+    description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-retry. Removed on 2026-06-10."
+  }).optional()
 });
 var caseBulkStatusUpdateResponseSchema = z43.object({
   updatedCount: z43.number(),
@@ -6401,9 +6584,6 @@ var acceptJoinLinkResponseSchema = z45.object({
 var createClarityProcessInviteLinkRequestSchema = z46.object({
   frontendUrl: z46.url()
 });
-var getClarityProcessInviteLinkQuerySchema = z46.object({
-  frontendUrl: z46.url()
-});
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
 var getClarityProcessInviteLinkResponseSchema = z46.object({
   hasLink: z46.boolean(),
@@ -7358,7 +7538,14 @@ var RunConfigSchema = AgentConfigSchema.extend({
   conversationHistory: z57.array(ThreadContextMessageSchema).optional(),
   chatFiles: z57.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z57.string().optional()
+  timezone: z57.string().optional(),
+  /**
+   * ISO 8601 timestamp captured when the run was created. Frozen at
+   * run-creation time and never recomputed, so resumes reuse the same value —
+   * the runtime injects it into the cached system prompt and a changing value
+   * would bust the prompt cache.
+   */
+  sessionStartedAt: z57.string().optional()
 });
 var StoredRunConfigV0Schema = z57.object({
   version: z57.literal("v0")
@@ -7633,73 +7820,101 @@ var teamInsightsUsersResponseSchema = z61.object({
   data: z61.array(teamInsightsUserWithAgentsAndRunsSchema),
   total: z61.number()
 });
-var userDismissalListResponseSchema = z62.object({
-  data: z62.array(z62.string())
+var guardrailsAuthorSchema = z62.object({
+  id: z62.guid(),
+  name: z62.string().nullable(),
+  email: z62.email()
+});
+var guardrailsRevisionSchema = z62.object({
+  id: z62.guid(),
+  teamId: z62.guid(),
+  guardrailsText: z62.string().nullable(),
+  blockedDomains: z62.array(z62.string()),
+  createdAt: z62.string(),
+  createdBy: guardrailsAuthorSchema
+});
+var getTeamGuardrailsResponseSchema = z62.object({
+  current: guardrailsRevisionSchema.nullable()
+});
+var listTeamGuardrailsRevisionsQuerySchema = z62.object({
+  limit: z62.coerce.number().int().min(1).max(100).default(20),
+  offset: z62.coerce.number().int().min(0).default(0)
+});
+var listTeamGuardrailsRevisionsResponseSchema = z62.object({
+  revisions: z62.array(guardrailsRevisionSchema),
+  total: z62.number().int().nonnegative()
+});
+var createTeamGuardrailsRevisionRequestSchema = z62.object({
+  guardrailsText: z62.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z62.array(z62.string()).max(MAX_BLOCKED_DOMAINS)
+});
+var userDismissalListResponseSchema = z63.object({
+  data: z63.array(z63.string())
 });
-var userDismissalMutationSchema = z62.object({
-  elementKey: z62.string()
+var userDismissalMutationSchema = z63.object({
+  elementKey: z63.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z63.object({
-  id: z63.guid(),
-  name: z63.string(),
-  server: z63.string(),
-  username: z63.string(),
-  enabled: z63.boolean(),
-  passwordSet: z63.boolean(),
-  organizationCount: z63.number().int().nonnegative(),
-  createdAt: z63.string(),
-  updatedAt: z63.string()
-});
-var vpnProxyConfigListResponseSchema = z63.object({
-  configs: z63.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z63.object({
-  name: z63.string().trim().min(1).max(NAME_MAX),
-  server: z63.string().trim().min(1).max(URL_MAX).url(),
-  username: z63.string().trim().min(1).max(USERNAME_MAX),
-  password: z63.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z63.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z63.object({
+var vpnProxyConfigSummarySchema = z64.object({
+  id: z64.guid(),
+  name: z64.string(),
+  server: z64.string(),
+  username: z64.string(),
+  enabled: z64.boolean(),
+  passwordSet: z64.boolean(),
+  organizationCount: z64.number().int().nonnegative(),
+  createdAt: z64.string(),
+  updatedAt: z64.string()
+});
+var vpnProxyConfigListResponseSchema = z64.object({
+  configs: z64.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z64.object({
+  name: z64.string().trim().min(1).max(NAME_MAX),
+  server: z64.string().trim().min(1).max(URL_MAX).url(),
+  username: z64.string().trim().min(1).max(USERNAME_MAX),
+  password: z64.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z64.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z63.object({
-  name: z63.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z63.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z63.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z63.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z63.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z64.object({
+  name: z64.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z64.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z64.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z64.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z64.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z63.object({
+var vpnProxyConfigUpdateResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z63.object({
-  success: z63.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z64.object({
+  success: z64.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z63.object({
-  id: z63.guid(),
-  organizationId: z63.guid(),
-  organizationName: z63.string(),
-  attachedAt: z63.string()
+var vpnProxyConfigOrganizationSchema = z64.object({
+  id: z64.guid(),
+  organizationId: z64.guid(),
+  organizationName: z64.string(),
+  attachedAt: z64.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z63.object({
-  organizations: z63.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z64.object({
+  organizations: z64.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z63.object({
-  organizationId: z63.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z64.object({
+  organizationId: z64.guid()
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z63.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z64.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z63.object({
-  success: z63.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z64.object({
+  success: z64.literal(true)
 });
-var vpnProxyConfigForOrganizationResponseSchema = z63.object({
+var vpnProxyConfigForOrganizationResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema.nullable()
 });
 function canonicalizeSopInput(config) {
@@ -7720,7 +7935,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z64.enum([
+var caseFilterStatusSchema = z65.enum([
   "pending",
   "claimed",
   "completed",
@@ -7728,19 +7943,19 @@ var caseFilterStatusSchema = z64.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z64.object({
-  status: z64.array(caseFilterStatusSchema).optional(),
-  created_at_from: z64.string().optional(),
-  updated_at_from: z64.string().optional(),
-  labels: z64.record(z64.string(), z64.array(z64.string())).optional()
+var casesFiltersSchema = z65.object({
+  status: z65.array(caseFilterStatusSchema).optional(),
+  created_at_from: z65.string().optional(),
+  updated_at_from: z65.string().optional(),
+  labels: z65.record(z65.string(), z65.array(z65.string())).optional()
 });
-var casesListRequestBodySchema = z64.object({
+var casesListRequestBodySchema = z65.object({
   filters: casesFiltersSchema.default({}),
-  limit: z64.int().min(1).max(100).default(25),
-  offset: z64.int().min(0).default(0),
-  sort_by: z64.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z64.enum(["asc", "desc"]).default("desc"),
-  search: z64.string().optional()
+  limit: z65.int().min(1).max(100).default(25),
+  offset: z65.int().min(0).default(0),
+  sort_by: z65.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z65.enum(["asc", "desc"]).default("desc"),
+  search: z65.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -7835,7 +8050,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z64.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z65.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -8975,11 +9190,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z65 } from "zod";
-var optionalEnvString = z65.string().optional().transform(
+import { z as z66 } from "zod";
+var optionalEnvString = z66.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z65.object({
+var CliEnvSchema = z66.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -9475,9 +9690,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z66 } from "zod";
-var teamSchema = z66.object({ id: z66.string() });
-var listMyTeamsResponseSchema = z66.object({ teams: z66.array(teamSchema) });
+import { z as z67 } from "zod";
+var teamSchema = z67.object({ id: z67.string() });
+var listMyTeamsResponseSchema = z67.object({ teams: z67.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -10268,56 +10483,56 @@ import { readFile as readFile2 } from "node:fs/promises";
 import { confirm as confirm2, isCancel as isCancel2, text } from "@clack/prompts";
 
 // src/api/agent-schemas.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 
 // src/api/json-value.ts
-import { z as z67 } from "zod";
-var jsonValueSchema = z67.lazy(
-  () => z67.union([
-    z67.string(),
-    z67.number(),
-    z67.boolean(),
-    z67.null(),
-    z67.array(jsonValueSchema),
-    z67.record(z67.string(), jsonValueSchema)
+import { z as z68 } from "zod";
+var jsonValueSchema = z68.lazy(
+  () => z68.union([
+    z68.string(),
+    z68.number(),
+    z68.boolean(),
+    z68.null(),
+    z68.array(jsonValueSchema),
+    z68.record(z68.string(), jsonValueSchema)
   ])
 );
 
 // src/api/agent-schemas.ts
-var publicAgentSchema = z68.object({
-  id: z68.string(),
-  name: z68.string(),
-  slack_enabled: z68.boolean().nullish(),
-  microsoft_teams_enabled: z68.boolean().nullish(),
-  agentic_memory_enabled: z68.boolean().nullish(),
-  thread_id: z68.string().nullish(),
-  created_at: z68.string().nullish(),
-  updated_at: z68.string().nullish(),
-  latest_build: z68.object({ config: jsonValueSchema.nullish() }).nullish()
-});
-var publicBuildSchema = z68.object({
-  id: z68.string(),
-  agent_id: z68.string(),
-  name: z68.string(),
-  revision_number: z68.number().nullish(),
-  created_at: z68.string().nullish(),
-  updated_at: z68.string().nullish()
-});
-var listAgentsResponseSchema = z68.object({
-  agents: z68.array(publicAgentSchema),
-  total: z68.number().nullish(),
-  limit: z68.number().nullish(),
-  offset: z68.number().nullish()
-});
-var getAgentResponseSchema = z68.object({
+var publicAgentSchema = z69.object({
+  id: z69.string(),
+  name: z69.string(),
+  slack_enabled: z69.boolean().nullish(),
+  microsoft_teams_enabled: z69.boolean().nullish(),
+  agentic_memory_enabled: z69.boolean().nullish(),
+  thread_id: z69.string().nullish(),
+  created_at: z69.string().nullish(),
+  updated_at: z69.string().nullish(),
+  latest_build: z69.object({ config: jsonValueSchema.nullish() }).nullish()
+});
+var publicBuildSchema = z69.object({
+  id: z69.string(),
+  agent_id: z69.string(),
+  name: z69.string(),
+  revision_number: z69.number().nullish(),
+  created_at: z69.string().nullish(),
+  updated_at: z69.string().nullish()
+});
+var listAgentsResponseSchema = z69.object({
+  agents: z69.array(publicAgentSchema),
+  total: z69.number().nullish(),
+  limit: z69.number().nullish(),
+  offset: z69.number().nullish()
+});
+var getAgentResponseSchema = z69.object({
   agent: publicAgentSchema
 });
-var createAgentResponseSchema = z68.object({
+var createAgentResponseSchema = z69.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z68.object({
-  success: z68.literal(true)
+var deleteAgentResponseSchema = z69.object({
+  success: z69.literal(true)
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -10626,29 +10841,29 @@ function registerAgentsDelete(agents) {
 __name(registerAgentsDelete, "registerAgentsDelete");
 
 // src/api/build-schemas.ts
-import { z as z69 } from "zod";
-var publicBuildSchema2 = z69.object({
-  id: z69.string(),
-  agent_id: z69.string(),
-  name: z69.string(),
-  status: z69.string().nullish(),
+import { z as z70 } from "zod";
+var publicBuildSchema2 = z70.object({
+  id: z70.string(),
+  agent_id: z70.string(),
+  name: z70.string(),
+  status: z70.string().nullish(),
   config: jsonValueSchema.nullish(),
-  revision_number: z69.number().nullish(),
-  created_at: z69.string().nullish(),
-  updated_at: z69.string().nullish()
+  revision_number: z70.number().nullish(),
+  created_at: z70.string().nullish(),
+  updated_at: z70.string().nullish()
 });
-var listBuildsResponseSchema2 = z69.object({
-  builds: z69.array(publicBuildSchema2),
-  total: z69.number().nullish(),
-  limit: z69.number().nullish(),
-  offset: z69.number().nullish()
+var listBuildsResponseSchema2 = z70.object({
+  builds: z70.array(publicBuildSchema2),
+  total: z70.number().nullish(),
+  limit: z70.number().nullish(),
+  offset: z70.number().nullish()
 });
-var getBuildResponseSchema = z69.object({
+var getBuildResponseSchema = z70.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z69.object({
+var createBuildResponseSchema = z70.object({
   build: publicBuildSchema2,
-  agent: z69.object({ id: z69.string() })
+  agent: z70.object({ id: z70.string() })
 });
 
 // src/commands/agents/get.ts
@@ -10898,30 +11113,30 @@ function registerAgentsModels(agents) {
 __name(registerAgentsModels, "registerAgentsModels");
 
 // src/api/schedule-schemas.ts
-import { z as z70 } from "zod";
-var publicScheduleSchema = z70.object({
-  id: z70.string(),
-  build_id: z70.string(),
-  agent_id: z70.string(),
-  user_id: z70.string(),
-  enabled: z70.boolean(),
-  frequency: z70.string(),
-  time: z70.string().nullish(),
-  timezone: z70.string(),
-  day: z70.string().nullish(),
-  day_of_month: z70.number().nullish(),
-  cron: z70.string().nullish(),
-  source: z70.string().nullish(),
-  task: z70.string().nullish(),
-  recurring: z70.boolean().nullish(),
-  created_at: z70.string(),
-  updated_at: z70.string()
-});
-var listSchedulesResponseSchema = z70.object({
-  schedules: z70.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z70.object({
-  success: z70.literal(true)
+import { z as z71 } from "zod";
+var publicScheduleSchema = z71.object({
+  id: z71.string(),
+  build_id: z71.string(),
+  agent_id: z71.string(),
+  user_id: z71.string(),
+  enabled: z71.boolean(),
+  frequency: z71.string(),
+  time: z71.string().nullish(),
+  timezone: z71.string(),
+  day: z71.string().nullish(),
+  day_of_month: z71.number().nullish(),
+  cron: z71.string().nullish(),
+  source: z71.string().nullish(),
+  task: z71.string().nullish(),
+  recurring: z71.boolean().nullish(),
+  created_at: z71.string(),
+  updated_at: z71.string()
+});
+var listSchedulesResponseSchema = z71.object({
+  schedules: z71.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z71.object({
+  success: z71.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -11369,33 +11584,33 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z71 } from "zod";
-var triggerSchema = z71.object({
-  id: z71.string(),
-  agent_id: z71.string(),
-  user_id: z71.string(),
-  integration_slug: z71.string(),
-  trigger_type: z71.string(),
-  filter_config: z71.record(z71.string(), z71.unknown()),
-  integration_instance_id: z71.string(),
-  enabled: z71.boolean(),
-  created_at: z71.string(),
-  updated_at: z71.string()
+import { z as z72 } from "zod";
+var triggerSchema = z72.object({
+  id: z72.string(),
+  agent_id: z72.string(),
+  user_id: z72.string(),
+  integration_slug: z72.string(),
+  trigger_type: z72.string(),
+  filter_config: z72.record(z72.string(), z72.unknown()),
+  integration_instance_id: z72.string(),
+  enabled: z72.boolean(),
+  created_at: z72.string(),
+  updated_at: z72.string()
 });
-var listTriggersResponseSchema = z71.object({
-  triggers: z71.array(triggerSchema)
+var listTriggersResponseSchema = z72.object({
+  triggers: z72.array(triggerSchema)
 });
-var triggerTypeSchema = z71.object({
-  integration_slug: z71.string(),
-  integration_name: z71.string(),
-  icon_url: z71.string(),
-  trigger_type: z71.string(),
-  label: z71.string(),
-  description: z71.string(),
-  filter_schema: z71.record(z71.string(), z71.unknown())
+var triggerTypeSchema = z72.object({
+  integration_slug: z72.string(),
+  integration_name: z72.string(),
+  icon_url: z72.string(),
+  trigger_type: z72.string(),
+  label: z72.string(),
+  description: z72.string(),
+  filter_schema: z72.record(z72.string(), z72.unknown())
 });
-var listTriggerTypesResponseSchema = z71.object({
-  trigger_types: z71.array(triggerTypeSchema)
+var listTriggerTypesResponseSchema = z72.object({
+  trigger_types: z72.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
@@ -12017,55 +12232,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z72 } from "zod";
-var integrationSchema = z72.object({
-  id: z72.string(),
-  name: z72.string(),
-  type: z72.string(),
-  provider: z72.string(),
-  user_id: z72.string().nullable(),
-  team_id: z72.string(),
-  server_url: z72.string().optional(),
-  transport_type: z72.string().optional(),
-  auth_method: z72.string().nullish(),
-  composio_mcp_id: z72.string().nullish(),
-  custom_integration_id: z72.string().nullish(),
-  icon_url: z72.string().nullish(),
-  oauth_provider: z72.string().nullish(),
-  oauth_provider_key: z72.string().nullish(),
-  oauth_scopes: z72.array(z72.string()).nullish(),
-  integration_id: z72.string().nullish(),
-  created_at: z72.string(),
-  updated_at: z72.string()
-});
-var integrationsListResponseSchema2 = z72.object({
-  integrations: z72.array(integrationSchema)
+import { z as z73 } from "zod";
+var integrationSchema = z73.object({
+  id: z73.string(),
+  name: z73.string(),
+  type: z73.string(),
+  provider: z73.string(),
+  user_id: z73.string().nullable(),
+  team_id: z73.string(),
+  server_url: z73.string().optional(),
+  transport_type: z73.string().optional(),
+  auth_method: z73.string().nullish(),
+  composio_mcp_id: z73.string().nullish(),
+  custom_integration_id: z73.string().nullish(),
+  icon_url: z73.string().nullish(),
+  oauth_provider: z73.string().nullish(),
+  oauth_provider_key: z73.string().nullish(),
+  oauth_scopes: z73.array(z73.string()).nullish(),
+  integration_id: z73.string().nullish(),
+  created_at: z73.string(),
+  updated_at: z73.string()
+});
+var integrationsListResponseSchema2 = z73.object({
+  integrations: z73.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z72.object({
-  id: z72.string(),
-  integration_id: z72.string().nullable(),
-  custom_integration_id: z72.string().nullable(),
-  integration_type: z72.string(),
-  integration_name: z72.string(),
-  created_at: z72.string()
+var buildIntegrationConfigSchema2 = z73.object({
+  id: z73.string(),
+  integration_id: z73.string().nullable(),
+  custom_integration_id: z73.string().nullable(),
+  integration_type: z73.string(),
+  integration_name: z73.string(),
+  created_at: z73.string()
 });
-var listBuildIntegrationsResponseSchema2 = z72.object({
-  integrations: z72.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z73.object({
+  integrations: z73.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z72.object({
-  success: z72.boolean(),
-  count: z72.number()
+var attachBuildIntegrationsResponseSchema = z73.object({
+  success: z73.boolean(),
+  count: z73.number()
 });
-var buildIntegrationConnectionSchema = z72.object({
-  connection_id: z72.string(),
-  created_at: z72.string()
+var buildIntegrationConnectionSchema = z73.object({
+  connection_id: z73.string(),
+  created_at: z73.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z72.object({
-  connections: z72.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z73.object({
+  connections: z73.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z72.object({
-  success: z72.boolean()
+var successResponseSchema = z73.object({
+  success: z73.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -12108,15 +12323,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z73 } from "zod";
-var slotSchema = z73.object({
-  config_id: z73.string(),
-  integration_type: z73.string(),
-  linked_queue_count: z73.number()
+import { z as z74 } from "zod";
+var slotSchema = z74.object({
+  config_id: z74.string(),
+  integration_type: z74.string(),
+  linked_queue_count: z74.number()
 });
-var responseSchema2 = z73.object({
-  configs: z73.array(slotSchema),
-  has_available_queues: z73.boolean()
+var responseSchema2 = z74.object({
+  configs: z74.array(slotSchema),
+  has_available_queues: z74.boolean()
 });
 var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -12611,9 +12826,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z74 } from "zod";
-var promoteResponseSchema = z74.object({
-  success: z74.boolean()
+import { z as z75 } from "zod";
+var promoteResponseSchema = z75.object({
+  success: z75.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -12739,50 +12954,6 @@ function parseCaseIds(raw) {
 }
 __name(parseCaseIds, "parseCaseIds");
 
-// src/commands/cases/bulk-delegate.ts
-function registerCasesBulkDelegate(cases) {
-  cases.command("bulk-delegate").description(
-    "Delegate multiple cases to a chosen agent (1-100). Interrupts any active runs."
-  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption(
-    "--agent <id>",
-    "agent ID to delegate to (must be a queue consumer; list via `duvo queues agents <queue-id>`)"
-  ).requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkDelegateAction(options) {
-    const caseIds = parseCaseIds(options.ids);
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    await confirmDestructive({
-      message: `Delegate ${caseIds.length} case(s) in queue "${options.queue}" to agent "${options.agent}"?`,
-      skip: Boolean(options.yes)
-    });
-    const raw = await httpRequest({
-      method: "POST",
-      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-delegate`,
-      apiKey,
-      apiBaseUrl,
-      body: { case_ids: caseIds, agent_id: options.agent }
-    });
-    if (options.json) {
-      printJson(raw);
-      return;
-    }
-    const parsed = caseBulkDelegateResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const result = parsed.data;
-    console.log(green("Bulk delegate complete."));
-    console.log();
-    console.log(
-      renderKeyValue([
-        { label: "Delegated", value: String(result.delegatedCount) },
-        { label: "Skipped", value: String(result.skippedCount) }
-      ])
-    );
-  }, "bulkDelegateAction"));
-}
-__name(registerCasesBulkDelegate, "registerCasesBulkDelegate");
-
 // src/commands/cases/bulk-delete.ts
 function registerCasesBulkDelete(cases) {
   cases.command("bulk-delete").description(
@@ -12882,46 +13053,49 @@ async function fetchCaseTitles(ids, apiKey, apiBaseUrl) {
 }
 __name(fetchCaseTitles, "fetchCaseTitles");
 
-// src/commands/cases/bulk-retry.ts
-function registerCasesBulkRetry(cases) {
-  cases.command("bulk-retry").description(
-    "Retry multiple cases by resetting them to pending (1-100). Interrupts any active runs."
-  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkRetryAction(options) {
+// src/commands/cases/bulk-reprocess.ts
+function registerCasesBulkReprocess(cases) {
+  cases.command("bulk-reprocess").description(
+    "Re-process multiple cases on a chosen agent (1-100). Interrupts any active runs."
+  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption(
+    "--agent <id>",
+    "agent ID to re-process on (must be a queue consumer; list via `duvo queues agents <queue-id>`)"
+  ).requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkReprocessAction(options) {
     const caseIds = parseCaseIds(options.ids);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     await confirmDestructive({
-      message: `Retry ${caseIds.length} case(s) in queue "${options.queue}"?`,
+      message: `Re-process ${caseIds.length} case(s) in queue "${options.queue}" on agent "${options.agent}"?`,
       skip: Boolean(options.yes)
     });
     const raw = await httpRequest({
       method: "POST",
-      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-retry`,
+      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-reprocess`,
       apiKey,
       apiBaseUrl,
-      body: { case_ids: caseIds }
+      body: { case_ids: caseIds, agent_id: options.agent }
     });
     if (options.json) {
       printJson(raw);
       return;
     }
-    const parsed = caseBulkRetryResponseSchema.safeParse(raw);
+    const parsed = caseBulkReprocessResponseSchema.safeParse(raw);
     if (!parsed.success) {
       throw new CliError(
         `Unexpected response from the API: ${parsed.error.message}`
       );
     }
     const result = parsed.data;
-    console.log(green("Bulk retry complete."));
+    console.log(green("Bulk reprocess complete."));
     console.log();
     console.log(
       renderKeyValue([
-        { label: "Retried", value: String(result.retriedCount) },
+        { label: "Re-processed", value: String(result.reprocessedCount) },
         { label: "Skipped", value: String(result.skippedCount) }
       ])
     );
-  }, "bulkRetryAction"));
+  }, "bulkReprocessAction"));
 }
-__name(registerCasesBulkRetry, "registerCasesBulkRetry");
+__name(registerCasesBulkReprocess, "registerCasesBulkReprocess");
 
 // src/commands/cases/bulk-update-status.ts
 var CASE_TERMINAL_STATUSES = ["completed", "failed"];
@@ -13665,7 +13839,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -13683,17 +13857,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z75.object({
-  id: z75.string(),
-  type: z75.string(),
-  role: z75.string(),
-  timestamp: z75.string(),
-  text_content: z75.string().nullish(),
-  tool_call: z75.object({ id: z75.string(), name: z75.string() }).passthrough().nullish(),
-  tool_result: z75.object({ tool_call_id: z75.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z75.object({
-  messages: z75.array(recentMessageSchema)
+var recentMessageSchema = z76.object({
+  id: z76.string(),
+  type: z76.string(),
+  role: z76.string(),
+  timestamp: z76.string(),
+  text_content: z76.string().nullish(),
+  tool_call: z76.object({ id: z76.string(), name: z76.string() }).passthrough().nullish(),
+  tool_result: z76.object({ tool_call_id: z76.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z76.object({
+  messages: z76.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -13814,56 +13988,544 @@ function registerCases(program) {
   registerCasesDelete(cases);
   registerCasesClear(cases);
   registerCasesBulkDelete(cases);
-  registerCasesBulkRetry(cases);
+  registerCasesBulkReprocess(cases);
   registerCasesBulkUpdateStatus(cases);
-  registerCasesBulkDelegate(cases);
   registerCasesRuns(cases);
   registerCasesLabels(cases);
 }
 __name(registerCases, "registerCases");
 
 // src/commands/clarity/index.ts
-import { z as z79 } from "zod";
+import { z as z84 } from "zod";
 
-// src/commands/clarity/render.ts
-var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
-var PROCESS_TABLE_COLUMNS = [
-  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
-  { header: "VERSION", cell: /* @__PURE__ */ __name((row) => String(row.version), "cell") },
-  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+// src/api/clarity-schemas.ts
+import { z as z77 } from "zod";
+var clarityListProcessSchema = z77.object({
+  id: z77.guid(),
+  name: z77.string(),
+  status: clarityProcessStatusSchema,
+  visibility: clarityProcessVisibilitySchema,
+  version: z77.number().int(),
+  capture_count: z77.number().int(),
+  capture_counts: z77.object({
+    video: z77.number().int(),
+    interview: z77.number().int(),
+    document: z77.number().int()
+  }).optional(),
+  pending_invitation_count: z77.number().int(),
+  contributors: z77.array(
+    z77.object({
+      user_id: z77.string(),
+      user_name: z77.string()
+    })
+  ),
+  created_at: z77.string(),
+  created_by_name: z77.string().nullable()
+});
+var listClarityProcessesResponseSchema = z77.object({
+  processes: z77.array(clarityListProcessSchema),
+  total: z77.number().int(),
+  limit: z77.number().int(),
+  offset: z77.number().int()
+});
+var createClarityInviteLinkResponseSchema = z77.object({
+  invite_link: z77.object({
+    id: z77.guid(),
+    url: z77.url(),
+    created_at: z77.string(),
+    created_by: z77.object({
+      id: z77.guid(),
+      email: z77.email().nullable()
+    })
+  })
+});
+var createArtifactImportUploadUrlResponseSchema = z77.object({
+  signed_url: z77.url(),
+  capture_id: z77.guid(),
+  expires_at: z77.iso.datetime()
+});
+var completeArtifactImportResponseSchema = z77.object({
+  capture: clarityCaptureSchema.extend({
+    createdAt: z77.iso.datetime(),
+    updatedAt: z77.iso.datetime()
+  })
+});
+var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
+
+// src/commands/clarity/artifact-chat.ts
+var SNAPSHOT_KIND_CHOICES = claritySnapshotKindSchema.options;
+var CONVERSATION_COLUMNS = [
   {
-    header: "CAPTURES",
-    cell: /* @__PURE__ */ __name((row) => String(row.capture_count), "cell")
+    header: "ID",
+    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
   },
   {
-    header: "NAME",
-    cell: /* @__PURE__ */ __name((row) => row.name, "cell"),
+    header: "SNAPSHOT",
+    cell: /* @__PURE__ */ __name((row) => row.snapshot_kind, "cell")
+  },
+  {
+    header: "STATUS",
+    cell: /* @__PURE__ */ __name((row) => row.status, "cell")
+  },
+  {
+    header: "TITLE",
+    cell: /* @__PURE__ */ __name((row) => row.title ?? "", "cell"),
     maxWidth: 48
+  },
+  {
+    header: "UPDATED",
+    cell: /* @__PURE__ */ __name((row) => row.updated_at, "cell")
   }
 ];
-var CAPTURE_TABLE_COLUMNS = [
-  { 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") },
+var MESSAGE_COLUMNS = [
   {
-    header: "USABLE",
-    cell: /* @__PURE__ */ __name((row) => describeCaptureUsability(row).usable ? "yes" : "no", "cell")
+    header: "ID",
+    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
+  },
+  {
+    header: "ROLE",
+    cell: /* @__PURE__ */ __name((row) => row.role, "cell")
+  },
+  {
+    header: "KIND",
+    cell: /* @__PURE__ */ __name((row) => row.kind, "cell")
   },
-  { header: "USER", cell: /* @__PURE__ */ __name((row) => row.userName ?? row.userId, "cell") },
   {
     header: "CREATED",
-    cell: /* @__PURE__ */ __name((row) => formatIso(row.createdAt), "cell")
+    cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
+  },
+  {
+    header: "BODY",
+    cell: /* @__PURE__ */ __name((row) => describeMessageBody(row.body), "cell"),
+    maxWidth: 64
   }
 ];
-function renderProcessTable(rows) {
-  return renderTable(PROCESS_TABLE_COLUMNS, rows);
-}
-__name(renderProcessTable, "renderProcessTable");
-function renderCapturesTable(rows) {
-  return renderTable(CAPTURE_TABLE_COLUMNS, rows);
-}
-__name(renderCapturesTable, "renderCapturesTable");
-function renderVersionReport(process2) {
+function registerClarityArtifactChatConversations(clarity) {
+  clarity.command("artifact-chat-conversations <process-id>").description("List artifact-chat conversations for a v2 process").requiredOption(
+    "--snapshot-kind <current_process|transformation_proposal>",
+    "artifact kind to list conversations for",
+    parseSnapshotKind
+  ).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("snapshot_kind", options.snapshotKind);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-chat/conversations`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    const parsed = listArtifactChatConversationsResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (options.json) {
+      printJson(response);
+      return;
+    }
+    if (response.conversations.length === 0) {
+      console.log("No artifact-chat conversations found.");
+      return;
+    }
+    console.log(renderTable(CONVERSATION_COLUMNS, response.conversations));
+  }, "action"));
+}
+__name(registerClarityArtifactChatConversations, "registerClarityArtifactChatConversations");
+function registerClarityArtifactChatMessages(clarity) {
+  clarity.command("artifact-chat-messages <process-id> <conversation-id>").description("Read messages for one artifact-chat conversation").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function action(processId, conversationId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-chat/conversations/${encodeURIComponent(conversationId)}/messages`,
+      apiKey,
+      apiBaseUrl
+    });
+    const parsed = getArtifactChatMessagesResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (options.json) {
+      printJson(response);
+      return;
+    }
+    const conversation = renderKeyValue([
+      { label: "Conversation", value: response.conversation.id },
+      { label: "Snapshot", value: response.conversation.snapshot_kind },
+      { label: "Status", value: response.conversation.status },
+      { label: "Title", value: response.conversation.title ?? "" }
+    ]);
+    if (response.messages.length === 0) {
+      console.log(`${conversation}
+
+No artifact-chat messages found.`);
+      return;
+    }
+    console.log(
+      `${conversation}
+
+${renderTable(MESSAGE_COLUMNS, response.messages)}`
+    );
+  }, "action"));
+}
+__name(registerClarityArtifactChatMessages, "registerClarityArtifactChatMessages");
+function parseSnapshotKind(value) {
+  const parsed = claritySnapshotKindSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError(
+      `--snapshot-kind must be one of: ${SNAPSHOT_KIND_CHOICES.join(", ")}`
+    );
+  }
+  return parsed.data;
+}
+__name(parseSnapshotKind, "parseSnapshotKind");
+function describeMessageBody(body) {
+  switch (body.kind) {
+    case "text":
+    case "error":
+    case "info":
+      return body.text;
+    case "patch":
+      return `${body.status}: ${body.summary}`;
+    case "hitl_question":
+      return `${body.questions.length} question(s)`;
+    case "hitl_answer":
+      return `${Object.keys(body.answers).length} answer(s)`;
+  }
+}
+__name(describeMessageBody, "describeMessageBody");
+
+// src/commands/clarity/artifact-import.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename, extname } from "node:path";
+var ARTIFACT_CONTENT_TYPES = [
+  "image/svg+xml",
+  "application/xml",
+  "text/xml",
+  "image/png",
+  "image/jpeg"
+];
+var ARTIFACT_UPLOAD_TIMEOUT_MS = 3e5;
+function registerClarityImportArtifact(clarity) {
+  clarity.command("import-artifact <process-id> <file>").description(
+    "Import a local Miro SVG, XML, PNG, or JPEG export into a Clarity process"
+  ).option("--content-type <type>", "artifact content type").option(
+    "--extra-capture-request-id <id>",
+    "bind the import to an extra-capture request"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, filePath, options) {
+    const fileName = basename(filePath);
+    const contentType = resolveArtifactContentType(
+      fileName,
+      options.contentType
+    );
+    const config = await requireAuthenticatedConfig(this);
+    const bytes = await readLocalArtifact(filePath);
+    const upload = await createUploadUrl(config, processId, {
+      fileName,
+      contentType,
+      extraCaptureRequestId: options.extraCaptureRequestId
+    });
+    await uploadToSignedUrl(upload.signed_url, bytes, contentType);
+    const complete = await completeArtifactImport(
+      config,
+      processId,
+      upload.capture_id,
+      { fileName, contentType }
+    );
+    if (options.json) {
+      printJson({ upload, complete });
+      return;
+    }
+    renderCompletedImport(complete);
+  }, "action"));
+}
+__name(registerClarityImportArtifact, "registerClarityImportArtifact");
+async function createUploadUrl(config, processId, input) {
+  const body = {
+    file_name: input.fileName,
+    content_type: input.contentType
+  };
+  if (input.extraCaptureRequestId !== void 0) {
+    body.extra_capture_request_id = input.extraCaptureRequestId;
+  }
+  const raw = await httpRequest({
+    method: "POST",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-imports/create-upload-url`,
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl,
+    body
+  });
+  const parsed = createArtifactImportUploadUrlResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(createUploadUrl, "createUploadUrl");
+async function completeArtifactImport(config, processId, captureId, input) {
+  const raw = await httpRequest({
+    method: "POST",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-imports/${encodeURIComponent(captureId)}/complete`,
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl,
+    body: {
+      file_name: input.fileName,
+      content_type: input.contentType
+    }
+  });
+  const parsed = completeArtifactImportResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(completeArtifactImport, "completeArtifactImport");
+async function readLocalArtifact(filePath) {
+  try {
+    return await readFile5(filePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(`Cannot read "${filePath}": ${message}`);
+  }
+}
+__name(readLocalArtifact, "readLocalArtifact");
+async function uploadToSignedUrl(signedUrl, bytes, contentType) {
+  let response;
+  try {
+    response = await fetch(signedUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: new Uint8Array(bytes),
+      signal: AbortSignal.timeout(ARTIFACT_UPLOAD_TIMEOUT_MS)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(`Artifact upload failed: ${message}`);
+  }
+  if (!response.ok) {
+    const text3 = await response.text().catch(() => "");
+    throw new CliError(
+      `Artifact upload failed with HTTP ${response.status}${text3 ? `: ${text3}` : ""}`
+    );
+  }
+}
+__name(uploadToSignedUrl, "uploadToSignedUrl");
+function resolveArtifactContentType(fileName, contentType) {
+  if (contentType !== void 0) {
+    return parseArtifactContentType(contentType);
+  }
+  const extension = extname(fileName).toLowerCase();
+  if (extension === ".svg") {
+    return "image/svg+xml";
+  }
+  if (extension === ".xml") {
+    return "application/xml";
+  }
+  if (extension === ".png") {
+    return "image/png";
+  }
+  if (extension === ".jpg" || extension === ".jpeg") {
+    return "image/jpeg";
+  }
+  throw new CliError(
+    "Cannot infer content type. Supported extensions: .svg, .xml, .png, .jpg, .jpeg."
+  );
+}
+__name(resolveArtifactContentType, "resolveArtifactContentType");
+function parseArtifactContentType(contentType) {
+  if (ARTIFACT_CONTENT_TYPES.includes(contentType)) {
+    return contentType;
+  }
+  throw new CliError(
+    `Invalid content type "${contentType}". Expected one of: ${ARTIFACT_CONTENT_TYPES.join(", ")}.`
+  );
+}
+__name(parseArtifactContentType, "parseArtifactContentType");
+function renderCompletedImport(response) {
+  console.log(
+    renderKeyValue([
+      { label: "Capture ID", value: response.capture.id },
+      { label: "Status", value: response.capture.status },
+      { label: "Type", value: response.capture.type },
+      { label: "Created", value: response.capture.createdAt },
+      { label: "Updated", value: response.capture.updatedAt }
+    ])
+  );
+}
+__name(renderCompletedImport, "renderCompletedImport");
+
+// src/commands/clarity/assign-extra-capture-request.ts
+import { z as z78 } from "zod";
+var responseSchema3 = z78.object({
+  request: clarityProposalExtraCaptureRequestSchema
+});
+function renderRequest(request) {
+  console.log(
+    renderKeyValue([
+      { label: "ID", value: request.id },
+      { label: "Step ID", value: request.step_id },
+      { label: "Status", value: request.status },
+      { label: "Priority", value: request.priority },
+      { label: "Assigned to", value: request.requested_user_id ?? "" },
+      { label: "Gap", value: request.gap },
+      { label: "Updated", value: request.updated_at }
+    ])
+  );
+}
+__name(renderRequest, "renderRequest");
+function registerClarityAssignExtraCaptureRequest(clarity) {
+  clarity.command(
+    "assign-extra-capture-request <process-id> <proposal-id> <request-id>"
+  ).description(
+    "Assign (or unassign) a team member to an extra-capture request"
+  ).option("--user-id <id>", "team member to assign (omit to unassign)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, requestId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests/${encodeURIComponent(requestId)}/assign`,
+      apiKey,
+      apiBaseUrl,
+      body: { user_id: options.userId ?? null }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema3.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    renderRequest(parsed.data.request);
+  }, "action"));
+}
+__name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
+
+// src/commands/clarity/build-automation.ts
+import { z as z79 } from "zod";
+var responseSchema4 = z79.object({
+  automation_run: z79.object({
+    id: z79.string(),
+    status: z79.string()
+  })
+});
+function registerClarityBuildAutomation(clarity) {
+  clarity.command("build-automation <process-id>").description(
+    "Hand the latest transformation proposal off to the workflow-builder pipeline (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/automation`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema4.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { automation_run: run } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "Run ID", value: run.id },
+        { label: "Status", value: run.status }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityBuildAutomation, "registerClarityBuildAutomation");
+
+// src/commands/clarity/create-invite-link.ts
+function registerClarityCreateInviteLink(clarity) {
+  clarity.command("create-invite-link <process-id>").description(
+    "Create or regenerate a Clarity interview invite link for a process"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/invite-link`,
+      apiKey,
+      apiBaseUrl
+    });
+    const parsed = createClarityInviteLinkResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const { invite_link: inviteLink } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: inviteLink.id },
+        { label: "URL", value: inviteLink.url },
+        { label: "Created", value: inviteLink.created_at },
+        { label: "Created by", value: inviteLink.created_by.email ?? "" }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
+
+// src/commands/clarity/render.ts
+var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
+var PROCESS_TABLE_COLUMNS = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "VERSION", cell: /* @__PURE__ */ __name((row) => String(row.version), "cell") },
+  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+  {
+    header: "CAPTURES",
+    cell: /* @__PURE__ */ __name((row) => String(row.capture_count), "cell")
+  },
+  {
+    header: "NAME",
+    cell: /* @__PURE__ */ __name((row) => row.name, "cell"),
+    maxWidth: 48
+  }
+];
+var CAPTURE_TABLE_COLUMNS = [
+  { 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") },
+  {
+    header: "USABLE",
+    cell: /* @__PURE__ */ __name((row) => describeCaptureUsability(row).usable ? "yes" : "no", "cell")
+  },
+  { header: "USER", cell: /* @__PURE__ */ __name((row) => row.userName ?? row.userId, "cell") },
+  {
+    header: "CREATED",
+    cell: /* @__PURE__ */ __name((row) => formatIso(row.createdAt), "cell")
+  }
+];
+function renderProcessTable(rows) {
+  return renderTable(PROCESS_TABLE_COLUMNS, rows);
+}
+__name(renderProcessTable, "renderProcessTable");
+function renderCapturesTable(rows) {
+  return renderTable(CAPTURE_TABLE_COLUMNS, rows);
+}
+__name(renderCapturesTable, "renderCapturesTable");
+function renderVersionReport(process2) {
   const current = process2.current_process_versions;
   const proposals = process2.transformation_proposal_versions;
   const defaultCurrent = selectDefaultVersion(current);
@@ -14816,25 +15478,15 @@ function formatOptionalBoolean(value) {
 }
 __name(formatOptionalBoolean, "formatOptionalBoolean");
 
-// src/commands/clarity/get-current-process.ts
-import { z as z76 } from "zod";
-var snapshotSchema = z76.object({
-  snapshot: z76.object({
-    id: z76.string(),
-    status: z76.string(),
-    creator_type: z76.string(),
-    user_id: z76.string().nullable(),
-    sandbox_id: z76.string().nullable(),
-    created_at: z76.string(),
-    updated_at: z76.string()
-  })
-});
-function registerClarityGetCurrentProcess(clarity) {
-  clarity.command("get-current-process <process-id> <snapshot-id>").description("Get a specific current-process snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+// src/commands/clarity/generate-current-process.ts
+function registerClarityGenerateCurrentProcess(clarity) {
+  clarity.command("generate-current-process <process-id>").description(
+    "Trigger current-process generation for a Clarity v2 process (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
-      method: "GET",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process`,
       apiKey,
       apiBaseUrl
     });
@@ -14842,13 +15494,259 @@ function registerClarityGetCurrentProcess(clarity) {
       printJson(raw);
       return;
     }
-    const parsed = snapshotSchema.safeParse(raw);
-    if (!parsed.success) {
+    console.log("Generation started.");
+  }, "action"));
+}
+__name(registerClarityGenerateCurrentProcess, "registerClarityGenerateCurrentProcess");
+
+// src/commands/clarity/generate-transformation-proposal.ts
+function registerClarityGenerateTransformationProposal(clarity) {
+  clarity.command("generate-transformation-proposal <process-id>").description(
+    "Trigger transformation-proposal generation for a Clarity v2 process (async)"
+  ).option(
+    "--current-process-id <id>",
+    "current-process snapshot to anchor generation to"
+  ).option(
+    "--regenerate-from <id>",
+    "previous transformation proposal to regenerate from"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    if (options.currentProcessId !== void 0 && options.regenerateFrom !== void 0) {
       throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
+        "Pass either --current-process-id or --regenerate-from, not both."
       );
     }
-    const { snapshot } = parsed.data;
+    const body = buildGenerateTransformationProposalBody(options);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Generation started.");
+  }, "action"));
+}
+__name(registerClarityGenerateTransformationProposal, "registerClarityGenerateTransformationProposal");
+function buildGenerateTransformationProposalBody(options) {
+  if (options.regenerateFrom !== void 0) {
+    return { regenerate_from: options.regenerateFrom };
+  }
+  if (options.currentProcessId !== void 0) {
+    return { current_process_id: options.currentProcessId };
+  }
+  return void 0;
+}
+__name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
+
+// src/commands/clarity/get-current-process.ts
+import { z as z80 } from "zod";
+
+// src/commands/clarity/read-api.ts
+var AUTH_ERROR_MARKER = "Unauthorized.";
+var NOT_FOUND_ERROR_PREFIX = "Not found:";
+var FETCH_FAILED_MARKER = "fetch failed";
+async function listClarityProcesses(config, teamId, params) {
+  const searchParams = new URLSearchParams();
+  searchParams.append("limit", String(params.limit));
+  searchParams.append("offset", String(params.offset));
+  if (params.search !== void 0) {
+    searchParams.append("search", params.search);
+  }
+  if (params.status !== void 0) {
+    searchParams.append("status", params.status);
+  }
+  if (params.version !== void 0) {
+    searchParams.append("version", String(params.version));
+  }
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: buildTeamPath(teamId, "/clarity-v2/processes"),
+    searchParams,
+    resource: "Clarity process list"
+  });
+  return parseResponse(listClarityProcessesResponseSchema, raw);
+}
+__name(listClarityProcesses, "listClarityProcesses");
+async function getClarityV2Process(config, processId) {
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}`,
+    resource: "Clarity v2 process"
+  });
+  return parseResponse(clarityV2ProcessReadModelSchema, raw);
+}
+__name(getClarityV2Process, "getClarityV2Process");
+async function getLegacyClarityProcess(config, processId) {
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity/processes/${encodeURIComponent(processId)}`,
+    resource: "legacy Clarity process"
+  });
+  return parseResponse(legacyClarityProcessResponseSchema, raw);
+}
+__name(getLegacyClarityProcess, "getLegacyClarityProcess");
+async function getCurrentProcessSnapshot(config, processId, snapshotId) {
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(
+      processId
+    )}/current-process/${encodeURIComponent(snapshotId)}`,
+    resource: "Clarity current-process snapshot"
+  });
+  return parseResponse(
+    clarityV2CurrentProcessSnapshotDetailResponseSchema,
+    raw
+  );
+}
+__name(getCurrentProcessSnapshot, "getCurrentProcessSnapshot");
+async function getTransformationProposalSnapshot(config, processId, snapshotId) {
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(
+      processId
+    )}/transformation-proposal/${encodeURIComponent(snapshotId)}`,
+    resource: "Clarity transformation-proposal snapshot"
+  });
+  return parseResponse(
+    clarityV2TransformationProposalSnapshotDetailResponseSchema,
+    raw
+  );
+}
+__name(getTransformationProposalSnapshot, "getTransformationProposalSnapshot");
+async function listExtraCaptureRequests(config, processId, proposalId, params = {}) {
+  const searchParams = new URLSearchParams();
+  searchParams.append("limit", String(params.limit ?? 100));
+  searchParams.append("offset", String(params.offset ?? 0));
+  const raw = await getClarityJson(config, {
+    method: "GET",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(
+      processId
+    )}/transformation-proposals/${encodeURIComponent(
+      proposalId
+    )}/extra-capture-requests`,
+    searchParams,
+    resource: "Clarity extra-capture requests"
+  });
+  return parseResponse(
+    clarityProposalExtraCaptureRequestListResponseSchema,
+    raw
+  );
+}
+__name(listExtraCaptureRequests, "listExtraCaptureRequests");
+function isLegacyV2ReadError(error) {
+  return error instanceof CliHttpError && error.status === 403 && (error.apiErrorCode === "PROCESS_NOT_ON_V2" || error.apiErrorMessage === "Process is not on v2");
+}
+__name(isLegacyV2ReadError, "isLegacyV2ReadError");
+async function requireV2Process(config, processId) {
+  try {
+    return await getClarityV2Process(config, processId);
+  } catch (error) {
+    if (isLegacyV2ReadError(error)) {
+      throw new CliError(
+        "This command requires Clarity v2. Use `duvo clarity overview <process-id>` to read legacy v1 context."
+      );
+    }
+    throw error;
+  }
+}
+__name(requireV2Process, "requireV2Process");
+async function getClarityJson(config, options) {
+  try {
+    return await httpRequest({
+      method: options.method,
+      path: options.path,
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl,
+      searchParams: options.searchParams
+    });
+  } catch (error) {
+    throw toClarityCliError(error, {
+      apiBaseUrl: config.apiBaseUrl,
+      resource: options.resource
+    });
+  }
+}
+__name(getClarityJson, "getClarityJson");
+function toClarityCliError(error, context) {
+  if (isLegacyV2ReadError(error)) {
+    return error;
+  }
+  if (error instanceof CliHttpError && error.status === 403) {
+    return new CliError(
+      `${context.resource} is not accessible with the active profile. Check the process ID and active profile with \`duvo whoami\` or reauthenticate with \`duvo login\`.`,
+      EXIT_CODE.FORBIDDEN
+    );
+  }
+  if (error instanceof CliError) {
+    if (error.message.includes(AUTH_ERROR_MARKER)) {
+      return new CliError(
+        "Authentication failed. Run `duvo login` to reauthenticate, or update your API key with `duvo login --api-key <key>`.",
+        EXIT_CODE.AUTH
+      );
+    }
+    if (error.message.startsWith(NOT_FOUND_ERROR_PREFIX)) {
+      return new CliError(
+        `${context.resource} was not found for the active profile. Check the process/snapshot ID and active profile; cross-team resources are not revealed.`,
+        EXIT_CODE.NOT_FOUND
+      );
+    }
+    return error;
+  }
+  if (error instanceof TypeError && error.message.includes(FETCH_FAILED_MARKER)) {
+    return new CliError(
+      `Could not reach the Duvo API at ${context.apiBaseUrl}. Check the API base URL and network connection.`
+    );
+  }
+  return error;
+}
+__name(toClarityCliError, "toClarityCliError");
+function parseResponse(schema, raw) {
+  const parsed = schema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(parseResponse, "parseResponse");
+
+// src/commands/clarity/get-current-process.ts
+var snapshotSchema = z80.object({
+  snapshot: z80.object({
+    id: z80.string(),
+    status: z80.string(),
+    creator_type: z80.string(),
+    user_id: z80.string().nullable(),
+    sandbox_id: z80.string().nullable(),
+    created_at: z80.string(),
+    updated_at: z80.string()
+  })
+});
+function registerClarityGetCurrentProcess(clarity) {
+  clarity.command("get-current-process <process-id> <snapshot-id>").description("Get a specific current-process snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const config = await requireAuthenticatedConfig(this);
+    const raw = await getClarityJson(config, {
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      resource: "Clarity current-process snapshot"
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
     console.log(
       renderKeyValue([
         { label: "ID", value: snapshot.id },
@@ -14865,26 +15763,25 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z77 } from "zod";
-var snapshotSchema2 = z77.object({
-  snapshot: z77.object({
-    id: z77.string(),
-    status: z77.string(),
-    creator_type: z77.string(),
-    user_id: z77.string().nullable(),
-    sandbox_id: z77.string().nullable(),
-    created_at: z77.string(),
-    updated_at: z77.string()
+import { z as z81 } from "zod";
+var snapshotSchema2 = z81.object({
+  snapshot: z81.object({
+    id: z81.string(),
+    status: z81.string(),
+    creator_type: z81.string(),
+    user_id: z81.string().nullable(),
+    sandbox_id: z81.string().nullable(),
+    created_at: z81.string(),
+    updated_at: z81.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
   clarity.command("get-transformation-proposal <process-id> <proposal-id>").description("Get a specific transformation-proposal snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    const raw = await httpRequest({
+    const config = await requireAuthenticatedConfig(this);
+    const raw = await getClarityJson(config, {
       method: "GET",
       path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
-      apiKey,
-      apiBaseUrl
+      resource: "Clarity transformation-proposal snapshot"
     });
     if (options.json) {
       printJson(raw);
@@ -14915,24 +15812,13 @@ __name(registerClarityGetTransformationProposal, "registerClarityGetTransformati
 // src/commands/clarity/get.ts
 function registerClarityGet(clarity) {
   clarity.command("get <process-id>").description("Get a Clarity process read model by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(processId, options) {
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    const raw = await httpRequest({
-      method: "GET",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}`,
-      apiKey,
-      apiBaseUrl
-    });
+    const config = await requireAuthenticatedConfig(this);
+    const result = await requireV2Process(config, processId);
     if (options.json) {
-      printJson(raw);
+      printJson(result);
       return;
     }
-    const parsed = clarityV2ProcessReadModelSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const { process: process2 } = parsed.data;
+    const { process: process2 } = result;
     console.log(
       renderKeyValue([
         { label: "ID", value: process2.id },
@@ -14954,7 +15840,7 @@ function registerClarityGet(clarity) {
     const {
       current_process_versions: cpVersions,
       transformation_proposal_versions: tpVersions
-    } = parsed.data;
+    } = result;
     if (cpVersions.length > 0) {
       console.log(`
 Current process versions (${cpVersions.length}):`);
@@ -15014,15 +15900,14 @@ function registerClarityListExtraCaptureRequests(clarity) {
       max: MAX_LIMIT5
     });
     const offset = parseOffset(options.offset);
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const config = await requireAuthenticatedConfig(this);
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
     searchParams.append("offset", String(offset));
-    const raw = await httpRequest({
+    const raw = await getClarityJson(config, {
       method: "GET",
       path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests`,
-      apiKey,
-      apiBaseUrl,
+      resource: "Clarity extra-capture requests",
       searchParams
     });
     if (options.json) {
@@ -15048,193 +15933,180 @@ function registerClarityListExtraCaptureRequests(clarity) {
 }
 __name(registerClarityListExtraCaptureRequests, "registerClarityListExtraCaptureRequests");
 
-// src/api/clarity-schemas.ts
-import { z as z78 } from "zod";
-var clarityListProcessSchema = z78.object({
-  id: z78.guid(),
-  name: z78.string(),
-  status: clarityProcessStatusSchema,
-  version: z78.number().int(),
-  capture_count: z78.number().int(),
-  capture_counts: z78.object({
-    video: z78.number().int(),
-    interview: z78.number().int(),
-    document: z78.number().int()
-  }).optional(),
-  pending_invitation_count: z78.number().int(),
-  contributors: z78.array(
-    z78.object({
-      user_id: z78.string(),
-      user_name: z78.string()
-    })
-  ),
-  created_at: z78.string(),
-  created_by_name: z78.string().nullable()
-});
-var listClarityProcessesResponseSchema = z78.object({
-  processes: z78.array(clarityListProcessSchema),
-  total: z78.number().int(),
-  limit: z78.number().int(),
-  offset: z78.number().int()
-});
-var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
-
-// src/commands/clarity/read-api.ts
-var AUTH_ERROR_MARKER = "Unauthorized.";
-var NOT_FOUND_ERROR_PREFIX = "Not found:";
-var FETCH_FAILED_MARKER = "fetch failed";
-async function listClarityProcesses(config, teamId, params) {
-  const searchParams = new URLSearchParams();
-  searchParams.append("limit", String(params.limit));
-  searchParams.append("offset", String(params.offset));
-  if (params.search !== void 0) {
-    searchParams.append("search", params.search);
-  }
-  if (params.status !== void 0) {
-    searchParams.append("status", params.status);
-  }
-  if (params.version !== void 0) {
-    searchParams.append("version", String(params.version));
-  }
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: buildTeamPath(teamId, "/clarity-v2/processes"),
-    searchParams,
-    resource: "Clarity process list"
-  });
-  return parseResponse(listClarityProcessesResponseSchema, raw);
-}
-__name(listClarityProcesses, "listClarityProcesses");
-async function getClarityV2Process(config, processId) {
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}`,
-    resource: "Clarity v2 process"
-  });
-  return parseResponse(clarityV2ProcessReadModelSchema, raw);
-}
-__name(getClarityV2Process, "getClarityV2Process");
-async function getLegacyClarityProcess(config, processId) {
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: `/v2/clarity/processes/${encodeURIComponent(processId)}`,
-    resource: "legacy Clarity process"
-  });
-  return parseResponse(legacyClarityProcessResponseSchema, raw);
-}
-__name(getLegacyClarityProcess, "getLegacyClarityProcess");
-async function getCurrentProcessSnapshot(config, processId, snapshotId) {
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: `/v2/clarity-v2/processes/${encodeURIComponent(
-      processId
-    )}/current-process/${encodeURIComponent(snapshotId)}`,
-    resource: "Clarity current-process snapshot"
-  });
-  return parseResponse(
-    clarityV2CurrentProcessSnapshotDetailResponseSchema,
-    raw
-  );
-}
-__name(getCurrentProcessSnapshot, "getCurrentProcessSnapshot");
-async function getTransformationProposalSnapshot(config, processId, snapshotId) {
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: `/v2/clarity-v2/processes/${encodeURIComponent(
-      processId
-    )}/transformation-proposal/${encodeURIComponent(snapshotId)}`,
-    resource: "Clarity transformation-proposal snapshot"
-  });
-  return parseResponse(
-    clarityV2TransformationProposalSnapshotDetailResponseSchema,
-    raw
-  );
-}
-__name(getTransformationProposalSnapshot, "getTransformationProposalSnapshot");
-async function listExtraCaptureRequests(config, processId, proposalId, params = {}) {
-  const searchParams = new URLSearchParams();
-  searchParams.append("limit", String(params.limit ?? 100));
-  searchParams.append("offset", String(params.offset ?? 0));
-  const raw = await getClarityJson(config, {
-    method: "GET",
-    path: `/v2/clarity-v2/processes/${encodeURIComponent(
-      processId
-    )}/transformation-proposals/${encodeURIComponent(
-      proposalId
-    )}/extra-capture-requests`,
-    searchParams,
-    resource: "Clarity extra-capture requests"
-  });
-  return parseResponse(
-    clarityProposalExtraCaptureRequestListResponseSchema,
-    raw
-  );
-}
-__name(listExtraCaptureRequests, "listExtraCaptureRequests");
-function isLegacyV2ReadError(error) {
-  return error instanceof CliHttpError && error.status === 403 && (error.apiErrorCode === "PROCESS_NOT_ON_V2" || error.apiErrorMessage === "Process is not on v2");
-}
-__name(isLegacyV2ReadError, "isLegacyV2ReadError");
-async function getClarityJson(config, options) {
-  try {
-    return await httpRequest({
-      method: options.method,
-      path: options.path,
-      apiKey: config.apiKey,
-      apiBaseUrl: config.apiBaseUrl,
-      searchParams: options.searchParams
-    });
-  } catch (error) {
-    throw toClarityCliError(error, {
-      apiBaseUrl: config.apiBaseUrl,
-      resource: options.resource
+// src/commands/clarity/postprocess.ts
+var SNAPSHOT_TYPES = ["current_process", "transformation_proposal"];
+function registerClarityPostprocess(clarity) {
+  clarity.command("postprocess <process-id> <snapshot-type> <snapshot-id>").description(
+    `Re-run postprocessing agents on an existing snapshot. snapshot-type must be one of: ${SNAPSHOT_TYPES.join(", ")}`
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotType, snapshotId, options) {
+    if (!SNAPSHOT_TYPES.includes(snapshotType)) {
+      throw new CliError(
+        `snapshot-type must be one of: ${SNAPSHOT_TYPES.join(", ")}`
+      );
+    }
+    const type = snapshotType;
+    const body = type === "current_process" ? { type, current_process_id: snapshotId } : { type, transformation_proposal_id: snapshotId };
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/postprocess`,
+      apiKey,
+      apiBaseUrl,
+      body
     });
-  }
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Postprocessing started.");
+  }, "action"));
 }
-__name(getClarityJson, "getClarityJson");
-function toClarityCliError(error, context) {
-  if (isLegacyV2ReadError(error)) {
-    return error;
-  }
-  if (error instanceof CliHttpError && error.status === 403) {
-    return new CliError(
-      `${context.resource} is not accessible with the active profile. Check the process ID and active profile with \`duvo whoami\` or reauthenticate with \`duvo login\`.`,
-      EXIT_CODE.FORBIDDEN
-    );
-  }
-  if (error instanceof CliError) {
-    if (error.message.includes(AUTH_ERROR_MARKER)) {
-      return new CliError(
-        "Authentication failed. Run `duvo login` to reauthenticate, or update your API key with `duvo login --api-key <key>`.",
-        EXIT_CODE.AUTH
+__name(registerClarityPostprocess, "registerClarityPostprocess");
+
+// src/commands/clarity/promote-current-process.ts
+import { z as z82 } from "zod";
+var snapshotSchema3 = z82.object({
+  snapshot: z82.object({
+    id: z82.string(),
+    status: z82.string(),
+    creator_type: z82.string(),
+    created_at: z82.string(),
+    updated_at: z82.string()
+  })
+});
+function registerClarityPromoteCurrentProcess(clarity) {
+  clarity.command("promote-current-process <process-id> <snapshot-id>").description("Promote a current-process snapshot to live").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}/promote`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema3.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    if (error.message.startsWith(NOT_FOUND_ERROR_PREFIX)) {
-      return new CliError(
-        `${context.resource} was not found for the active profile. Check the process/snapshot ID and active profile; cross-team resources are not revealed.`,
-        EXIT_CODE.NOT_FOUND
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
+
+// src/commands/clarity/promote-transformation-proposal.ts
+import { z as z83 } from "zod";
+var snapshotSchema4 = z83.object({
+  snapshot: z83.object({
+    id: z83.string(),
+    status: z83.string(),
+    creator_type: z83.string(),
+    created_at: z83.string(),
+    updated_at: z83.string()
+  })
+});
+function registerClarityPromoteTransformationProposal(clarity) {
+  clarity.command("promote-transformation-proposal <process-id> <proposal-id>").description("Promote a transformation-proposal snapshot to live").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}/promote`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema4.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    return error;
-  }
-  if (error instanceof TypeError && error.message.includes(FETCH_FAILED_MARKER)) {
-    return new CliError(
-      `Could not reach the Duvo API at ${context.apiBaseUrl}. Check the API base URL and network connection.`
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
     );
-  }
-  return error;
+  }, "action"));
 }
-__name(toClarityCliError, "toClarityCliError");
-function parseResponse(schema, raw) {
-  const parsed = schema.safeParse(raw);
-  if (!parsed.success) {
-    throw new CliError(
-      `Unexpected response from the API: ${parsed.error.message}`
-    );
-  }
-  return parsed.data;
+__name(registerClarityPromoteTransformationProposal, "registerClarityPromoteTransformationProposal");
+
+// src/commands/clarity/revert-current-process.ts
+function registerClarityRevertCurrentProcess(clarity) {
+  clarity.command("revert-current-process <process-id> <snapshot-id>").description("Delete (revert) a current-process snapshot").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Snapshot reverted.");
+  }, "action"));
 }
-__name(parseResponse, "parseResponse");
+__name(registerClarityRevertCurrentProcess, "registerClarityRevertCurrentProcess");
+
+// src/commands/clarity/revert-transformation-proposal.ts
+function registerClarityRevertTransformationProposal(clarity) {
+  clarity.command("revert-transformation-proposal <process-id> <proposal-id>").description("Delete (revert) a transformation-proposal snapshot").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Snapshot reverted.");
+  }, "action"));
+}
+__name(registerClarityRevertTransformationProposal, "registerClarityRevertTransformationProposal");
+
+// src/commands/clarity/stop-transformation-proposal.ts
+function registerClarityStopTransformationProposal(clarity) {
+  clarity.command("stop-transformation-proposal <process-id>").description("Stop an in-flight transformation-proposal generation").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/stop`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Generation stopped.");
+  }, "action"));
+}
+__name(registerClarityStopTransformationProposal, "registerClarityStopTransformationProposal");
 
 // src/commands/clarity/index.ts
 var DEFAULT_LIMIT6 = 50;
@@ -15342,8 +16214,200 @@ var CLARITY_READ_TOOLS = [
       }
     ],
     description: "Read active extra-capture requests for a v2 transformation proposal."
+  },
+  {
+    name: "listClarityArtifactChatConversations",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity artifact-chat-conversations"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/artifact-chat/conversations"
+      }
+    ],
+    description: "List recent artifact-chat conversations for a v2 process and snapshot kind."
+  },
+  {
+    name: "getClarityArtifactChatMessages",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity artifact-chat-messages"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/artifact-chat/conversations/:conversationId/messages"
+      }
+    ],
+    description: "Read messages for one artifact-chat conversation in a v2 process."
+  }
+];
+var CLARITY_WRITE_TOOLS = [
+  {
+    name: "generateClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity generate-current-process"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/current-process"
+      }
+    ],
+    description: "Start asynchronous current-process generation."
+  },
+  {
+    name: "generateClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity generate-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal"
+      }
+    ],
+    description: "Start asynchronous transformation-proposal generation or regeneration."
+  },
+  {
+    name: "promoteClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity promote-current-process"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/current-process/:snapshotId/promote"
+      }
+    ],
+    description: "Promote a current-process snapshot to live."
+  },
+  {
+    name: "promoteClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity promote-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/:proposalId/promote"
+      }
+    ],
+    description: "Promote a transformation-proposal snapshot to live."
+  },
+  {
+    name: "revertClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity revert-current-process"],
+    endpoints: [
+      {
+        method: "DELETE",
+        path: "/v2/clarity-v2/processes/:processId/current-process/:snapshotId"
+      }
+    ],
+    description: "Delete a current-process snapshot."
+  },
+  {
+    name: "revertClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity revert-transformation-proposal"],
+    endpoints: [
+      {
+        method: "DELETE",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/:proposalId"
+      }
+    ],
+    description: "Delete a transformation-proposal snapshot."
+  },
+  {
+    name: "assignClarityExtraCaptureRequest",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity assign-extra-capture-request"],
+    endpoints: [
+      {
+        method: "PATCH",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposals/:proposalId/extra-capture-requests/:requestId/assign"
+      }
+    ],
+    description: "Assign or unassign an extra-capture request."
+  },
+  {
+    name: "postprocessClaritySnapshot",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity postprocess"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/postprocess"
+      }
+    ],
+    description: "Re-run postprocessing for an existing snapshot."
+  },
+  {
+    name: "buildClarityAutomation",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity build-automation"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/automation"
+      }
+    ],
+    description: "Start workflow-builder automation generation from the latest proposal."
+  },
+  {
+    name: "stopClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity stop-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/stop"
+      }
+    ],
+    description: "Stop an in-flight transformation-proposal generation."
+  },
+  {
+    name: "createClarityInviteLink",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity create-invite-link"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/invite-link"
+      }
+    ],
+    description: "Create or regenerate a public Clarity interview invite link."
+  },
+  {
+    name: "importClarityArtifact",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity import-artifact"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/artifact-imports/create-upload-url"
+      },
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/artifact-imports/:captureId/complete"
+      }
+    ],
+    description: "Upload and complete a local Miro SVG, XML, PNG, or JPEG export."
   }
 ];
+var CLARITY_TOOLS = [
+  ...CLARITY_READ_TOOLS,
+  ...CLARITY_WRITE_TOOLS
+];
 var CLARITY_TOOL_COLUMNS = [
   { header: "TOOL", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "SCOPE", cell: /* @__PURE__ */ __name((row) => row.scope, "cell") },
@@ -15354,7 +16418,7 @@ var CLARITY_TOOL_COLUMNS = [
   },
   {
     header: "ENDPOINTS",
-    cell: /* @__PURE__ */ __name((row) => row.endpoints.map((endpoint) => endpoint.path).join(", "), "cell"),
+    cell: /* @__PURE__ */ __name((row) => row.endpoints.map((endpoint) => `${endpoint.method} ${endpoint.path}`).join(", "), "cell"),
     maxWidth: 62
   }
 ];
@@ -15381,6 +16445,20 @@ function registerClarity(program) {
   registerClarityGetCurrentProcess(clarity);
   registerClarityGetTransformationProposal(clarity);
   registerClarityListExtraCaptureRequests(clarity);
+  registerClarityArtifactChatConversations(clarity);
+  registerClarityArtifactChatMessages(clarity);
+  registerClarityGenerateCurrentProcess(clarity);
+  registerClarityGenerateTransformationProposal(clarity);
+  registerClarityPromoteCurrentProcess(clarity);
+  registerClarityPromoteTransformationProposal(clarity);
+  registerClarityRevertCurrentProcess(clarity);
+  registerClarityRevertTransformationProposal(clarity);
+  registerClarityAssignExtraCaptureRequest(clarity);
+  registerClarityPostprocess(clarity);
+  registerClarityBuildAutomation(clarity);
+  registerClarityStopTransformationProposal(clarity);
+  registerClarityCreateInviteLink(clarity);
+  registerClarityImportArtifact(clarity);
 }
 __name(registerClarity, "registerClarity");
 function registerList(clarity) {
@@ -15739,7 +16817,7 @@ function registerExport(clarity) {
 __name(registerExport, "registerExport");
 function registerDoctor(clarity) {
   clarity.command("doctor [process-id]").description(
-    "Check auth, API reachability, read-only tools, and optionally one process context"
+    "Check auth, API reachability, Clarity tools, and optionally one process context"
   ).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function doctorAction(processId, options) {
     const environment = await buildEnvironmentDoctorChecks(this);
     const processChecks = processId === void 0 ? [] : await buildProcessDoctorChecks(environment.config, processId);
@@ -15757,15 +16835,15 @@ function registerDoctor(clarity) {
 }
 __name(registerDoctor, "registerDoctor");
 function registerTools(clarity) {
-  clarity.command("tools").description("List read-only Clarity tools used by the CLI").option("--json", "output JSON").action((options) => {
+  clarity.command("tools").description("List Clarity tools used by the CLI").option("--json", "output JSON").action((options) => {
     if (options.json) {
-      printJson({ tools: CLARITY_READ_TOOLS });
+      printJson({ tools: CLARITY_TOOLS });
       return;
     }
-    console.log(renderTable(CLARITY_TOOL_COLUMNS, CLARITY_READ_TOOLS));
+    console.log(renderTable(CLARITY_TOOL_COLUMNS, CLARITY_TOOLS));
     console.log("");
     console.log(
-      "All listed Clarity tools are read-only GET calls. Generation, promotion, revert, assignment, postprocess, and automation-build commands are not exposed."
+      "Clarity tools include read-only GET calls and explicit write commands for generation, promotion, revert, assignment, postprocess, automation, artifact import, and invite links."
     );
   });
 }
@@ -15887,17 +16965,6 @@ async function loadV2Overview(config, processId, options) {
   };
 }
 __name(loadV2Overview, "loadV2Overview");
-async function requireV2Process(config, processId) {
-  try {
-    return await getClarityV2Process(config, processId);
-  } catch (error) {
-    if (isLegacyV2ReadError(error)) {
-      throw new CliError(CLARITY_V2_REQUIRED_MESSAGE);
-    }
-    throw error;
-  }
-}
-__name(requireV2Process, "requireV2Process");
 function buildWarnings(context) {
   const warnings = [];
   const processId = context.process.process.id;
@@ -15976,14 +17043,14 @@ __name(buildProposalAnchorCheck, "buildProposalAnchorCheck");
 async function buildEnvironmentDoctorChecks(command) {
   const checks = [
     {
-      name: "read_only_surface",
+      name: "command_surface",
       ok: true,
-      detail: "The Clarity CLI registers read commands only; generation, promotion, revert, assignment, postprocess, and automation build routes are not exposed."
+      detail: "The Clarity CLI registers read commands and explicit write commands for public Clarity v2 routes."
     },
     {
-      name: "read_tools_available",
+      name: "tools_available",
       ok: true,
-      detail: `${CLARITY_READ_TOOLS.length} read-only Clarity tools available.`,
+      detail: `${CLARITY_TOOLS.length} Clarity tools available.`,
       next_command: "duvo clarity tools"
     }
   ];
@@ -16086,8 +17153,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z79.object({
-  teams: z79.array(z79.object({ id: z79.string() }))
+var listMyTeamsResponseSchema2 = z84.object({
+  teams: z84.array(z84.object({ id: z84.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -16835,16 +17902,16 @@ function registerConnectionsList(connections) {
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z80 } from "zod";
-var toolSchema = z80.object({
-  name: z80.string(),
-  description: z80.string().optional(),
-  input_schema: z80.record(z80.string(), z80.unknown()).optional()
+import { z as z85 } from "zod";
+var toolSchema = z85.object({
+  name: z85.string(),
+  description: z85.string().optional(),
+  input_schema: z85.record(z85.string(), z85.unknown()).optional()
 });
-var probeResponseSchema = z80.object({
-  success: z80.boolean(),
-  tools: z80.array(toolSchema).optional(),
-  error: z80.string().optional()
+var probeResponseSchema = z85.object({
+  success: z85.boolean(),
+  tools: z85.array(toolSchema).optional(),
+  error: z85.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
 var TABLE_COLUMNS21 = [
@@ -17063,48 +18130,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z81 } from "zod";
-var dateLike = z81.string();
-var secretSchema = z81.object({
-  id: z81.string(),
-  team_id: z81.string(),
-  user_id: z81.string().nullable(),
-  name: z81.string(),
-  service_slug: z81.string().nullable(),
-  env_var_keys: z81.array(z81.string()),
-  created_by: z81.string(),
+import { z as z86 } from "zod";
+var dateLike = z86.string();
+var secretSchema = z86.object({
+  id: z86.string(),
+  team_id: z86.string(),
+  user_id: z86.string().nullable(),
+  name: z86.string(),
+  service_slug: z86.string().nullable(),
+  env_var_keys: z86.array(z86.string()),
+  created_by: z86.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z81.array(secretSchema);
+var secretsListResponseSchema = z86.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z81.object({
-  id: z81.string(),
-  user_id: z81.string().nullable(),
-  team_id: z81.string(),
-  domain: z81.string(),
-  username: z81.string().nullable(),
+var browserLoginSchema = z86.object({
+  id: z86.string(),
+  user_id: z86.string().nullable(),
+  team_id: z86.string(),
+  domain: z86.string(),
+  username: z86.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z81.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z81.object({
-  id: z81.string(),
-  user_id: z81.string().nullable(),
-  team_id: z81.string().nullable(),
-  domain: z81.string(),
-  username: z81.string().nullable(),
+var browserLoginsListResponseSchema = z86.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z86.object({
+  id: z86.string(),
+  user_id: z86.string().nullable(),
+  team_id: z86.string().nullable(),
+  domain: z86.string(),
+  username: z86.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z81.array(
+var revisionLoginsListResponseSchema = z86.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z81.array(secretSchema);
-var successResponseSchema2 = z81.object({
-  success: z81.boolean()
+var revisionSecretsListResponseSchema = z86.array(secretSchema);
+var successResponseSchema2 = z86.object({
+  success: z86.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -20472,94 +21539,176 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z82 } from "zod";
-var publicRunSchema = z82.object({
-  id: z82.string(),
-  agent_id: z82.string(),
-  build_id: z82.string(),
-  status: z82.string(),
-  source: z82.string().nullish(),
-  sandbox_id: z82.string().nullish(),
-  started_at: z82.string().nullish(),
-  completed_at: z82.string().nullish(),
-  created_at: z82.string(),
-  updated_at: z82.string().nullish(),
-  human_in_the_loop_enabled: z82.boolean().nullish()
-});
-var startRunResponseSchema = z82.object({
+import { z as z87 } from "zod";
+var publicRunSchema = z87.object({
+  id: z87.string(),
+  agent_id: z87.string(),
+  build_id: z87.string(),
+  status: z87.string(),
+  source: z87.string().nullish(),
+  sandbox_id: z87.string().nullish(),
+  started_at: z87.string().nullish(),
+  completed_at: z87.string().nullish(),
+  created_at: z87.string(),
+  updated_at: z87.string().nullish(),
+  human_in_the_loop_enabled: z87.boolean().nullish()
+});
+var startRunResponseSchema = z87.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z82.object({
-  label: z82.string(),
-  description: z82.string().nullish()
-});
-var questionSchema = z82.object({
-  question: z82.string(),
-  header: z82.string().nullish(),
-  options: z82.array(questionOptionSchema).nullish(),
-  multi_select: z82.boolean().nullish()
-});
-var pendingHumanRequestSchema = z82.object({
-  id: z82.string(),
-  title: z82.string(),
-  description: z82.string().nullish(),
-  created_at: z82.string(),
-  type: z82.string(),
-  questions: z82.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z82.object({
+var questionOptionSchema = z87.object({
+  label: z87.string(),
+  description: z87.string().nullish()
+});
+var questionSchema = z87.object({
+  question: z87.string(),
+  header: z87.string().nullish(),
+  options: z87.array(questionOptionSchema).nullish(),
+  multi_select: z87.boolean().nullish()
+});
+var pendingHumanRequestSchema = z87.object({
+  id: z87.string(),
+  title: z87.string(),
+  description: z87.string().nullish(),
+  created_at: z87.string(),
+  type: z87.string(),
+  questions: z87.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z87.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z82.object({
-  success: z82.boolean(),
-  message: z82.string().nullish()
-});
-var runMessageSchema = z82.object({
-  id: z82.string(),
-  type: z82.string(),
-  role: z82.string(),
-  timestamp: z82.string(),
-  text_content: z82.string().nullish(),
-  tool_call: z82.object({
-    id: z82.string(),
-    name: z82.string(),
-    arguments: z82.record(z82.string(), z82.unknown()).nullish()
+var stopRunResponseSchema = z87.object({
+  success: z87.boolean(),
+  message: z87.string().nullish()
+});
+var runMessageSchema = z87.object({
+  id: z87.string(),
+  type: z87.string(),
+  role: z87.string(),
+  timestamp: z87.string(),
+  text_content: z87.string().nullish(),
+  tool_call: z87.object({
+    id: z87.string(),
+    name: z87.string(),
+    arguments: z87.record(z87.string(), z87.unknown()).nullish()
   }).nullish(),
-  tool_result: z82.object({
-    tool_call_id: z82.string(),
-    result: z82.unknown().nullish(),
-    error: z82.string().nullish()
+  tool_result: z87.object({
+    tool_call_id: z87.string(),
+    result: z87.unknown().nullish(),
+    error: z87.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z82.object({
-  messages: z82.array(runMessageSchema),
-  total: z82.number().nullish(),
-  limit: z82.number().nullish(),
-  offset: z82.number().nullish()
+var listRunMessagesResponseSchema = z87.object({
+  messages: z87.array(runMessageSchema),
+  total: z87.number().nullish(),
+  limit: z87.number().nullish(),
+  offset: z87.number().nullish()
 });
-var postedMessageSchema = z82.object({
-  id: z82.string(),
-  type: z82.string(),
-  role: z82.string(),
-  timestamp: z82.string(),
-  text_content: z82.string()
+var postedMessageSchema = z87.object({
+  id: z87.string(),
+  type: z87.string(),
+  role: z87.string(),
+  timestamp: z87.string(),
+  text_content: z87.string()
 });
-var postRunMessageResponseSchema = z82.object({
+var postRunMessageResponseSchema = z87.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z82.object({
-  human_request: z82.object({
-    id: z82.string(),
-    run_id: z82.string(),
-    title: z82.string(),
-    description: z82.string().nullish(),
-    response: z82.string().nullish(),
-    responded_at: z82.string().nullish(),
-    created_at: z82.string()
+var respondHumanRequestResponseSchema = z87.object({
+  human_request: z87.object({
+    id: z87.string(),
+    run_id: z87.string(),
+    title: z87.string(),
+    description: z87.string().nullish(),
+    response: z87.string().nullish(),
+    responded_at: z87.string().nullish(),
+    created_at: z87.string()
   })
 });
 
+// src/commands/runs/evaluation.ts
+async function resolveAgentId(runId, apiKey, apiBaseUrl) {
+  const raw = await httpRequest({
+    method: "GET",
+    path: `/v2/runs/${encodeURIComponent(runId)}`,
+    apiKey,
+    apiBaseUrl
+  });
+  const parsed = getRunResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  const { run } = parsed.data;
+  if (!run) {
+    throw new CliError(`Run "${runId}" not found.`);
+  }
+  return run.agent_id;
+}
+__name(resolveAgentId, "resolveAgentId");
+function registerRunsEvaluation(runs) {
+  runs.command("evaluation <run-id>").alias("eval").description("Get the latest evaluation for an agent run").option(
+    "--agent <agent-id>",
+    "agent ID for the run (resolved from the run automatically when omitted)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function evaluationAction(runId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const agentId = options.agent ?? await resolveAgentId(runId, apiKey, apiBaseUrl);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/agent/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/evaluation`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = runEvaluationResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const evaluation = parsed.data.data;
+    if (!evaluation) {
+      console.log(`No evaluation available for run "${runId}".`);
+      return;
+    }
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: evaluation.id },
+        { label: "Run", value: evaluation.run_id },
+        { label: "Source", value: evaluation.source ?? "" },
+        { label: "Created", value: evaluation.created_at }
+      ])
+    );
+    const flags = Object.entries(evaluation.output.data).filter(
+      ([key]) => key !== "final_comment"
+    );
+    if (flags.length > 0) {
+      console.log("");
+      console.log("Rubric:");
+      console.log(
+        renderKeyValue(
+          flags.map(([key, value]) => ({
+            label: key,
+            value: value === null ? "" : String(value)
+          }))
+        )
+      );
+    }
+    const finalComment = evaluation.output.data.final_comment;
+    if (typeof finalComment === "string" && finalComment.length > 0) {
+      console.log("");
+      console.log("Final comment:");
+      console.log(finalComment);
+    }
+  }, "evaluationAction"));
+}
+__name(registerRunsEvaluation, "registerRunsEvaluation");
+
 // src/commands/runs/get.ts
 function registerRunsGet(runs) {
   runs.command("get <id>").description("Get an agent run by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(id, options) {
@@ -21160,6 +22309,7 @@ function registerRuns(program) {
   registerRunsStart(runs);
   registerRunsList(runs);
   registerRunsGet(runs);
+  registerRunsEvaluation(runs);
   registerRunsMessages(runs);
   registerRunsSendMessage(runs);
   registerRunsRespond(runs);
@@ -21168,28 +22318,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z83 } from "zod";
-var createSandboxResponseSchema = z83.object({
-  sandbox_id: z83.string(),
-  expires_at: z83.string()
+import { z as z88 } from "zod";
+var createSandboxResponseSchema = z88.object({
+  sandbox_id: z88.string(),
+  expires_at: z88.string()
 });
-var createSandboxUploadUrlResponseSchema = z83.object({
-  upload_url: z83.string(),
-  path: z83.string(),
-  expires_in_seconds: z83.number()
+var createSandboxUploadUrlResponseSchema = z88.object({
+  upload_url: z88.string(),
+  path: z88.string(),
+  expires_in_seconds: z88.number()
 });
-var sandboxFileSchema = z83.object({
-  name: z83.string(),
-  path: z83.string(),
-  type: z83.enum(["file", "dir"]),
-  size_bytes: z83.number()
+var sandboxFileSchema = z88.object({
+  name: z88.string(),
+  path: z88.string(),
+  type: z88.enum(["file", "dir"]),
+  size_bytes: z88.number()
 });
-var listSandboxFilesResponseSchema = z83.object({
-  files: z83.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z88.object({
+  files: z88.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z83.object({
-  path: z83.string(),
-  size_bytes: z83.number()
+var uploadSandboxFileResponseSchema = z88.object({
+  path: z88.string(),
+  size_bytes: z88.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -21317,8 +22467,8 @@ function registerSandboxesPrepareUploadUrl(sandboxes) {
 __name(registerSandboxesPrepareUploadUrl, "registerSandboxesPrepareUploadUrl");
 
 // src/commands/sandboxes/upload.ts
-import { readFile as readFile5, stat } from "node:fs/promises";
-import { basename } from "node:path";
+import { readFile as readFile6, stat } from "node:fs/promises";
+import { basename as basename2 } from "node:path";
 var MAX_DIRECT_UPLOAD_BYTES = 10 * 1024 * 1024;
 function registerSandboxesUpload(sandboxes) {
   sandboxes.command("upload <sandbox_id> <file>").description(
@@ -21344,11 +22494,11 @@ function registerSandboxesUpload(sandboxes) {
         `File "${file}" is ${stats.size} bytes, larger than the ${MAX_DIRECT_UPLOAD_BYTES}-byte direct-upload limit. Use \`duvo sandboxes prepare-upload-url\` for larger files.`
       );
     }
-    const content = await readFile5(file).catch((error) => {
+    const content = await readFile6(file).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       throw new CliError(`Could not read file "${file}": ${message}`);
     });
-    const filename = basename(file);
+    const filename = basename2(file);
     const formData = new FormData();
     formData.append("file", new Blob([new Uint8Array(content)]), filename);
     if (trimmedPath !== void 0) {
@@ -21800,13 +22950,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { z as z84 } from "zod";
-var createSkillResponseSchema = z84.object({
-  skill: z84.object({
-    id: z84.string(),
-    name: z84.string(),
-    description: z84.string(),
-    team_id: z84.string()
+import { z as z89 } from "zod";
+var createSkillResponseSchema = z89.object({
+  skill: z89.object({
+    id: z89.string(),
+    name: z89.string(),
+    description: z89.string(),
+    team_id: z89.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -22170,13 +23320,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z85 } from "zod";
-var installSkillResponseSchema = z85.object({
-  skill: z85.object({
-    id: z85.string(),
-    name: z85.string(),
-    description: z85.string(),
-    team_id: z85.string()
+import { z as z90 } from "zod";
+var installSkillResponseSchema = z90.object({
+  skill: z90.object({
+    id: z90.string(),
+    name: z90.string(),
+    description: z90.string(),
+    team_id: z90.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -22364,15 +23514,15 @@ function registerSkillsSystem(skills) {
 __name(registerSkillsSystem, "registerSkillsSystem");
 
 // src/commands/skills/upload.ts
-import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
-import { basename as basename2 } from "node:path";
-import { z as z86 } from "zod";
-var uploadSkillResponseSchema = z86.object({
-  skill: z86.object({
-    id: z86.string(),
-    name: z86.string(),
-    description: z86.string(),
-    team_id: z86.string()
+import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
+import { basename as basename3 } from "node:path";
+import { z as z91 } from "zod";
+var uploadSkillResponseSchema = z91.object({
+  skill: z91.object({
+    id: z91.string(),
+    name: z91.string(),
+    description: z91.string(),
+    team_id: z91.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -22386,11 +23536,11 @@ function registerSkillsUpload(skills) {
     if (!fileStats.isFile()) {
       throw new CliError(`Could not read file "${file}": not a regular file`);
     }
-    const content = await readFile6(file).catch((error) => {
+    const content = await readFile7(file).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       throw new CliError(`Could not read file "${file}": ${message}`);
     });
-    const filename = basename2(file);
+    const filename = basename3(file);
     const formData = new FormData();
     formData.append("file", new Blob([new Uint8Array(content)]), filename);
     const config = await requireAuthenticatedConfig(this);
@@ -22587,11 +23737,11 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z87 } from "zod";
+import { z as z92 } 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 = z87.string().regex(TEAM_ID_SHAPE);
-var listMyTeamsResponseSchema3 = z87.object({
-  teams: z87.array(z87.object({ id: z87.string() }))
+var teamIdSchema = z92.string().regex(TEAM_ID_SHAPE);
+var listMyTeamsResponseSchema3 = z92.object({
+  teams: z92.array(z92.object({ id: z92.string() }))
 });
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
@@ -22673,14 +23823,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z88 } from "zod";
-var teamApiSchema2 = z88.object({
-  id: z88.string(),
-  name: z88.string(),
-  organization_id: z88.string().nullable()
+import { z as z93 } from "zod";
+var teamApiSchema2 = z93.object({
+  id: z93.string(),
+  name: z93.string(),
+  organization_id: z93.string().nullable()
 });
-var listMyTeamsResponseSchema4 = z88.object({
-  teams: z88.array(teamApiSchema2)
+var listMyTeamsResponseSchema4 = z93.object({
+  teams: z93.array(teamApiSchema2)
 });
 function registerTeamsList(program) {
   const teams = program.command("teams").description("Inspect the teams your credentials can act on");
@@ -22776,7 +23926,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.3.0";
+    return "1.4.0";
   }
   const packageJsonPath = join2(
     dirname2(fileURLToPath(import.meta.url)),
@@ -22845,7 +23995,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.3.0" };
+    return { name: "@duvoai/cli", version: "1.4.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");