@duvoai/cli 1.3.0 → 1.5.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,13 +1660,34 @@ 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(),
   with_issues: z8.int(),
   flag_distribution: z8.array(evalFlagCountSchema)
 });
+var evalRubricSchema = z8.object({
+  id: z8.guid(),
+  slug: z8.string(),
+  title: z8.string(),
+  description: z8.string(),
+  sort_order: z8.number(),
+  deleted_at: z8.string().nullable()
+});
+var platformEvalRubricSchema = z8.object({
+  key: z8.string(),
+  label: z8.string(),
+  description: z8.string(),
+  cause: z8.string()
+});
+var evalRubricsResponseSchema = z8.object({
+  /** Assignment-specific rubrics persisted in `agent_eval_rubric`. */
+  rubrics: z8.array(evalRubricSchema),
+  /** Platform default rubrics sourced from `EVALUATION_RUBRIC_CATALOG`. */
+  platform_rubrics: z8.array(platformEvalRubricSchema)
+});
 var evalCountsSchema = z8.object({
   total_evaluated: z8.int(),
   with_issues: z8.int()
@@ -1674,7 +1696,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 +1738,7 @@ var AGENT_RUN_SOURCES = [
   "handover",
   "postpone",
   "delegate",
+  "reprocess",
   "trigger"
 ];
 var agentRunSourceSchema = z9.enum(AGENT_RUN_SOURCES);
@@ -1746,6 +1771,7 @@ var SOURCE_TO_INITIATOR = {
   handover: "handover",
   postpone: "case-queue",
   delegate: "case-queue",
+  reprocess: "case-queue",
   trigger: "trigger"
 };
 function mapSourceToInitiator(source) {
@@ -2012,6 +2038,28 @@ function isLegacyModelId(model) {
 }
 __name(isLegacyModelId, "isLegacyModelId");
 __name2(isLegacyModelId, "isLegacyModelId");
+var CONTEXT_1M_MARKER = "[1m]";
+var RUNTIME_AUXILIARY_MODEL_IDS = [
+  "claude-haiku-4-5-20251001"
+];
+function buildModelAliasesForProvider(provider) {
+  if (provider === "bedrock") {
+    const aliasableModelIds = [
+      ...CLAUDE_MODEL_IDS,
+      ...RUNTIME_AUXILIARY_MODEL_IDS
+    ];
+    return Object.fromEntries(
+      aliasableModelIds.map((id) => {
+        const bareId = id.endsWith(CONTEXT_1M_MARKER) ? id.slice(0, -CONTEXT_1M_MARKER.length) : id;
+        const marker = id.slice(bareId.length);
+        return [id, `${bareId}-bedrock${marker}`];
+      })
+    );
+  }
+  return {};
+}
+__name(buildModelAliasesForProvider, "buildModelAliasesForProvider");
+__name2(buildModelAliasesForProvider, "buildModelAliasesForProvider");
 var AGENT_CONFIG_VERSION = "v2";
 var DEFAULT_BROWSER_PROVIDER = "browserbase";
 var LEGACY_DEFAULT_BROWSER_PROVIDER = "browserbase";
@@ -2044,24 +2092,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 +2369,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 +2392,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 +2712,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 +2737,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 +2811,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",
@@ -3280,41 +3335,22 @@ var stepEdgeSchema = z14.object({
     "True on exactly one outgoing edge of an exclusive or inclusive gateway, marking the fallback taken when no other condition matches. False on all other edges."
   )
 });
-var clarityStepBaseSchema = z14.object({
+var baseStepFields = {
   id: z14.string().min(1).describe(
     'Stable identifier for the step. Referenced by targetSteps[].stepId and by postprocessing agents annotating specific steps. Example: "step-review-invoice"'
   ),
-  nodeType: z14.enum(PROCESS_FLOW_NODE_TYPES).describe(
-    'BPMN top-level category. "event" for things that happen (start/end/timer/message/escalation), "task" for work performed, "gateway" for branching decisions.'
-  ),
-  nodeSubtype: z14.enum([
-    ...PROCESS_FLOW_EVENT_SUBTYPES,
-    ...PROCESS_FLOW_TASK_SUBTYPES,
-    ...PROCESS_FLOW_GATEWAY_SUBTYPES
-  ]).describe(
-    'Specific BPMN element. Events: "start", "end", "timer", "message", "escalation". Tasks: "user", "service", "send", "receive", "manual", "businessRule", "script". Gateways: "exclusive", "parallel", "inclusive".'
-  ),
   targetSteps: z14.array(stepEdgeSchema).describe(
     "Outgoing BPMN edges from this step. Empty array only on end events. Exclusive and inclusive gateways must have \u22652 entries with exactly one isDefault: true."
   ),
   title: z14.string().min(1).describe(
-    `Short action-oriented heading, 2-5 words. Used as the step's name in lists and BPMN node labels. Example: "Review invoice"`
-  ),
-  description: z14.string().min(1).describe(
-    'Full prose paragraph describing what happens in this step in natural language. Used for documentation reconstruction. Example: "Finance reviews the invoice in NetSuite, checking line item accuracy and matching against the purchase order before flagging for approval."'
+    'Required node label used in lists and BPMN node labels. Structural markers use defaults such as "Start" and "End".'
   ),
   action: z14.string().min(1).nullable().describe(
     'Verb-led one-liner summarizing the concrete action performed. Example: "Reviews invoice line items in NetSuite against the purchase order."'
   ),
-  rationale: z14.string().min(1).describe(
-    'Why this step exists in the process \u2014 its purpose or business reason. Used by downstream agents to assess whether the step is essential or removable. Example: "Catches mispriced line items before they reach the customer and prevents downstream credit notes."'
-  ),
   role: z14.string().min(1).nullable().describe(
     'Performer of this step \u2014 the specific job title, team, or system. Use "Duvo" for automated actions and "System" for system-triggered steps. Examples: "Finance Analyst", "Sales Operations", "Duvo", "System"'
   ),
-  sources: z14.array(stepSourceSchema).min(1).describe(
-    "Evidence supporting this step's existence and details. At least one source is required \u2014 every step must trace back to something in the captures."
-  ),
   system: z14.string().nullable().describe(
     'System, tool, or application used to perform this step. Null when the step is purely manual or is a decision/event with no associated tool. Examples: "NetSuite", "Gmail", "Excel", null'
   ),
@@ -3324,9 +3360,6 @@ var clarityStepBaseSchema = z14.object({
   output: z14.string().nullable().describe(
     'What this step produces or updates. Null on pure waits or events that emit nothing. Example: "Approved invoice record in NetSuite with reviewer signature"'
   ),
-  condition: z14.string().nullable().describe(
-    'Decision criteria or precondition that gates this step. Null when the step is unconditional. For gateway nodes, this is the question being evaluated. Example: "Only when invoice total exceeds $10,000"'
-  ),
   exception: z14.string().nullable().describe(
     'Known exceptions, errors, or failure modes observed in the captures for this step. Null when none were mentioned. Example: "Customer disputes line items or PO number does not match"'
   ),
@@ -3342,7 +3375,66 @@ var clarityStepBaseSchema = z14.object({
   confidence: z14.enum(["low", "medium", "high"]).describe(
     'Confidence in the accuracy of this step given evidence quality and completeness. "high" = directly stated by multiple sources, "medium" = stated by one source or inferred from strong signals, "low" = inferred with significant assumptions.'
   )
+};
+var eventStepSchema = z14.object({
+  ...baseStepFields,
+  nodeType: z14.literal("event"),
+  nodeSubtype: z14.enum(PROCESS_FLOW_EVENT_SUBTYPES).describe(
+    'BPMN event subtype. "start" (entry trigger), "end" (terminal state), "timer" (time-based wait), "message" (external communication), "escalation" (route to higher authority).'
+  ),
+  description: z14.string().min(1).nullable().describe(
+    "Optional prose describing what happens at this event. May be null for structural markers."
+  ),
+  rationale: z14.string().min(1).nullable().describe(
+    "Optional reason for the event's existence. May be null for structural markers."
+  ),
+  sources: z14.array(stepSourceSchema).describe(
+    "Evidence supporting this event. Empty array allowed (structural markers carry no evidence); non-empty values must follow the source schema."
+  ),
+  condition: z14.string().nullable().describe(
+    "Always null on events; included for shape compatibility across variants."
+  )
+});
+var taskStepSchema = z14.object({
+  ...baseStepFields,
+  nodeType: z14.literal("task"),
+  nodeSubtype: z14.enum(PROCESS_FLOW_TASK_SUBTYPES).describe(
+    'BPMN task subtype. "user" (human work), "service" (automated/API call), "send"/"receive" (messaging), "manual" (offline physical work), "businessRule" (rule engine), "script" (code execution).'
+  ),
+  description: z14.string().min(1).describe(
+    'Full prose paragraph describing what happens in this step in natural language. Used for documentation reconstruction. Example: "Finance reviews the invoice in NetSuite, checking line item accuracy and matching against the purchase order before flagging for approval."'
+  ),
+  rationale: z14.string().min(1).describe(
+    'Why this step exists in the process \u2014 its purpose or business reason. Used by downstream agents to assess whether the step is essential or removable. Example: "Catches mispriced line items before they reach the customer and prevents downstream credit notes."'
+  ),
+  sources: z14.array(stepSourceSchema).min(1).describe(
+    "Evidence supporting this step's existence and details. At least one source is required \u2014 every step must trace back to something in the captures."
+  ),
+  condition: z14.string().nullable().describe(
+    'Optional precondition that gates this task. Null when the task is unconditional. Example: "Only when invoice total exceeds $10,000"'
+  )
+});
+var gatewayStepSchema = z14.object({
+  ...baseStepFields,
+  nodeType: z14.literal("gateway"),
+  nodeSubtype: z14.enum(PROCESS_FLOW_GATEWAY_SUBTYPES).describe(
+    'BPMN gateway subtype. "exclusive" (XOR \u2014 exactly one branch taken), "parallel" (AND \u2014 all branches taken), "inclusive" (OR \u2014 one or more branches taken).'
+  ),
+  description: z14.string().min(1).describe("Full prose describing the decision logic at this gateway."),
+  rationale: z14.string().min(1).describe("Why this branching decision exists in the process."),
+  sources: z14.array(stepSourceSchema).min(1).describe("Evidence supporting the decision criteria."),
+  condition: z14.preprocess(
+    (value) => value == null || value === "" ? "unknown" : value,
+    z14.string().min(1)
+  ).describe(
+    'Decision criteria evaluated at this gateway. BPMN requires this on every branching gateway. Existing rows persisted with null/empty values parse as "unknown" via a read-side preprocess; producers should write a real condition string going forward.'
+  )
 });
+var clarityStepBaseSchema = z14.discriminatedUnion("nodeType", [
+  eventStepSchema,
+  taskStepSchema,
+  gatewayStepSchema
+]);
 var extraCaptureNeededValueSchema = z14.object({
   id: z14.guid().describe(
     "Id of the `clarity_proposal_extra_capture_request` row this slot points at. Created server-side by the agent after the LLM call; the LLM never produces this value."
@@ -3366,7 +3458,27 @@ var bpmnStepReadinessAgentStepSchema = z14.object({
     'One-sentence justification for the readiness rating, citing the specific signals that drove the choice. Example: "Requires human judgement on edge cases that are not documented in the captures."'
   )
 });
-var postprocessClarityStepBaseSchema = clarityStepBaseSchema.extend(extraCaptureNeededAgentStepSchema.shape).extend(bpmnStepReadinessAgentStepSchema.shape).extend({});
+var postprocessAgentSliceShape = {
+  ...extraCaptureNeededAgentStepSchema.shape,
+  ...bpmnStepReadinessAgentStepSchema.shape
+};
+var postprocessEventStepSchema = eventStepSchema.extend(
+  postprocessAgentSliceShape
+);
+var postprocessTaskStepSchema = taskStepSchema.extend(
+  postprocessAgentSliceShape
+);
+var postprocessGatewayStepSchema = gatewayStepSchema.extend(
+  postprocessAgentSliceShape
+);
+var postprocessClarityStepBaseSchema = z14.discriminatedUnion(
+  "nodeType",
+  [
+    postprocessEventStepSchema,
+    postprocessTaskStepSchema,
+    postprocessGatewayStepSchema
+  ]
+);
 var clarityCurrentProcessDataObjectSchema = z14.object({
   version: z14.number().int().describe(
     "Schema version for the current process data payload. Increment on breaking changes to the data shape so consumers can branch on the version field."
@@ -3510,6 +3622,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 +3775,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 +4181,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",
@@ -4735,6 +5007,8 @@ var createOrganizationRequestSchema = z28.object({
 });
 var DISCOVERY_MODES = ["request", "auto"];
 var discoveryModeSchema = z28.enum(DISCOVERY_MODES);
+var LLM_PROVIDERS = ["default", "bedrock"];
+var DEFAULT_LLM_PROVIDER = "default";
 var updateOrganizationRequestSchema = z28.object({
   name: z28.string().min(1).optional(),
   discoveryMode: discoveryModeSchema.optional()
@@ -4892,6 +5166,10 @@ var adminOrgSummarySchema = z29.object({
   discoveryMode: z29.string(),
   enterpriseBillingEnabled: z29.boolean(),
   connectionsSharingEnabled: z29.boolean(),
+  // Optional for backwards compatibility: a response from an older backend
+  // (pre-llm_provider) parses fine and defaults to "default" here. The output
+  // type stays non-optional, so consumers don't need null handling.
+  llmProvider: z29.enum(LLM_PROVIDERS).default(DEFAULT_LLM_PROVIDER),
   createdAt: z29.string().nullable(),
   deletedAt: z29.string().nullable(),
   teamCount: z29.number().int().nonnegative(),
@@ -4954,7 +5232,8 @@ var adminOrgUpdateRequestSchema = z29.object({
   name: z29.string().trim().min(1).max(200).optional(),
   discoveryMode: z29.enum(DISCOVERY_MODES).optional(),
   enterpriseBillingEnabled: z29.boolean().optional(),
-  connectionsSharingEnabled: z29.boolean().optional()
+  connectionsSharingEnabled: z29.boolean().optional(),
+  llmProvider: z29.enum(LLM_PROVIDERS).optional()
 }).refine(
   (val) => Object.values(val).some((v) => v !== void 0),
   "At least one field must be provided"
@@ -5228,7 +5507,14 @@ var integrationConfigApiSchema = z31.object({
   integration_name: z31.string(),
   created_at: z31.string(),
   icon_url: z31.string().nullish(),
-  is_connected: z31.boolean().optional()
+  is_connected: z31.boolean().optional(),
+  /**
+   * Names of case queues linked to this integration config on the live build.
+   * Populated only for `case-queue-producer` and `case-queue-consumer` types;
+   * null for every other integration type, and null when a case-queue config
+   * has no queues linked (PostgreSQL `json_agg` returns NULL on empty input).
+   */
+  linked_queue_names: z31.array(z31.string()).nullish()
 });
 var userScheduleBlockersSchema = z31.object({
   user_id: z31.string(),
@@ -5328,7 +5614,6 @@ var agentApiSchema = z31.object({
   pinned_at: z31.string().nullable().optional(),
   created_at: z31.string().nullable(),
   updated_at: z31.string().nullable(),
-  last_run_at: z31.string().nullable(),
   created_by: z31.object({
     id: z31.string(),
     name: z31.string().nullable(),
@@ -5338,21 +5623,27 @@ var agentApiSchema = z31.object({
     id: z31.string(),
     name: z31.string().nullable(),
     email: z31.string()
-  }).nullable().optional(),
+  }).nullable().optional()
+});
+var agentUserContextApiSchema = z31.object({
+  last_run_at: z31.string().nullable(),
   latest_build: buildApiSchema.nullable(),
   integration_configs: z31.array(integrationConfigApiSchema),
   user_triggers: z31.object({
     slack_mention: z31.boolean(),
     slack_channel: z31.boolean(),
     teams_mention: z31.boolean()
-  }).optional(),
-  case_trigger_enabled: z31.boolean().optional(),
-  case_trigger_has_conflict: z31.boolean().optional(),
-  case_trigger_conflicting_agents: z31.array(conflictingAgentSchema).optional(),
-  case_queue_name: z31.string().nullable().optional()
+  }),
+  case_trigger_enabled: z31.boolean(),
+  case_trigger_has_conflict: z31.boolean(),
+  case_trigger_conflicting_agents: z31.array(conflictingAgentSchema),
+  case_queue_name: z31.string().nullable()
 });
+var agentListItemApiSchema = agentApiSchema.extend(
+  agentUserContextApiSchema.shape
+);
 var agentsListApiSchema = z31.object({
-  agents: z31.array(agentApiSchema),
+  agents: z31.array(agentListItemApiSchema),
   total: z31.int(),
   limit: z31.int(),
   offset: z31.int()
@@ -5741,13 +6032,13 @@ var caseQueueMinSchema = z41.object({
 var caseQueuesForSlotResponseSchema = z41.object({
   queues: z41.array(caseQueueMinSchema)
 });
-var CASE_APPROVAL_DECISION = {
+var APPROVAL_DECISION = {
   APPROVED: "approved",
   REJECTED: "rejected"
 };
-var caseApprovalDecisionSchema = z42.enum([
-  CASE_APPROVAL_DECISION.APPROVED,
-  CASE_APPROVAL_DECISION.REJECTED
+var approvalDecisionSchema = z42.enum([
+  APPROVAL_DECISION.APPROVED,
+  APPROVAL_DECISION.REJECTED
 ]);
 var HUMAN_REQUEST_TITLE_MAX = 200;
 var HUMAN_REQUEST_PROMPT_MAX = 2e3;
@@ -5763,7 +6054,7 @@ var humanRequestBatchRowSchema = z42.object({
    * single shared question across approvers.
    */
   prompt: z42.string(),
-  decision: caseApprovalDecisionSchema.nullable(),
+  decision: approvalDecisionSchema.nullable(),
   responded_at: z42.string().nullable(),
   responded_by_user_id: z42.string().uuid().nullable(),
   responded_by_name: z42.string().nullable(),
@@ -5806,7 +6097,7 @@ var requestCaseApprovalsBatchStatusSchema = z42.enum([
 ]);
 var requestCaseApprovalsDecisionEntrySchema = z42.object({
   assigneeUserId: z42.string().uuid(),
-  decision: caseApprovalDecisionSchema,
+  decision: approvalDecisionSchema,
   respondedAt: z42.string(),
   respondedByUserId: z42.string().uuid()
 });
@@ -5873,6 +6164,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 +6298,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 +6702,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 +7656,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 +7938,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 +8053,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z64.enum([
+var caseFilterStatusSchema = z65.enum([
   "pending",
   "claimed",
   "completed",
@@ -7728,19 +8061,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 +8168,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 +9308,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 +9808,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 +10601,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;
@@ -10625,30 +10958,162 @@ function registerAgentsDelete(agents) {
 }
 __name(registerAgentsDelete, "registerAgentsDelete");
 
+// src/commands/agents/eval-rubrics.ts
+var DESCRIPTION_PREVIEW_WIDTH = 60;
+var RUBRIC_COLUMNS = [
+  { header: "SLUG", cell: /* @__PURE__ */ __name((row) => row.slug, "cell") },
+  { header: "TITLE", cell: /* @__PURE__ */ __name((row) => row.title, "cell") },
+  {
+    header: "DESCRIPTION",
+    cell: /* @__PURE__ */ __name((row) => row.description, "cell"),
+    maxWidth: DESCRIPTION_PREVIEW_WIDTH
+  }
+];
+var PLATFORM_RUBRIC_COLUMNS = [
+  { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
+  { header: "CAUSE", cell: /* @__PURE__ */ __name((row) => row.cause, "cell") },
+  {
+    header: "DESCRIPTION",
+    cell: /* @__PURE__ */ __name((row) => row.description, "cell"),
+    maxWidth: DESCRIPTION_PREVIEW_WIDTH
+  }
+];
+function registerAgentsEvalRubrics(agents) {
+  agents.command("eval-rubrics <agent-id>").description("List an agent's active evaluation rubrics").option(
+    "--build <build-id>",
+    "rubrics for a specific revision (defaults to the agent's live build)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function evalRubricsAction(agentId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    if (options.build) {
+      searchParams.append("build_id", options.build);
+    }
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/agents/${encodeURIComponent(agentId)}/eval-rubrics`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = evalRubricsResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { rubrics, platform_rubrics: platformRubrics } = parsed.data;
+    if (platformRubrics.length > 0) {
+      console.log("Platform rubrics:");
+      console.log(renderTable(PLATFORM_RUBRIC_COLUMNS, platformRubrics));
+      console.log("");
+    }
+    console.log("Assignment-specific rubrics:");
+    if (rubrics.length === 0) {
+      console.log("No assignment-specific rubrics defined for this agent.");
+      return;
+    }
+    console.log(renderTable(RUBRIC_COLUMNS, rubrics));
+  }, "evalRubricsAction"));
+}
+__name(registerAgentsEvalRubrics, "registerAgentsEvalRubrics");
+
+// src/commands/agents/eval-scores.ts
+var SCOPES = ["all", "custom"];
+var DEFAULT_LOOKBACK_DAYS = 30;
+var FLAG_COLUMNS = [
+  { header: "FLAG", cell: /* @__PURE__ */ __name((row) => row.flag, "cell") },
+  { header: "LABEL", cell: /* @__PURE__ */ __name((row) => row.label ?? "", "cell") },
+  { header: "COUNT", cell: /* @__PURE__ */ __name((row) => String(row.count), "cell") }
+];
+function isScope(value) {
+  return SCOPES.includes(value);
+}
+__name(isScope, "isScope");
+function defaultSince() {
+  return new Date(
+    Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3
+  ).toISOString();
+}
+__name(defaultSince, "defaultSince");
+function registerAgentsEvalScores(agents) {
+  agents.command("eval-scores <agent-id>").description("Show aggregate evaluation scores for an agent's jobs").option(
+    "--since <iso>",
+    `only count jobs evaluated after this ISO timestamp (default: last ${DEFAULT_LOOKBACK_DAYS} days)`
+  ).option(
+    "--scope <scope>",
+    "'all' (platform + custom rubrics) or 'custom' (live-build custom rubrics only)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function evalScoresAction(agentId, options) {
+    if (options.scope !== void 0 && !isScope(options.scope)) {
+      throw new CliError(
+        `Invalid --scope "${options.scope}". Expected one of: ${SCOPES.join(", ")}.`
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("since", options.since ?? defaultSince());
+    if (options.scope) {
+      searchParams.append("scope", options.scope);
+    }
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/agent/${encodeURIComponent(agentId)}/eval-scores`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = evalScoresResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { total_evaluated, with_issues, flag_distribution } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "Evaluated", value: String(total_evaluated) },
+        { label: "With issues", value: String(with_issues) }
+      ])
+    );
+    if (flag_distribution.length > 0) {
+      console.log("");
+      console.log(renderTable(FLAG_COLUMNS, flag_distribution));
+    }
+  }, "evalScoresAction"));
+}
+__name(registerAgentsEvalScores, "registerAgentsEvalScores");
+
 // 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,35 +11363,35 @@ 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)
-});
-
-// src/commands/agents/schedules/render-schedule.ts
-function renderScheduleDetails(schedule) {
-  return renderKeyValue([
+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
+function renderScheduleDetails(schedule) {
+  return renderKeyValue([
     { label: "ID", value: schedule.id },
     { label: "Agent", value: schedule.agent_id },
     { label: "Build", value: schedule.build_id },
@@ -11369,33 +11834,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
@@ -11525,7 +11990,7 @@ function registerAgentsTriggersSet(triggers) {
 __name(registerAgentsTriggersSet, "registerAgentsTriggersSet");
 
 // src/commands/agents/triggers/types.ts
-var DESCRIPTION_PREVIEW_WIDTH = 50;
+var DESCRIPTION_PREVIEW_WIDTH2 = 50;
 var TABLE_COLUMNS9 = [
   { header: "INTEGRATION", cell: /* @__PURE__ */ __name((row) => row.integration_slug, "cell") },
   { header: "TRIGGER TYPE", cell: /* @__PURE__ */ __name((row) => row.trigger_type, "cell") },
@@ -11533,7 +11998,7 @@ var TABLE_COLUMNS9 = [
   {
     header: "DESCRIPTION",
     cell: /* @__PURE__ */ __name((row) => row.description, "cell"),
-    maxWidth: DESCRIPTION_PREVIEW_WIDTH
+    maxWidth: DESCRIPTION_PREVIEW_WIDTH2
   }
 ];
 function registerAgentsTriggersTypes(triggers) {
@@ -11712,6 +12177,8 @@ function registerAgents(program) {
   registerAgentsModels(agents);
   registerAgentsSetModel(agents);
   registerAgentsDelete(agents);
+  registerAgentsEvalScores(agents);
+  registerAgentsEvalRubrics(agents);
   registerAgentsSchedules(agents);
   registerAgentsCaseTriggers(agents);
   registerAgentsTriggers(agents);
@@ -12017,55 +12484,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 +12575,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 +13078,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 +13206,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 +13305,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 +14091,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 +14109,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,123 +14240,611 @@ 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);
+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(renderProcessTable, "renderProcessTable");
-function renderCapturesTable(rows) {
-  return renderTable(CAPTURE_TABLE_COLUMNS, rows);
+__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(renderCapturesTable, "renderCapturesTable");
-function renderVersionReport(process2) {
-  const current = process2.current_process_versions;
-  const proposals = process2.transformation_proposal_versions;
-  const defaultCurrent = selectDefaultVersion(current);
-  const defaultProposal = selectDefaultVersion(proposals);
-  const currentTable = current.length === 0 ? "No current-process versions found." : renderTable(
-    [
-      { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
-      { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
-      {
-        header: "DEFAULT",
-        cell: /* @__PURE__ */ __name((row) => row.id === defaultCurrent?.id ? "yes" : "", "cell")
-      },
-      {
-        header: "CREATED",
-        cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
-      },
-      {
-        header: "CREATOR",
-        cell: /* @__PURE__ */ __name((row) => row.creator_type ?? "", "cell")
-      }
-    ],
-    current
-  );
-  const proposalTable = proposals.length === 0 ? "No transformation-proposal versions found." : renderTable(
-    [
-      { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
-      { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
-      {
-        header: "DEFAULT",
-        cell: /* @__PURE__ */ __name((row) => row.id === defaultProposal?.id ? "yes" : "", "cell")
-      },
-      {
-        header: "ANCHOR",
-        cell: /* @__PURE__ */ __name((row) => row.clarity_current_process_id ?? "", "cell"),
-        maxWidth: 38
-      },
-      {
-        header: "CREATED",
-        cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
-      }
-    ],
-    proposals
-  );
-  return [
-    "Default versions",
-    renderKeyValue([
-      {
-        label: "Current",
-        value: defaultCurrent?.id ?? "none"
-      },
-      {
-        label: "Proposal",
-        value: defaultProposal === null ? "none" : `${defaultProposal.id} (anchor ${defaultProposal.clarity_current_process_id ?? "none"})`
-      }
-    ]),
-    "",
-    "Current process versions",
-    currentTable,
-    "",
-    "Transformation proposal versions",
-    proposalTable,
-    "",
-    "Use `duvo clarity compare <process-id> --current <id> --proposal <id>` to compare exact snapshots."
-  ].join("\n");
+__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(renderVersionReport, "renderVersionReport");
-function selectDefaultVersion(rows) {
+__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);
+  const defaultProposal = selectDefaultVersion(proposals);
+  const currentTable = current.length === 0 ? "No current-process versions found." : renderTable(
+    [
+      { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+      { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+      {
+        header: "DEFAULT",
+        cell: /* @__PURE__ */ __name((row) => row.id === defaultCurrent?.id ? "yes" : "", "cell")
+      },
+      {
+        header: "CREATED",
+        cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
+      },
+      {
+        header: "CREATOR",
+        cell: /* @__PURE__ */ __name((row) => row.creator_type ?? "", "cell")
+      }
+    ],
+    current
+  );
+  const proposalTable = proposals.length === 0 ? "No transformation-proposal versions found." : renderTable(
+    [
+      { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+      { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+      {
+        header: "DEFAULT",
+        cell: /* @__PURE__ */ __name((row) => row.id === defaultProposal?.id ? "yes" : "", "cell")
+      },
+      {
+        header: "ANCHOR",
+        cell: /* @__PURE__ */ __name((row) => row.clarity_current_process_id ?? "", "cell"),
+        maxWidth: 38
+      },
+      {
+        header: "CREATED",
+        cell: /* @__PURE__ */ __name((row) => row.created_at, "cell")
+      }
+    ],
+    proposals
+  );
+  return [
+    "Default versions",
+    renderKeyValue([
+      {
+        label: "Current",
+        value: defaultCurrent?.id ?? "none"
+      },
+      {
+        label: "Proposal",
+        value: defaultProposal === null ? "none" : `${defaultProposal.id} (anchor ${defaultProposal.clarity_current_process_id ?? "none"})`
+      }
+    ]),
+    "",
+    "Current process versions",
+    currentTable,
+    "",
+    "Transformation proposal versions",
+    proposalTable,
+    "",
+    "Use `duvo clarity compare <process-id> --current <id> --proposal <id>` to compare exact snapshots."
+  ].join("\n");
+}
+__name(renderVersionReport, "renderVersionReport");
+function selectDefaultVersion(rows) {
   const live = rows.find((row) => row.status === "live");
   return live ?? rows[0] ?? null;
 }
@@ -14816,27 +15730,263 @@ 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()
-  })
+// 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: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    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(
+        "Pass either --current-process-id or --regenerate-from, not both."
+      );
+    }
+    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 { 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)}/current-process/${encodeURIComponent(snapshotId)}`,
-      apiKey,
-      apiBaseUrl
+      resource: "Clarity current-process snapshot"
     });
     if (options.json) {
       printJson(raw);
@@ -14865,26 +16015,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 +16064,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 +16092,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 +16152,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 +16185,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 +16466,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 +16670,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 +16697,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 +17069,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 +17087,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 +17217,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 +17295,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 +17405,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 +18154,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 +18382,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 +21791,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 +22561,7 @@ function registerRuns(program) {
   registerRunsStart(runs);
   registerRunsList(runs);
   registerRunsGet(runs);
+  registerRunsEvaluation(runs);
   registerRunsMessages(runs);
   registerRunsSendMessage(runs);
   registerRunsRespond(runs);
@@ -21168,28 +22570,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 +22719,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 +22746,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 +23202,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 +23572,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 +23766,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 +23788,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 +23989,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 +24075,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 +24178,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.3.0";
+    return "1.5.0";
   }
   const packageJsonPath = join2(
     dirname2(fileURLToPath(import.meta.url)),
@@ -22845,7 +24247,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.3.0" };
+    return { name: "@duvoai/cli", version: "1.5.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");