@duvoai/cli 1.2.0 → 1.4.0

package/dist/bin/duvo.js

@@ -99,6 +99,7 @@ import { z as z61 } from "zod";
 import { z as z62 } from "zod";
 import { z as z63 } from "zod";
 import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -863,7 +864,7 @@ var PLAN_VERSIONS = {
     maxAgents: "unlimited",
     maxAgentRunsPerMonth: 500,
     runCountingMode: "monthly",
-    maxConcurrentRuns: 1,
+    maxConcurrentRuns: 20,
     features: [
       PLAN_FEATURE.BROWSER_AUTOMATION,
       PLAN_FEATURE.ADVANCED_INTEGRATIONS,
@@ -1659,7 +1660,8 @@ var evalSummarySchema = z8.object({
 });
 var evalFlagCountSchema = z8.object({
   flag: z8.string(),
-  count: z8.int()
+  count: z8.int(),
+  label: z8.string().nullable().optional()
 });
 var evalScoresResponseSchema = z8.object({
   total_evaluated: z8.int(),
@@ -1674,7 +1676,9 @@ var evalCountsByAgentResponseSchema = z8.object({
   by_agent: z8.record(z8.string(), evalCountsSchema)
 });
 var summarizeEvalScoresBodySchema = z8.object({
-  since: z8.iso.datetime()
+  since: z8.iso.datetime(),
+  /** `"custom"` restricts to live-build runs + `custom__*` flags only. */
+  scope: z8.enum(["all", "custom"]).optional()
 });
 var summarizeEvalScoresResponseSchema = z8.object({
   data: z8.object({
@@ -1714,6 +1718,7 @@ var AGENT_RUN_SOURCES = [
   "handover",
   "postpone",
   "delegate",
+  "reprocess",
   "trigger"
 ];
 var agentRunSourceSchema = z9.enum(AGENT_RUN_SOURCES);
@@ -1746,6 +1751,7 @@ var SOURCE_TO_INITIATOR = {
   handover: "handover",
   postpone: "case-queue",
   delegate: "case-queue",
+  reprocess: "case-queue",
   trigger: "trigger"
 };
 function mapSourceToInitiator(source) {
@@ -1965,6 +1971,31 @@ var ClaudeModelIdSchema = z11.enum([
   ...CLAUDE_MODEL_IDS,
   ...LEGACY_MODEL_IDS
 ]);
+var AVAILABLE_AGENT_MODELS = {
+  "claude-sonnet-4-6": {
+    displayName: "Claude Sonnet 4.6"
+  },
+  "claude-sonnet-4-6[1m]": {
+    displayName: "Claude Sonnet 4.6",
+    description: "Fast and capable for everyday tasks"
+  },
+  "claude-opus-4-6": {
+    displayName: "Claude Opus 4.6",
+    description: "Advanced model for complex work"
+  },
+  "claude-opus-4-6[1m]": {
+    displayName: "Claude Opus 4.6",
+    description: "Advanced model for complex work"
+  },
+  "claude-opus-4-7": {
+    displayName: "Claude Opus 4.7",
+    description: "Our most capable model \u2014 best for complex work"
+  },
+  "claude-opus-4-7[1m]": {
+    displayName: "Claude Opus 4.7",
+    description: "Our most capable model \u2014 best for complex work"
+  }
+};
 var BrowsingModelIdSchema = z11.enum([
   "gemini-2.5-pro",
   "gemini-2.5-flash",
@@ -2019,24 +2050,6 @@ var BUILD_STATUS = {
   LIVE: "live",
   HISTORIC: "historic"
 };
-var CASE_QUEUE_ITEM_STATUS = {
-  PENDING: "pending",
-  CLAIMED: "claimed",
-  COMPLETED: "completed",
-  FAILED: "failed"
-};
-var RETRYABLE_CASE_STATUSES = [
-  CASE_QUEUE_ITEM_STATUS.COMPLETED,
-  CASE_QUEUE_ITEM_STATUS.FAILED,
-  CASE_QUEUE_ITEM_STATUS.CLAIMED
-];
-function isRetryableCaseStatus(status) {
-  return RETRYABLE_CASE_STATUSES.includes(
-    status
-  );
-}
-__name(isRetryableCaseStatus, "isRetryableCaseStatus");
-__name2(isRetryableCaseStatus, "isRetryableCaseStatus");
 var ALL_EVALUATION_RUBRIC_SEVERITIES = [
   "critical",
   "medium",
@@ -2314,6 +2327,7 @@ var ALL_EVALUATION_RUBRIC_KEYS = Object.keys(
 var PLATFORM_DEFAULT_EVAL_RUBRIC_KEYS = ALL_EVALUATION_RUBRIC_KEYS.filter(
   (k) => EVALUATION_RUBRIC_CATALOG[k].is_default
 );
+var EVALUATION_FINAL_COMMENT_KEY = "final_comment";
 var EVALUATION_SEVERITY_KEY_SUFFIX = "_severity";
 var EVALUATION_REASON_KEY_SUFFIX = "_reason";
 function getRubricSeverityKey(key) {
@@ -2336,6 +2350,23 @@ function isEvaluationRubricKey(value) {
 }
 __name(isEvaluationRubricKey, "isEvaluationRubricKey");
 __name2(isEvaluationRubricKey, "isEvaluationRubricKey");
+var CUSTOM_RUBRIC_KEY_PREFIX = "custom__";
+function isCustomRubricKey(key) {
+  return key.startsWith(CUSTOM_RUBRIC_KEY_PREFIX);
+}
+__name(isCustomRubricKey, "isCustomRubricKey");
+__name2(isCustomRubricKey, "isCustomRubricKey");
+function isFailingFlag(key, value) {
+  if (key === EVALUATION_FINAL_COMMENT_KEY) {
+    return false;
+  }
+  if (typeof value !== "boolean") {
+    return false;
+  }
+  return isCustomRubricKey(key) ? !value : value;
+}
+__name(isFailingFlag, "isFailingFlag");
+__name2(isFailingFlag, "isFailingFlag");
 var EVALUATION_RUBRIC_KEYS_BY_CAUSE = (() => {
   const mutable = {
     sop_gap: [],
@@ -2639,12 +2670,17 @@ var clarityProcessVersionSchema = z12.union([
   z12.literal(1),
   z12.literal(2)
 ]);
+var CLARITY_PROCESS_VISIBILITIES = ["team", "restricted"];
+var clarityProcessVisibilitySchema = z12.enum(
+  CLARITY_PROCESS_VISIBILITIES
+);
 var clarityProcessSchema = z12.object({
   id: z12.guid(),
   teamId: z12.guid(),
   userId: z12.guid(),
   name: z12.string(),
   status: clarityProcessStatusSchema,
+  visibility: clarityProcessVisibilitySchema,
   /** 1 = legacy, 2 = v2. */
   version: z12.number().int(),
   analysis: clarityAnalysisResponseSchema.nullable(),
@@ -2659,6 +2695,7 @@ var clarityProcessListItemSchema = z12.object({
   teamName: z12.string().optional(),
   name: z12.string(),
   status: clarityProcessStatusSchema,
+  visibility: clarityProcessVisibilitySchema,
   version: z12.number().int(),
   captureCount: z12.number(),
   captureCounts: z12.object({
@@ -2732,7 +2769,8 @@ var createClarityProcessResponseSchema = z12.object({
 });
 var updateClarityProcessSchema = z12.object({
   name: z12.string().min(1).max(255).optional(),
-  customPrompt: z12.string().max(5e3).nullable().optional()
+  customPrompt: z12.string().max(5e3).nullable().optional(),
+  visibility: clarityProcessVisibilitySchema.optional()
 });
 var INTERVIEW_LANGUAGES = [
   "en",
@@ -3176,6 +3214,66 @@ function refineStepGraph(steps, ctx) {
 }
 __name(refineStepGraph, "refineStepGraph");
 __name2(refineStepGraph, "refineStepGraph");
+var STRING_ARRAY_FIELDS = ["assumptions", "openQuestions"];
+var NULLABLE_STRING_FIELDS = [
+  "action",
+  "role",
+  "system",
+  "input",
+  "output",
+  "condition",
+  "exception",
+  "handling"
+];
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+__name2(isPlainObject, "isPlainObject");
+function coerceStringArrayField(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? null : [trimmed];
+  }
+  return value;
+}
+__name(coerceStringArrayField, "coerceStringArrayField");
+__name2(coerceStringArrayField, "coerceStringArrayField");
+function coerceNullableStringField(value) {
+  if (typeof value === "string" && value.trim().length === 0) {
+    return null;
+  }
+  return value;
+}
+__name(coerceNullableStringField, "coerceNullableStringField");
+__name2(coerceNullableStringField, "coerceNullableStringField");
+function coerceStepOutput(step) {
+  if (!isPlainObject(step)) {
+    return step;
+  }
+  const next = { ...step };
+  for (const field of STRING_ARRAY_FIELDS) {
+    if (field in next) {
+      next[field] = coerceStringArrayField(next[field]);
+    }
+  }
+  for (const field of NULLABLE_STRING_FIELDS) {
+    if (field in next) {
+      next[field] = coerceNullableStringField(next[field]);
+    }
+  }
+  return next;
+}
+__name(coerceStepOutput, "coerceStepOutput");
+__name2(coerceStepOutput, "coerceStepOutput");
+function coerceStepsOutput(steps) {
+  return steps.map(coerceStepOutput);
+}
+__name(coerceStepsOutput, "coerceStepsOutput");
+__name2(coerceStepsOutput, "coerceStepsOutput");
 var stepSourceSchema = z14.object({
   attribution: z14.string().min(1).describe(
     'Human-readable source label identifying who or what the evidence comes from. Examples: "Anna (sales interview)", "Onboarding SOP \xA73.2", "Slack #ops 2024-06-12"'
@@ -3425,6 +3523,9 @@ var clarityV2ProcessReadModelSchema = z15.object({
     user_id: z15.guid().describe("Creator user id"),
     name: z15.string().describe("Process name"),
     status: clarityProcessStatusSchema.describe("Lifecycle status"),
+    visibility: clarityProcessVisibilitySchema.describe(
+      "Process visibility. 'team' is workspace-visible to full members; 'restricted' is visible to the creator, org admins, workspace managers/admins, and accepted grant holders."
+    ),
     version: z15.number().int().describe("Schema version (always 2 here)"),
     generation_error: z15.string().nullable().describe("Error message from the most recent failed generation, if any"),
     generation_progress: generationProgressSchema.nullable().describe(
@@ -3575,6 +3676,31 @@ function getClarityProcessRoomName(processId) {
 }
 __name(getClarityProcessRoomName, "getClarityProcessRoomName");
 __name2(getClarityProcessRoomName, "getClarityProcessRoomName");
+var clarityExportStatusSchema = z17.enum([
+  "queued",
+  "running",
+  "succeeded",
+  "failed"
+]);
+var clarityExportResultSchema = z17.object({
+  diagramId: z17.string().optional(),
+  diagramName: z17.string().optional(),
+  folderId: z17.string().optional()
+});
+var clarityExportBaseSchema = z17.object({
+  processId: z17.guid(),
+  exportRunId: z17.guid()
+});
+var clarityExportProgressEventDataSchema = clarityExportBaseSchema.extend({
+  status: clarityExportStatusSchema,
+  label: z17.string().optional()
+});
+var clarityExportCompletedEventDataSchema = clarityExportBaseSchema.extend({
+  result: clarityExportResultSchema
+});
+var clarityExportFailedEventDataSchema = clarityExportBaseSchema.extend({
+  error: z17.string()
+});
 var clarityProcessChatConversationStatusSchema = z18.enum([
   "open",
   "running",
@@ -3712,6 +3838,151 @@ var artifactChatMessageUpsertEventDataSchema = z18.object({
   conversation: clarityProcessChatConversationSchema,
   message: clarityProcessChatMessageSchema
 });
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isJsonObject, "isJsonObject");
+__name2(isJsonObject, "isJsonObject");
+function clarityStepsToEaseDocument(steps) {
+  const stepOrder = steps.map((step) => step.id);
+  const stepsById = Object.fromEntries(
+    steps.map((step) => {
+      const {
+        id,
+        readiness: _readiness,
+        readinessRationale: _readinessRationale,
+        extraCaptureNeeded: _extraCaptureNeeded,
+        ...baseStep
+      } = step;
+      return [id, baseStep];
+    })
+  );
+  return { stepOrder, stepsById };
+}
+__name(clarityStepsToEaseDocument, "clarityStepsToEaseDocument");
+__name2(clarityStepsToEaseDocument, "clarityStepsToEaseDocument");
+function assertEaseDocument(value) {
+  if (!isJsonObject(value)) {
+    throw new Error("EASE document must be an object");
+  }
+  if (!Array.isArray(value.stepOrder)) {
+    throw new Error("EASE document stepOrder must be an array");
+  }
+  if (!isJsonObject(value.stepsById)) {
+    throw new Error("EASE document stepsById must be an object");
+  }
+  const stepOrder = value.stepOrder.map((stepId, index) => {
+    if (typeof stepId !== "string" || stepId.length === 0) {
+      throw new Error(`stepOrder[${index}] must be a non-empty string`);
+    }
+    return stepId;
+  });
+  const duplicateStepIds = stepOrder.filter(
+    (stepId, index) => stepOrder.indexOf(stepId) !== index
+  );
+  if (duplicateStepIds.length > 0) {
+    throw new Error(`stepOrder contains duplicate id "${duplicateStepIds[0]}"`);
+  }
+  const stepOrderSet = new Set(stepOrder);
+  const stepEntries = Object.entries(value.stepsById).map(([stepId, step]) => {
+    if (!stepOrderSet.has(stepId)) {
+      throw new Error(`stepsById contains "${stepId}" but stepOrder does not`);
+    }
+    if (!isJsonObject(step)) {
+      throw new Error(`stepsById.${stepId} must be an object`);
+    }
+    if ("id" in step) {
+      throw new Error(`stepsById.${stepId} must not contain an id field`);
+    }
+    const targetSteps = step.targetSteps;
+    if (!Array.isArray(targetSteps)) {
+      throw new Error(`stepsById.${stepId}.targetSteps must be an array`);
+    }
+    targetSteps.forEach((edge, edgeIndex) => {
+      if (!isJsonObject(edge)) {
+        throw new Error(
+          `stepsById.${stepId}.targetSteps[${edgeIndex}] must be an object`
+        );
+      }
+      if (typeof edge.stepId !== "string" || !stepOrderSet.has(edge.stepId)) {
+        throw new Error(
+          `stepsById.${stepId}.targetSteps[${edgeIndex}].stepId "${String(edge.stepId)}" does not match any step id`
+        );
+      }
+    });
+    return [stepId, step];
+  });
+  for (const stepId of stepOrder) {
+    if (!(stepId in value.stepsById)) {
+      throw new Error(`stepOrder contains "${stepId}" but stepsById does not`);
+    }
+  }
+  return {
+    stepOrder,
+    stepsById: Object.fromEntries(stepEntries)
+  };
+}
+__name(assertEaseDocument, "assertEaseDocument");
+__name2(assertEaseDocument, "assertEaseDocument");
+function materializeEaseDocument(easeDocument) {
+  const ease = assertEaseDocument(easeDocument);
+  return {
+    steps: ease.stepOrder.map((stepId) => ({
+      id: stepId,
+      ...ease.stepsById[stepId]
+    }))
+  };
+}
+__name(materializeEaseDocument, "materializeEaseDocument");
+__name2(materializeEaseDocument, "materializeEaseDocument");
+function mergeCurrentProcessPostprocessSlices(previous, steps) {
+  return { ...previous, steps: mergeSteps(previous.steps, steps) };
+}
+__name(mergeCurrentProcessPostprocessSlices, "mergeCurrentProcessPostprocessSlices");
+__name2(mergeCurrentProcessPostprocessSlices, "mergeCurrentProcessPostprocessSlices");
+function mergeTransformationProposalPostprocessSlices(previous, steps) {
+  return { ...previous, steps: mergeSteps(previous.steps, steps) };
+}
+__name(mergeTransformationProposalPostprocessSlices, "mergeTransformationProposalPostprocessSlices");
+__name2(mergeTransformationProposalPostprocessSlices, "mergeTransformationProposalPostprocessSlices");
+function createBaseCurrentProcessData(previous, steps) {
+  return postprocessClarityCurrentProcessDataSchema.parse({
+    version: previous.version,
+    steps: steps.map((step) => clarityStepBaseSchema.parse(step))
+  });
+}
+__name(createBaseCurrentProcessData, "createBaseCurrentProcessData");
+__name2(createBaseCurrentProcessData, "createBaseCurrentProcessData");
+function createBaseTransformationProposalData(previous, steps) {
+  return postprocessClarityTransformationProposalDataSchema.parse({
+    version: previous.version,
+    steps: steps.map((step) => clarityStepBaseSchema.parse(step))
+  });
+}
+__name(createBaseTransformationProposalData, "createBaseTransformationProposalData");
+__name2(createBaseTransformationProposalData, "createBaseTransformationProposalData");
+function mergeSteps(previousSteps, steps) {
+  const previousById = new Map(previousSteps.map((step) => [step.id, step]));
+  return steps.map((step) => {
+    const prev = previousById.get(step.id);
+    if (!prev) {
+      return step;
+    }
+    return {
+      ...step,
+      readiness: step.readiness ?? prev.readiness,
+      readinessRationale: nonEmptyString(step.readinessRationale) ? step.readinessRationale : prev.readinessRationale,
+      extraCaptureNeeded: step.extraCaptureNeeded ?? prev.extraCaptureNeeded
+    };
+  });
+}
+__name(mergeSteps, "mergeSteps");
+__name2(mergeSteps, "mergeSteps");
+function nonEmptyString(value) {
+  return value != null && value.length > 0;
+}
+__name(nonEmptyString, "nonEmptyString");
+__name2(nonEmptyString, "nonEmptyString");
 var MAX_PROCESS_GUIDANCE_PROMPT_CHARS = 500;
 function removeControlCharacters(value) {
   return [...value].map((character) => {
@@ -3811,6 +4082,138 @@ function makeSentryReporter(sentry) {
 }
 __name(makeSentryReporter, "makeSentryReporter");
 __name2(makeSentryReporter, "makeSentryReporter");
+var MAX_BLOCKED_DOMAINS = 1e3;
+var MAX_GUARDRAILS_TEXT_LENGTH = 2e4;
+var DOMAIN_LABEL = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+function stripToHost(value) {
+  if (/^[a-z][a-z0-9+.-]*:\/\//.test(value)) {
+    try {
+      return new URL(value).hostname;
+    } catch {
+      return value;
+    }
+  }
+  const pathStart = ["/", "?", "#"].reduce((idx, ch) => {
+    const at = value.indexOf(ch);
+    return at !== -1 && (idx === -1 || at < idx) ? at : idx;
+  }, -1);
+  const withoutPath = pathStart === -1 ? value : value.slice(0, pathStart);
+  const portStart = withoutPath.indexOf(":");
+  return portStart === -1 ? withoutPath : withoutPath.slice(0, portStart);
+}
+__name(stripToHost, "stripToHost");
+__name2(stripToHost, "stripToHost");
+function normalizeBlockedDomain(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "Empty line" };
+  }
+  const host = stripToHost(trimmed);
+  if (host.includes("*")) {
+    return {
+      ok: false,
+      reason: "Wildcards are not needed \u2014 entering `acme.com` blocks acme.com and all subdomains"
+    };
+  }
+  const normalized = host.replace(/\.$/, "");
+  const wwwStripped = normalized.startsWith("www.") ? normalized.slice(4) : normalized;
+  const candidate = wwwStripped.includes(".") ? wwwStripped : normalized;
+  if (!candidate.includes(".")) {
+    return {
+      ok: false,
+      reason: "Not a valid domain \u2014 must contain at least one dot"
+    };
+  }
+  const labels = candidate.split(".");
+  for (const label of labels) {
+    if (!DOMAIN_LABEL.test(label)) {
+      return {
+        ok: false,
+        reason: `"${label}" is not a valid domain label`
+      };
+    }
+  }
+  return { ok: true, value: candidate };
+}
+__name(normalizeBlockedDomain, "normalizeBlockedDomain");
+__name2(normalizeBlockedDomain, "normalizeBlockedDomain");
+function parseBlockedDomainsList(text3) {
+  const seen = /* @__PURE__ */ new Set();
+  const domains = [];
+  const errors = [];
+  const lines = text3.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const raw = lines[i];
+    if (raw.trim().length === 0) {
+      continue;
+    }
+    const result = normalizeBlockedDomain(raw);
+    if (!result.ok) {
+      errors.push({ line: i + 1, input: raw, reason: result.reason });
+      continue;
+    }
+    if (seen.has(result.value)) {
+      continue;
+    }
+    seen.add(result.value);
+    domains.push(result.value);
+  }
+  return { domains, errors };
+}
+__name(parseBlockedDomainsList, "parseBlockedDomainsList");
+__name2(parseBlockedDomainsList, "parseBlockedDomainsList");
+function domainToCdpBlockPatterns(domain) {
+  return [
+    `*://${domain}/*`,
+    `*://${domain}:*/*`,
+    `*://${domain}./*`,
+    `*://${domain}.:*/*`,
+    `*://*.${domain}/*`,
+    `*://*.${domain}:*/*`,
+    `*://*.${domain}./*`,
+    `*://*.${domain}.:*/*`
+  ];
+}
+__name(domainToCdpBlockPatterns, "domainToCdpBlockPatterns");
+__name2(domainToCdpBlockPatterns, "domainToCdpBlockPatterns");
+function blockedDomainsToCdpPatterns(domains) {
+  return domains.flatMap(domainToCdpBlockPatterns);
+}
+__name(blockedDomainsToCdpPatterns, "blockedDomainsToCdpPatterns");
+__name2(blockedDomainsToCdpPatterns, "blockedDomainsToCdpPatterns");
+function isUrlBlocked(url, blockedDomains) {
+  if (blockedDomains.length === 0) {
+    return { blocked: false };
+  }
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return { blocked: false };
+  }
+  for (const domain of blockedDomains) {
+    if (host === domain || host.endsWith(`.${domain}`)) {
+      return { blocked: true, matchedDomain: domain, host };
+    }
+  }
+  return { blocked: false };
+}
+__name(isUrlBlocked, "isUrlBlocked");
+__name2(isUrlBlocked, "isUrlBlocked");
+function blockedDomainAgentErrorMessage(args) {
+  const { host, matchedDomain } = args;
+  const domainLine = host === matchedDomain ? `"${host}" is on this team's browser blocklist` : `"${host}" matches the blocklist entry "${matchedDomain}" (subdomain match)`;
+  return [
+    `A team admin has restricted access to this domain: ${domainLine}, so it cannot be accessed.`,
+    "",
+    "What to do:",
+    "- Check that you're using the correct URLs in your SOP \u2014 you may be pointing at the wrong site or have a typo in the domain.",
+    `- If you genuinely need this domain, contact your team admin to update Team Settings \u2192 Guardrails (currently blocks "${matchedDomain}").`,
+    "- Do NOT attempt to bypass this restriction by reformatting the URL, using a proxy, or other workarounds \u2014 the request will continue to fail."
+  ].join("\n");
+}
+__name(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
+__name2(blockedDomainAgentErrorMessage, "blockedDomainAgentErrorMessage");
 var ORG_ROLE = {
   EXECUTIVE: "organization:executive",
   OWNER: "organization:owner",
@@ -5643,6 +6046,7 @@ var caseQueueItemEventSchema = z43.object({
   agent_run_id: z43.guid().nullable(),
   human_request_id: z43.guid().nullable(),
   type: z43.string(),
+  reason: z43.string().nullable(),
   created_at: z43.string(),
   agent_id: z43.guid().nullable(),
   agent_name: z43.string().nullable(),
@@ -5776,13 +6180,22 @@ var caseBulkDeleteResponseSchema = z43.object({
   deletedCount: z43.number(),
   interruptedRunIds: z43.array(z43.guid())
 });
-var caseBulkRetryResponseSchema = z43.object({
-  retriedCount: z43.number(),
-  skippedCount: z43.number()
-});
-var caseBulkDelegateResponseSchema = z43.object({
-  delegatedCount: z43.number(),
-  skippedCount: z43.number()
+var caseBulkReprocessResponseSchema = z43.object({
+  reprocessedCount: z43.number(),
+  skippedCount: z43.number(),
+  // Deprecated aliases of `reprocessedCount`, both equal to it. Returned so
+  // clients 308-redirected here from the deprecated `bulk-delegate` /
+  // `bulk-retry` endpoints still find their original field. Optional +
+  // `deprecated` so consumers don't couple to them; removed with those aliases
+  // at the 2026-06-10 sunset.
+  delegatedCount: z43.number().meta({
+    deprecated: true,
+    description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-delegate. Removed on 2026-06-10."
+  }).optional(),
+  retriedCount: z43.number().meta({
+    deprecated: true,
+    description: "Deprecated alias of reprocessedCount, kept for clients redirected from bulk-retry. Removed on 2026-06-10."
+  }).optional()
 });
 var caseBulkStatusUpdateResponseSchema = z43.object({
   updatedCount: z43.number(),
@@ -6171,9 +6584,6 @@ var acceptJoinLinkResponseSchema = z45.object({
 var createClarityProcessInviteLinkRequestSchema = z46.object({
   frontendUrl: z46.url()
 });
-var getClarityProcessInviteLinkQuerySchema = z46.object({
-  frontendUrl: z46.url()
-});
 var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
 var getClarityProcessInviteLinkResponseSchema = z46.object({
   hasLink: z46.boolean(),
@@ -6322,6 +6732,11 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: true,
     description: "Grants a team access to the Windows Remote Desktop beta. Default-on day-one (no known scaling limit); flip off to hide the Enable form and show a Request Access flow on the tile's detail page."
   },
+  CROSS_TEAM_AGENT_MOVE: {
+    key: "cross_team_agent_move",
+    defaultValue: false,
+    description: "Enables the Move Assignment to another team flow. Default-off while we monitor multi-table move semantics in prod; flip on for individual teams to grant access."
+  },
   TEAM_ONTOLOGY: {
     key: "team_ontology",
     defaultValue: false,
@@ -6356,6 +6771,11 @@ var FEATURE_FLAG_CATALOGUE = {
     key: "portfolio_intelligence",
     defaultValue: false,
     description: "Enables portfolio intelligence analysis in the Clarity sidebar, providing cross-process insights and recommendations."
+  },
+  SHARED_CONNECTIONS: {
+    key: "shared_connections",
+    defaultValue: false,
+    description: "Grants connection sharing to teams that are NOT part of an organization (org-less teams have no org-level `connections_sharing_enabled` kill-switch). Resolved with team > global precedence; a global override turns it on for every org-less team. Teams inside an organization are governed solely by their org's setting and are unaffected by this flag."
   }
 };
 var FEATURE_FLAGS = Object.fromEntries(
@@ -7118,7 +7538,14 @@ var RunConfigSchema = AgentConfigSchema.extend({
   conversationHistory: z57.array(ThreadContextMessageSchema).optional(),
   chatFiles: z57.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z57.string().optional()
+  timezone: z57.string().optional(),
+  /**
+   * ISO 8601 timestamp captured when the run was created. Frozen at
+   * run-creation time and never recomputed, so resumes reuse the same value —
+   * the runtime injects it into the cached system prompt and a changing value
+   * would bust the prompt cache.
+   */
+  sessionStartedAt: z57.string().optional()
 });
 var StoredRunConfigV0Schema = z57.object({
   version: z57.literal("v0")
@@ -7393,73 +7820,101 @@ var teamInsightsUsersResponseSchema = z61.object({
   data: z61.array(teamInsightsUserWithAgentsAndRunsSchema),
   total: z61.number()
 });
-var userDismissalListResponseSchema = z62.object({
-  data: z62.array(z62.string())
+var guardrailsAuthorSchema = z62.object({
+  id: z62.guid(),
+  name: z62.string().nullable(),
+  email: z62.email()
+});
+var guardrailsRevisionSchema = z62.object({
+  id: z62.guid(),
+  teamId: z62.guid(),
+  guardrailsText: z62.string().nullable(),
+  blockedDomains: z62.array(z62.string()),
+  createdAt: z62.string(),
+  createdBy: guardrailsAuthorSchema
+});
+var getTeamGuardrailsResponseSchema = z62.object({
+  current: guardrailsRevisionSchema.nullable()
+});
+var listTeamGuardrailsRevisionsQuerySchema = z62.object({
+  limit: z62.coerce.number().int().min(1).max(100).default(20),
+  offset: z62.coerce.number().int().min(0).default(0)
+});
+var listTeamGuardrailsRevisionsResponseSchema = z62.object({
+  revisions: z62.array(guardrailsRevisionSchema),
+  total: z62.number().int().nonnegative()
+});
+var createTeamGuardrailsRevisionRequestSchema = z62.object({
+  guardrailsText: z62.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z62.array(z62.string()).max(MAX_BLOCKED_DOMAINS)
+});
+var userDismissalListResponseSchema = z63.object({
+  data: z63.array(z63.string())
 });
-var userDismissalMutationSchema = z62.object({
-  elementKey: z62.string()
+var userDismissalMutationSchema = z63.object({
+  elementKey: z63.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z63.object({
-  id: z63.guid(),
-  name: z63.string(),
-  server: z63.string(),
-  username: z63.string(),
-  enabled: z63.boolean(),
-  passwordSet: z63.boolean(),
-  organizationCount: z63.number().int().nonnegative(),
-  createdAt: z63.string(),
-  updatedAt: z63.string()
-});
-var vpnProxyConfigListResponseSchema = z63.object({
-  configs: z63.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z63.object({
-  name: z63.string().trim().min(1).max(NAME_MAX),
-  server: z63.string().trim().min(1).max(URL_MAX).url(),
-  username: z63.string().trim().min(1).max(USERNAME_MAX),
-  password: z63.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z63.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z63.object({
+var vpnProxyConfigSummarySchema = z64.object({
+  id: z64.guid(),
+  name: z64.string(),
+  server: z64.string(),
+  username: z64.string(),
+  enabled: z64.boolean(),
+  passwordSet: z64.boolean(),
+  organizationCount: z64.number().int().nonnegative(),
+  createdAt: z64.string(),
+  updatedAt: z64.string()
+});
+var vpnProxyConfigListResponseSchema = z64.object({
+  configs: z64.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z64.object({
+  name: z64.string().trim().min(1).max(NAME_MAX),
+  server: z64.string().trim().min(1).max(URL_MAX).url(),
+  username: z64.string().trim().min(1).max(USERNAME_MAX),
+  password: z64.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z64.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z63.object({
-  name: z63.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z63.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z63.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z63.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z63.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z64.object({
+  name: z64.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z64.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z64.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z64.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z64.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z63.object({
+var vpnProxyConfigUpdateResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z63.object({
-  success: z63.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z64.object({
+  success: z64.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z63.object({
-  id: z63.guid(),
-  organizationId: z63.guid(),
-  organizationName: z63.string(),
-  attachedAt: z63.string()
+var vpnProxyConfigOrganizationSchema = z64.object({
+  id: z64.guid(),
+  organizationId: z64.guid(),
+  organizationName: z64.string(),
+  attachedAt: z64.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z63.object({
-  organizations: z63.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z64.object({
+  organizations: z64.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z63.object({
-  organizationId: z63.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z64.object({
+  organizationId: z64.guid()
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z63.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z64.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z63.object({
-  success: z63.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z64.object({
+  success: z64.literal(true)
 });
-var vpnProxyConfigForOrganizationResponseSchema = z63.object({
+var vpnProxyConfigForOrganizationResponseSchema = z64.object({
   config: vpnProxyConfigSummarySchema.nullable()
 });
 function canonicalizeSopInput(config) {
@@ -7480,7 +7935,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z64.enum([
+var caseFilterStatusSchema = z65.enum([
   "pending",
   "claimed",
   "completed",
@@ -7488,19 +7943,19 @@ var caseFilterStatusSchema = z64.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z64.object({
-  status: z64.array(caseFilterStatusSchema).optional(),
-  created_at_from: z64.string().optional(),
-  updated_at_from: z64.string().optional(),
-  labels: z64.record(z64.string(), z64.array(z64.string())).optional()
+var casesFiltersSchema = z65.object({
+  status: z65.array(caseFilterStatusSchema).optional(),
+  created_at_from: z65.string().optional(),
+  updated_at_from: z65.string().optional(),
+  labels: z65.record(z65.string(), z65.array(z65.string())).optional()
 });
-var casesListRequestBodySchema = z64.object({
+var casesListRequestBodySchema = z65.object({
   filters: casesFiltersSchema.default({}),
-  limit: z64.int().min(1).max(100).default(25),
-  offset: z64.int().min(0).default(0),
-  sort_by: z64.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z64.enum(["asc", "desc"]).default("desc"),
-  search: z64.string().optional()
+  limit: z65.int().min(1).max(100).default(25),
+  offset: z65.int().min(0).default(0),
+  sort_by: z65.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z65.enum(["asc", "desc"]).default("desc"),
+  search: z65.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -7595,7 +8050,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z64.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z65.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -8735,11 +9190,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z65 } from "zod";
-var optionalEnvString = z65.string().optional().transform(
+import { z as z66 } from "zod";
+var optionalEnvString = z66.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z65.object({
+var CliEnvSchema = z66.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -9235,9 +9690,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z66 } from "zod";
-var teamSchema = z66.object({ id: z66.string() });
-var listMyTeamsResponseSchema = z66.object({ teams: z66.array(teamSchema) });
+import { z as z67 } from "zod";
+var teamSchema = z67.object({ id: z67.string() });
+var listMyTeamsResponseSchema = z67.object({ teams: z67.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -10028,40 +10483,56 @@ import { readFile as readFile2 } from "node:fs/promises";
 import { confirm as confirm2, isCancel as isCancel2, text } from "@clack/prompts";
 
 // src/api/agent-schemas.ts
-import { z as z67 } from "zod";
-var publicAgentSchema = z67.object({
-  id: z67.string(),
-  name: z67.string(),
-  slack_enabled: z67.boolean().nullish(),
-  microsoft_teams_enabled: z67.boolean().nullish(),
-  agentic_memory_enabled: z67.boolean().nullish(),
-  thread_id: z67.string().nullish(),
-  created_at: z67.string().nullish(),
-  updated_at: z67.string().nullish()
-});
-var publicBuildSchema = z67.object({
-  id: z67.string(),
-  agent_id: z67.string(),
-  name: z67.string(),
-  revision_number: z67.number().nullish(),
-  created_at: z67.string().nullish(),
-  updated_at: z67.string().nullish()
-});
-var listAgentsResponseSchema = z67.object({
-  agents: z67.array(publicAgentSchema),
-  total: z67.number().nullish(),
-  limit: z67.number().nullish(),
-  offset: z67.number().nullish()
-});
-var getAgentResponseSchema = z67.object({
+import { z as z69 } from "zod";
+
+// src/api/json-value.ts
+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 = 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 = z67.object({
+var createAgentResponseSchema = z69.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z67.object({
-  success: z67.literal(true)
+var deleteAgentResponseSchema = z69.object({
+  success: z69.literal(true)
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -10071,6 +10542,77 @@ var DEFAULT_BUILD_CONFIG = {
   data: DEFAULT_AGENT_CONFIG
 };
 
+// src/commands/shared/is-interactive-terminal.ts
+function isInteractiveTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+__name(isInteractiveTerminal, "isInteractiveTerminal");
+
+// src/commands/agents/model-option.ts
+var MODEL_IDS = CLAUDE_MODEL_IDS;
+var NO_MODEL_LABEL = "\u2014";
+function modelFromConfig(config) {
+  if (config === null || config === void 0) {
+    return NO_MODEL_LABEL;
+  }
+  const { config: parsed } = parseAgentConfig(config);
+  return parsed ? parsed.models.agent.model : NO_MODEL_LABEL;
+}
+__name(modelFromConfig, "modelFromConfig");
+function isCoreClaudeModelId(value) {
+  return MODEL_IDS.includes(value);
+}
+__name(isCoreClaudeModelId, "isCoreClaudeModelId");
+function formatModelChoices() {
+  return MODEL_IDS.map(
+    (id) => `  ${id} \u2014 ${AVAILABLE_AGENT_MODELS[id].displayName}`
+  ).join("\n");
+}
+__name(formatModelChoices, "formatModelChoices");
+function resolveModelFlag(flag) {
+  const trimmed = flag.trim();
+  if (trimmed.length === 0) {
+    throw new CliError("--model must not be empty");
+  }
+  if (!isCoreClaudeModelId(trimmed)) {
+    throw new CliError(
+      `Unknown model "${trimmed}". Available models:
+${formatModelChoices()}`
+    );
+  }
+  return trimmed;
+}
+__name(resolveModelFlag, "resolveModelFlag");
+function listAgentModels() {
+  return MODEL_IDS.map((id) => ({
+    id,
+    displayName: AVAILABLE_AGENT_MODELS[id].displayName,
+    description: AVAILABLE_AGENT_MODELS[id].description ?? "",
+    isDefault: id === PLATFORM_DEFAULT_MODELS.agent.model
+  }));
+}
+__name(listAgentModels, "listAgentModels");
+function buildModelPickerOptions() {
+  return MODEL_IDS.map((id) => ({
+    value: id,
+    label: `${AVAILABLE_AGENT_MODELS[id].displayName} (${id})`
+  }));
+}
+__name(buildModelPickerOptions, "buildModelPickerOptions");
+function applyModelToConfig(config, model) {
+  return {
+    ...config,
+    data: {
+      ...config.data,
+      models: {
+        ...config.data.models,
+        agent: { ...config.data.models.agent, model }
+      }
+    }
+  };
+}
+__name(applyModelToConfig, "applyModelToConfig");
+
 // src/commands/agents/create.ts
 function registerAgentsCreate(agents) {
   agents.command("create").description("Create a new agent").option("--name <name>", "human-readable agent name").option(
@@ -10079,11 +10621,18 @@ function registerAgentsCreate(agents) {
   ).option(
     "--config <path>",
     "path to a JSON file with the full build config (overrides --input)"
+  ).option(
+    "--model <model>",
+    "Claude model the agent should use (overrides the model in --config)"
   ).option("--no-build", "create the agent without an initial build").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
     const resolved = await requireAuthenticatedConfig(this);
     const teamId = await resolveRequiredTeamId(resolved, {
       override: getTeamFlag(this)
     });
+    const model = options.model !== void 0 ? resolveModelFlag(options.model) : void 0;
+    if (options.build === false && model !== void 0) {
+      throw new CliError("--model cannot be combined with --no-build.");
+    }
     const name = await resolveName(options.name);
     const body = { name };
     if (options.build !== false) {
@@ -10091,7 +10640,7 @@ function registerAgentsCreate(agents) {
       if (config) {
         body.build = {
           name: DEFAULT_BUILD_NAME,
-          config
+          config: model ? applyModelToConfig(config, model) : config
         };
       }
     }
@@ -10120,6 +10669,12 @@ function registerAgentsCreate(agents) {
     ];
     if (build) {
       entries.push({ label: "Build", value: `${build.id} (${build.name})` });
+      if (body.build) {
+        entries.push({
+          label: "Model",
+          value: modelFromConfig(body.build.config)
+        });
+      }
     }
     console.log(green("Agent created!"));
     console.log();
@@ -10127,10 +10682,6 @@ function registerAgentsCreate(agents) {
   }, "createAction"));
 }
 __name(registerAgentsCreate, "registerAgentsCreate");
-function isInteractiveTerminal() {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-__name(isInteractiveTerminal, "isInteractiveTerminal");
 async function resolveName(flag) {
   if (flag !== void 0) {
     const trimmed2 = flag.trim();
@@ -10289,7 +10840,56 @@ function registerAgentsDelete(agents) {
 }
 __name(registerAgentsDelete, "registerAgentsDelete");
 
+// src/api/build-schemas.ts
+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: z70.number().nullish(),
+  created_at: z70.string().nullish(),
+  updated_at: z70.string().nullish()
+});
+var listBuildsResponseSchema2 = z70.object({
+  builds: z70.array(publicBuildSchema2),
+  total: z70.number().nullish(),
+  limit: z70.number().nullish(),
+  offset: z70.number().nullish()
+});
+var getBuildResponseSchema = z70.object({
+  build: publicBuildSchema2
+});
+var createBuildResponseSchema = z70.object({
+  build: publicBuildSchema2,
+  agent: z70.object({ id: z70.string() })
+});
+
 // src/commands/agents/get.ts
+async function fetchLatestModel(agentId, apiKey, apiBaseUrl) {
+  const searchParams = new URLSearchParams();
+  searchParams.append("limit", "1");
+  searchParams.append("offset", "0");
+  try {
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/agents/${encodeURIComponent(agentId)}/revisions`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    const parsed = listBuildsResponseSchema2.safeParse(raw);
+    if (!parsed.success) {
+      return NO_MODEL_LABEL;
+    }
+    const latest = parsed.data.builds[0];
+    return latest ? modelFromConfig(latest.config) : NO_MODEL_LABEL;
+  } catch {
+    return NO_MODEL_LABEL;
+  }
+}
+__name(fetchLatestModel, "fetchLatestModel");
 function registerAgentsGet(agents) {
   agents.command("get <id>").description("Get an agent by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(id, options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -10310,10 +10910,12 @@ function registerAgentsGet(agents) {
       );
     }
     const { agent } = parsed.data;
+    const model = await fetchLatestModel(agent.id, apiKey, apiBaseUrl);
     console.log(
       renderKeyValue([
         { label: "ID", value: agent.id },
         { label: "Name", value: agent.name },
+        { label: "Model", value: model },
         { label: "Created", value: agent.created_at ?? "" },
         { label: "Updated", value: agent.updated_at ?? "" }
       ])
@@ -10356,6 +10958,10 @@ var MAX_LIMIT = 100;
 var TABLE_COLUMNS4 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
+  {
+    header: "MODEL",
+    cell: /* @__PURE__ */ __name((row) => modelFromConfig(row.latest_build?.config), "cell")
+  },
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerAgentsList(agents) {
@@ -10479,31 +11085,58 @@ function registerAgentsMemory(agents) {
 }
 __name(registerAgentsMemory, "registerAgentsMemory");
 
+// src/commands/agents/models.ts
+var DEFAULT_MARKER = "\u2713";
+var TABLE_COLUMNS6 = [
+  { header: "MODEL", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.displayName, "cell") },
+  {
+    header: "DEFAULT",
+    cell: /* @__PURE__ */ __name((row) => row.isDefault ? DEFAULT_MARKER : "", "cell")
+  },
+  { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
+];
+function registerAgentsModels(agents) {
+  agents.command("models").description("List the LLM models available for agents").option("--json", "output raw JSON").action(/* @__PURE__ */ __name(function modelsAction(options) {
+    const models = listAgentModels();
+    if (options.json) {
+      printJson(models);
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS6, models));
+    console.log();
+    console.log(
+      `Use a MODEL value with \`duvo agents create --model <model>\` or \`duvo agents set-model <id> --model <model>\`.`
+    );
+  }, "modelsAction"));
+}
+__name(registerAgentsModels, "registerAgentsModels");
+
 // src/api/schedule-schemas.ts
-import { z as z68 } from "zod";
-var publicScheduleSchema = z68.object({
-  id: z68.string(),
-  build_id: z68.string(),
-  agent_id: z68.string(),
-  user_id: z68.string(),
-  enabled: z68.boolean(),
-  frequency: z68.string(),
-  time: z68.string().nullish(),
-  timezone: z68.string(),
-  day: z68.string().nullish(),
-  day_of_month: z68.number().nullish(),
-  cron: z68.string().nullish(),
-  source: z68.string().nullish(),
-  task: z68.string().nullish(),
-  recurring: z68.boolean().nullish(),
-  created_at: z68.string(),
-  updated_at: z68.string()
-});
-var listSchedulesResponseSchema = z68.object({
-  schedules: z68.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z68.object({
-  success: z68.literal(true)
+import { z as z71 } from "zod";
+var publicScheduleSchema = z71.object({
+  id: z71.string(),
+  build_id: z71.string(),
+  agent_id: z71.string(),
+  user_id: z71.string(),
+  enabled: z71.boolean(),
+  frequency: z71.string(),
+  time: z71.string().nullish(),
+  timezone: z71.string(),
+  day: z71.string().nullish(),
+  day_of_month: z71.number().nullish(),
+  cron: z71.string().nullish(),
+  source: z71.string().nullish(),
+  task: z71.string().nullish(),
+  recurring: z71.boolean().nullish(),
+  created_at: z71.string(),
+  updated_at: z71.string()
+});
+var listSchedulesResponseSchema = z71.object({
+  schedules: z71.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z71.object({
+  success: z71.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -10682,7 +11315,7 @@ __name(registerAgentsSchedulesDelete, "registerAgentsSchedulesDelete");
 
 // src/commands/agents/schedules/list.ts
 var TASK_PREVIEW_WIDTH = 40;
-var TABLE_COLUMNS6 = [
+var TABLE_COLUMNS7 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   {
     header: "ENABLED",
@@ -10741,7 +11374,7 @@ function registerAgentsSchedulesList(schedules) {
       console.log("No schedules found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS6, rows));
+    console.log(renderTable(TABLE_COLUMNS7, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -10860,39 +11493,129 @@ function registerAgentsSchedules(agents) {
 }
 __name(registerAgentsSchedules, "registerAgentsSchedules");
 
+// src/commands/agents/set-model.ts
+import { isCancel as isCancel3, select } from "@clack/prompts";
+async function resolveModel(flag) {
+  if (flag !== void 0) {
+    return resolveModelFlag(flag);
+  }
+  if (!isInteractiveTerminal()) {
+    throw new CliError(
+      "--model is required in non-interactive shells (e.g. --model claude-opus-4-7)."
+    );
+  }
+  const answer = await select({
+    message: "Select a model for this agent",
+    options: buildModelPickerOptions()
+  });
+  if (isCancel3(answer)) {
+    throw new CancelCliError("Model switch cancelled.");
+  }
+  return answer;
+}
+__name(resolveModel, "resolveModel");
+function buildConfigWithModel(rawConfig, model) {
+  const { config } = parseAgentConfig(rawConfig);
+  const data = config ?? DEFAULT_AGENT_CONFIG;
+  return {
+    version: AGENT_CONFIG_VERSION,
+    data: {
+      ...data,
+      models: {
+        ...data.models,
+        agent: { ...data.models.agent, model }
+      }
+    }
+  };
+}
+__name(buildConfigWithModel, "buildConfigWithModel");
+function registerAgentsSetModel(agents) {
+  agents.command("set-model <id>").description("Switch the LLM model used by an agent's latest revision").option(
+    "--model <model>",
+    "Claude model to switch to (interactive picker when omitted)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function setModelAction(id, options) {
+    const agentId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const model = await resolveModel(options.model);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", "1");
+    searchParams.append("offset", "0");
+    const listRaw = await httpRequest({
+      method: "GET",
+      path: `/v2/agents/${encodeURIComponent(agentId)}/revisions`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    const listParsed = listBuildsResponseSchema2.safeParse(listRaw);
+    if (!listParsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${listParsed.error.message}`
+      );
+    }
+    const latest = listParsed.data.builds[0];
+    if (!latest) {
+      throw new CliError(
+        "This agent has no revisions yet. Create one with `duvo builds create` first."
+      );
+    }
+    const config = buildConfigWithModel(latest.config, model);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v2/revisions/${encodeURIComponent(latest.id)}`,
+      apiKey,
+      apiBaseUrl,
+      body: { config }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log(green("Model updated!"));
+    console.log(
+      renderKeyValue([
+        { label: "Agent", value: agentId },
+        { label: "Revision", value: latest.id },
+        { label: "Model", value: model }
+      ])
+    );
+  }, "setModelAction"));
+}
+__name(registerAgentsSetModel, "registerAgentsSetModel");
+
 // src/api/trigger-schemas.ts
-import { z as z69 } from "zod";
-var triggerSchema = z69.object({
-  id: z69.string(),
-  agent_id: z69.string(),
-  user_id: z69.string(),
-  integration_slug: z69.string(),
-  trigger_type: z69.string(),
-  filter_config: z69.record(z69.string(), z69.unknown()),
-  integration_instance_id: z69.string(),
-  enabled: z69.boolean(),
-  created_at: z69.string(),
-  updated_at: z69.string()
-});
-var listTriggersResponseSchema = z69.object({
-  triggers: z69.array(triggerSchema)
-});
-var triggerTypeSchema = z69.object({
-  integration_slug: z69.string(),
-  integration_name: z69.string(),
-  icon_url: z69.string(),
-  trigger_type: z69.string(),
-  label: z69.string(),
-  description: z69.string(),
-  filter_schema: z69.record(z69.string(), z69.unknown())
-});
-var listTriggerTypesResponseSchema = z69.object({
-  trigger_types: z69.array(triggerTypeSchema)
+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 = z72.object({
+  triggers: z72.array(triggerSchema)
+});
+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 = z72.object({
+  trigger_types: z72.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
 var FILTER_PREVIEW_WIDTH = 40;
-var TABLE_COLUMNS7 = [
+var TABLE_COLUMNS8 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "INTEGRATION", cell: /* @__PURE__ */ __name((row) => row.integration_slug, "cell") },
   { header: "TRIGGER TYPE", cell: /* @__PURE__ */ __name((row) => row.trigger_type, "cell") },
@@ -10936,7 +11659,7 @@ function registerAgentsTriggersList(triggers) {
       console.log("No triggers found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS7, rows));
+    console.log(renderTable(TABLE_COLUMNS8, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -11018,7 +11741,7 @@ __name(registerAgentsTriggersSet, "registerAgentsTriggersSet");
 
 // src/commands/agents/triggers/types.ts
 var DESCRIPTION_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS8 = [
+var TABLE_COLUMNS9 = [
   { header: "INTEGRATION", cell: /* @__PURE__ */ __name((row) => row.integration_slug, "cell") },
   { header: "TRIGGER TYPE", cell: /* @__PURE__ */ __name((row) => row.trigger_type, "cell") },
   { header: "LABEL", cell: /* @__PURE__ */ __name((row) => row.label, "cell") },
@@ -11055,7 +11778,7 @@ function registerAgentsTriggersTypes(triggers) {
       console.log("No trigger types available.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS8, rows));
+    console.log(renderTable(TABLE_COLUMNS9, rows));
     console.log(`Showing ${rows.length}`);
   }, "typesAction"));
 }
@@ -11201,6 +11924,8 @@ function registerAgents(program) {
   registerAgentsGet(agents);
   registerAgentsCreate(agents);
   registerAgentsUpdate(agents);
+  registerAgentsModels(agents);
+  registerAgentsSetModel(agents);
   registerAgentsDelete(agents);
   registerAgentsSchedules(agents);
   registerAgentsCaseTriggers(agents);
@@ -11507,55 +12232,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z70 } from "zod";
-var integrationSchema = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  type: z70.string(),
-  provider: z70.string(),
-  user_id: z70.string().nullable(),
-  team_id: z70.string(),
-  server_url: z70.string().optional(),
-  transport_type: z70.string().optional(),
-  auth_method: z70.string().nullish(),
-  composio_mcp_id: z70.string().nullish(),
-  custom_integration_id: z70.string().nullish(),
-  icon_url: z70.string().nullish(),
-  oauth_provider: z70.string().nullish(),
-  oauth_provider_key: z70.string().nullish(),
-  oauth_scopes: z70.array(z70.string()).nullish(),
-  integration_id: z70.string().nullish(),
-  created_at: z70.string(),
-  updated_at: z70.string()
-});
-var integrationsListResponseSchema2 = z70.object({
-  integrations: z70.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 = z70.object({
-  id: z70.string(),
-  integration_id: z70.string().nullable(),
-  custom_integration_id: z70.string().nullable(),
-  integration_type: z70.string(),
-  integration_name: z70.string(),
-  created_at: z70.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 = z70.object({
-  integrations: z70.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z73.object({
+  integrations: z73.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z70.object({
-  success: z70.boolean(),
-  count: z70.number()
+var attachBuildIntegrationsResponseSchema = z73.object({
+  success: z73.boolean(),
+  count: z73.number()
 });
-var buildIntegrationConnectionSchema = z70.object({
-  connection_id: z70.string(),
-  created_at: z70.string()
+var buildIntegrationConnectionSchema = z73.object({
+  connection_id: z73.string(),
+  created_at: z73.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z70.object({
-  connections: z70.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z73.object({
+  connections: z73.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z70.object({
-  success: z70.boolean()
+var successResponseSchema = z73.object({
+  success: z73.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -11598,17 +12323,17 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z71 } from "zod";
-var slotSchema = z71.object({
-  config_id: z71.string(),
-  integration_type: z71.string(),
-  linked_queue_count: z71.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 = z71.object({
-  configs: z71.array(slotSchema),
-  has_available_queues: z71.boolean()
+var responseSchema2 = z74.object({
+  configs: z74.array(slotSchema),
+  has_available_queues: z74.boolean()
 });
-var TABLE_COLUMNS9 = [
+var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.integration_type, "cell") },
   { header: "QUEUES", cell: /* @__PURE__ */ __name((row) => String(row.linked_queue_count), "cell") },
@@ -11643,7 +12368,7 @@ function registerBuildIntegrationsCaseQueueSetup(buildIntegrations) {
       console.log("No case-queue integration slots on this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS9, configs));
+    console.log(renderTable(TABLE_COLUMNS10, configs));
     const unmapped = configs.filter((slot) => slot.linked_queue_count === 0);
     if (unmapped.length > 0) {
       console.log(
@@ -11662,7 +12387,7 @@ function registerBuildIntegrationsCaseQueueSetup(buildIntegrations) {
 __name(registerBuildIntegrationsCaseQueueSetup, "registerBuildIntegrationsCaseQueueSetup");
 
 // src/commands/build-integrations/connections-list.ts
-var TABLE_COLUMNS10 = [
+var TABLE_COLUMNS11 = [
   {
     header: "CONNECTION ID",
     cell: /* @__PURE__ */ __name((row) => row.connection_id, "cell")
@@ -11701,7 +12426,7 @@ function registerBuildIntegrationsConnectionsList(connections) {
       console.log("No connections pinned to this slot.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS10, rows));
+    console.log(renderTable(TABLE_COLUMNS11, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -11771,7 +12496,7 @@ function registerBuildIntegrationsConnectionsUnpin(connections) {
 __name(registerBuildIntegrationsConnectionsUnpin, "registerBuildIntegrationsConnectionsUnpin");
 
 // src/commands/build-integrations/list.ts
-var TABLE_COLUMNS11 = [
+var TABLE_COLUMNS12 = [
   {
     header: "INTEGRATION ID",
     cell: /* @__PURE__ */ __name((row) => row.integration_id ?? row.custom_integration_id ?? "", "cell")
@@ -11811,14 +12536,14 @@ function registerBuildIntegrationsList(buildIntegrations) {
       console.log("No integrations attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS11, integrations));
+    console.log(renderTable(TABLE_COLUMNS12, integrations));
     console.log(`Showing ${integrations.length}`);
   }, "listAction"));
 }
 __name(registerBuildIntegrationsList, "registerBuildIntegrationsList");
 
 // src/commands/build-integrations/queues-list.ts
-var TABLE_COLUMNS12 = [
+var TABLE_COLUMNS13 = [
   { header: "QUEUE ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -11850,14 +12575,14 @@ function registerBuildIntegrationsQueuesList(queues) {
       console.log("No case queues linked to this integration slot.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS12, parsed.data.queues));
+    console.log(renderTable(TABLE_COLUMNS13, parsed.data.queues));
     console.log(`Showing ${parsed.data.queues.length}`);
   }, "listAction"));
 }
 __name(registerBuildIntegrationsQueuesList, "registerBuildIntegrationsQueuesList");
 
 // src/commands/build-integrations/queues-set.ts
-var TABLE_COLUMNS13 = [
+var TABLE_COLUMNS14 = [
   { header: "QUEUE ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -11899,7 +12624,7 @@ function registerBuildIntegrationsQueuesSet(queues) {
       green(`Linked ${parsed.data.queues.length} case queue(s) to the slot.`)
     );
     if (parsed.data.queues.length > 0) {
-      console.log(renderTable(TABLE_COLUMNS13, parsed.data.queues));
+      console.log(renderTable(TABLE_COLUMNS14, parsed.data.queues));
     }
   }, "setAction"));
 }
@@ -11957,47 +12682,6 @@ function registerBuildIntegrations(program) {
 }
 __name(registerBuildIntegrations, "registerBuildIntegrations");
 
-// src/api/build-schemas.ts
-import { z as z73 } from "zod";
-
-// src/api/json-value.ts
-import { z as z72 } from "zod";
-var jsonValueSchema = z72.lazy(
-  () => z72.union([
-    z72.string(),
-    z72.number(),
-    z72.boolean(),
-    z72.null(),
-    z72.array(jsonValueSchema),
-    z72.record(z72.string(), jsonValueSchema)
-  ])
-);
-
-// src/api/build-schemas.ts
-var publicBuildSchema2 = z73.object({
-  id: z73.string(),
-  agent_id: z73.string(),
-  name: z73.string(),
-  status: z73.string().nullish(),
-  config: jsonValueSchema.nullish(),
-  revision_number: z73.number().nullish(),
-  created_at: z73.string().nullish(),
-  updated_at: z73.string().nullish()
-});
-var listBuildsResponseSchema2 = z73.object({
-  builds: z73.array(publicBuildSchema2),
-  total: z73.number().nullish(),
-  limit: z73.number().nullish(),
-  offset: z73.number().nullish()
-});
-var getBuildResponseSchema = z73.object({
-  build: publicBuildSchema2
-});
-var createBuildResponseSchema = z73.object({
-  build: publicBuildSchema2,
-  agent: z73.object({ id: z73.string() })
-});
-
 // src/commands/builds/create.ts
 function registerBuildsCreate(builds) {
   builds.command("create").description("Create a new revision for an existing agent").requiredOption("--agent <id>", "ID of the agent this revision belongs to").requiredOption("--name <text>", "revision name").requiredOption(
@@ -12089,7 +12773,7 @@ __name(registerBuildsGet, "registerBuildsGet");
 var DEFAULT_LIMIT2 = 20;
 var MIN_LIMIT2 = 1;
 var MAX_LIMIT2 = 100;
-var TABLE_COLUMNS14 = [
+var TABLE_COLUMNS15 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -12132,7 +12816,7 @@ function registerBuildsList(builds) {
       console.log("No revisions found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS14, response.builds));
+    console.log(renderTable(TABLE_COLUMNS15, response.builds));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.builds.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.builds.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -12142,9 +12826,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z74 } from "zod";
-var promoteResponseSchema = z74.object({
-  success: z74.boolean()
+import { z as z75 } from "zod";
+var promoteResponseSchema = z75.object({
+  success: z75.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -12270,50 +12954,6 @@ function parseCaseIds(raw) {
 }
 __name(parseCaseIds, "parseCaseIds");
 
-// src/commands/cases/bulk-delegate.ts
-function registerCasesBulkDelegate(cases) {
-  cases.command("bulk-delegate").description(
-    "Delegate multiple cases to a chosen agent (1-100). Interrupts any active runs."
-  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption(
-    "--agent <id>",
-    "agent ID to delegate to (must be a queue consumer; list via `duvo queues agents <queue-id>`)"
-  ).requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkDelegateAction(options) {
-    const caseIds = parseCaseIds(options.ids);
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    await confirmDestructive({
-      message: `Delegate ${caseIds.length} case(s) in queue "${options.queue}" to agent "${options.agent}"?`,
-      skip: Boolean(options.yes)
-    });
-    const raw = await httpRequest({
-      method: "POST",
-      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-delegate`,
-      apiKey,
-      apiBaseUrl,
-      body: { case_ids: caseIds, agent_id: options.agent }
-    });
-    if (options.json) {
-      printJson(raw);
-      return;
-    }
-    const parsed = caseBulkDelegateResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const result = parsed.data;
-    console.log(green("Bulk delegate complete."));
-    console.log();
-    console.log(
-      renderKeyValue([
-        { label: "Delegated", value: String(result.delegatedCount) },
-        { label: "Skipped", value: String(result.skippedCount) }
-      ])
-    );
-  }, "bulkDelegateAction"));
-}
-__name(registerCasesBulkDelegate, "registerCasesBulkDelegate");
-
 // src/commands/cases/bulk-delete.ts
 function registerCasesBulkDelete(cases) {
   cases.command("bulk-delete").description(
@@ -12413,46 +13053,49 @@ async function fetchCaseTitles(ids, apiKey, apiBaseUrl) {
 }
 __name(fetchCaseTitles, "fetchCaseTitles");
 
-// src/commands/cases/bulk-retry.ts
-function registerCasesBulkRetry(cases) {
-  cases.command("bulk-retry").description(
-    "Retry multiple cases by resetting them to pending (1-100). Interrupts any active runs."
-  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkRetryAction(options) {
+// src/commands/cases/bulk-reprocess.ts
+function registerCasesBulkReprocess(cases) {
+  cases.command("bulk-reprocess").description(
+    "Re-process multiple cases on a chosen agent (1-100). Interrupts any active runs."
+  ).requiredOption("--queue <id>", "ID of the queue the cases belong to").requiredOption(
+    "--agent <id>",
+    "agent ID to re-process on (must be a queue consumer; list via `duvo queues agents <queue-id>`)"
+  ).requiredOption("--ids <list>", "comma-separated case IDs (1-100)").option("-y, --yes", "skip confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function bulkReprocessAction(options) {
     const caseIds = parseCaseIds(options.ids);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     await confirmDestructive({
-      message: `Retry ${caseIds.length} case(s) in queue "${options.queue}"?`,
+      message: `Re-process ${caseIds.length} case(s) in queue "${options.queue}" on agent "${options.agent}"?`,
       skip: Boolean(options.yes)
     });
     const raw = await httpRequest({
       method: "POST",
-      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-retry`,
+      path: `/v2/queues/${encodeURIComponent(options.queue)}/cases/bulk-reprocess`,
       apiKey,
       apiBaseUrl,
-      body: { case_ids: caseIds }
+      body: { case_ids: caseIds, agent_id: options.agent }
     });
     if (options.json) {
       printJson(raw);
       return;
     }
-    const parsed = caseBulkRetryResponseSchema.safeParse(raw);
+    const parsed = caseBulkReprocessResponseSchema.safeParse(raw);
     if (!parsed.success) {
       throw new CliError(
         `Unexpected response from the API: ${parsed.error.message}`
       );
     }
     const result = parsed.data;
-    console.log(green("Bulk retry complete."));
+    console.log(green("Bulk reprocess complete."));
     console.log();
     console.log(
       renderKeyValue([
-        { label: "Retried", value: String(result.retriedCount) },
+        { label: "Re-processed", value: String(result.reprocessedCount) },
         { label: "Skipped", value: String(result.skippedCount) }
       ])
     );
-  }, "bulkRetryAction"));
+  }, "bulkReprocessAction"));
 }
-__name(registerCasesBulkRetry, "registerCasesBulkRetry");
+__name(registerCasesBulkReprocess, "registerCasesBulkReprocess");
 
 // src/commands/cases/bulk-update-status.ts
 var CASE_TERMINAL_STATUSES = ["completed", "failed"];
@@ -12603,7 +13246,7 @@ __name(fetchQueueCaseCount, "fetchQueueCaseCount");
 
 // src/commands/cases/create.ts
 import { readFile as readFile4 } from "node:fs/promises";
-var TABLE_COLUMNS15 = [
+var TABLE_COLUMNS16 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TITLE", cell: /* @__PURE__ */ __name((row) => row.title, "cell"), maxWidth: 50 },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") }
@@ -12646,7 +13289,7 @@ function registerCasesCreate(cases) {
       )
     );
     console.log();
-    console.log(renderTable(TABLE_COLUMNS15, addedCases));
+    console.log(renderTable(TABLE_COLUMNS16, addedCases));
   }, "createAction"));
 }
 __name(registerCasesCreate, "registerCasesCreate");
@@ -12881,7 +13524,7 @@ __name(registerCasesGet, "registerCasesGet");
 
 // src/commands/cases/labels.ts
 var MAX_LABELS_PER_REQUEST = 50;
-var TABLE_COLUMNS16 = [
+var TABLE_COLUMNS17 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -12911,7 +13554,7 @@ function registerCasesLabels(cases) {
       console.log("No labels assigned.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS16, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS17, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
   labels.command("assign <case-id>").description(
@@ -12951,7 +13594,7 @@ function registerCasesLabels(cases) {
       );
     }
     console.log(green("Labels assigned!"));
-    console.log(renderTable(TABLE_COLUMNS16, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS17, parsed.data.labels));
   }, "assignAction"));
   labels.command("unlink <case-id>").description(
     "Remove one or more labels from a case (by --label-id or --label key=value, for symmetry with assign)"
@@ -13069,7 +13712,7 @@ var MIN_LIMIT3 = 1;
 var MAX_LIMIT3 = 100;
 var SORT_FIELDS = ["created_at", "updated_at", "postponed_to"];
 var SORT_ORDERS = ["asc", "desc"];
-var TABLE_COLUMNS17 = [
+var TABLE_COLUMNS18 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "TITLE", cell: /* @__PURE__ */ __name((row) => row.title, "cell"), maxWidth: 50 },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -13142,7 +13785,7 @@ function registerCasesList(cases) {
       console.log("No cases found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS17, response.cases));
+    console.log(renderTable(TABLE_COLUMNS18, response.cases));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.cases.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.cases.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -13196,7 +13839,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -13214,17 +13857,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z75.object({
-  id: z75.string(),
-  type: z75.string(),
-  role: z75.string(),
-  timestamp: z75.string(),
-  text_content: z75.string().nullish(),
-  tool_call: z75.object({ id: z75.string(), name: z75.string() }).passthrough().nullish(),
-  tool_result: z75.object({ tool_call_id: z75.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z75.object({
-  messages: z75.array(recentMessageSchema)
+var recentMessageSchema = z76.object({
+  id: z76.string(),
+  type: z76.string(),
+  role: z76.string(),
+  timestamp: z76.string(),
+  text_content: z76.string().nullish(),
+  tool_call: z76.object({ id: z76.string(), name: z76.string() }).passthrough().nullish(),
+  tool_result: z76.object({ tool_call_id: z76.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z76.object({
+  messages: z76.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -13345,53 +13988,541 @@ 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(registerClarityArtifactChatMessages, "registerClarityArtifactChatMessages");
+function parseSnapshotKind(value) {
+  const parsed = claritySnapshotKindSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError(
+      `--snapshot-kind must be one of: ${SNAPSHOT_KIND_CHOICES.join(", ")}`
+    );
+  }
+  return parsed.data;
+}
+__name(parseSnapshotKind, "parseSnapshotKind");
+function describeMessageBody(body) {
+  switch (body.kind) {
+    case "text":
+    case "error":
+    case "info":
+      return body.text;
+    case "patch":
+      return `${body.status}: ${body.summary}`;
+    case "hitl_question":
+      return `${body.questions.length} question(s)`;
+    case "hitl_answer":
+      return `${Object.keys(body.answers).length} answer(s)`;
+  }
+}
+__name(describeMessageBody, "describeMessageBody");
+
+// src/commands/clarity/artifact-import.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { basename, extname } from "node:path";
+var ARTIFACT_CONTENT_TYPES = [
+  "image/svg+xml",
+  "application/xml",
+  "text/xml",
+  "image/png",
+  "image/jpeg"
+];
+var ARTIFACT_UPLOAD_TIMEOUT_MS = 3e5;
+function registerClarityImportArtifact(clarity) {
+  clarity.command("import-artifact <process-id> <file>").description(
+    "Import a local Miro SVG, XML, PNG, or JPEG export into a Clarity process"
+  ).option("--content-type <type>", "artifact content type").option(
+    "--extra-capture-request-id <id>",
+    "bind the import to an extra-capture request"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, filePath, options) {
+    const fileName = basename(filePath);
+    const contentType = resolveArtifactContentType(
+      fileName,
+      options.contentType
+    );
+    const config = await requireAuthenticatedConfig(this);
+    const bytes = await readLocalArtifact(filePath);
+    const upload = await createUploadUrl(config, processId, {
+      fileName,
+      contentType,
+      extraCaptureRequestId: options.extraCaptureRequestId
+    });
+    await uploadToSignedUrl(upload.signed_url, bytes, contentType);
+    const complete = await completeArtifactImport(
+      config,
+      processId,
+      upload.capture_id,
+      { fileName, contentType }
+    );
+    if (options.json) {
+      printJson({ upload, complete });
+      return;
+    }
+    renderCompletedImport(complete);
+  }, "action"));
+}
+__name(registerClarityImportArtifact, "registerClarityImportArtifact");
+async function createUploadUrl(config, processId, input) {
+  const body = {
+    file_name: input.fileName,
+    content_type: input.contentType
+  };
+  if (input.extraCaptureRequestId !== void 0) {
+    body.extra_capture_request_id = input.extraCaptureRequestId;
+  }
+  const raw = await httpRequest({
+    method: "POST",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-imports/create-upload-url`,
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl,
+    body
+  });
+  const parsed = createArtifactImportUploadUrlResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(createUploadUrl, "createUploadUrl");
+async function completeArtifactImport(config, processId, captureId, input) {
+  const raw = await httpRequest({
+    method: "POST",
+    path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/artifact-imports/${encodeURIComponent(captureId)}/complete`,
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl,
+    body: {
+      file_name: input.fileName,
+      content_type: input.contentType
+    }
+  });
+  const parsed = completeArtifactImportResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(completeArtifactImport, "completeArtifactImport");
+async function readLocalArtifact(filePath) {
+  try {
+    return await readFile5(filePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(`Cannot read "${filePath}": ${message}`);
+  }
+}
+__name(readLocalArtifact, "readLocalArtifact");
+async function uploadToSignedUrl(signedUrl, bytes, contentType) {
+  let response;
+  try {
+    response = await fetch(signedUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: new Uint8Array(bytes),
+      signal: AbortSignal.timeout(ARTIFACT_UPLOAD_TIMEOUT_MS)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CliError(`Artifact upload failed: ${message}`);
+  }
+  if (!response.ok) {
+    const text3 = await response.text().catch(() => "");
+    throw new CliError(
+      `Artifact upload failed with HTTP ${response.status}${text3 ? `: ${text3}` : ""}`
+    );
+  }
+}
+__name(uploadToSignedUrl, "uploadToSignedUrl");
+function resolveArtifactContentType(fileName, contentType) {
+  if (contentType !== void 0) {
+    return parseArtifactContentType(contentType);
+  }
+  const extension = extname(fileName).toLowerCase();
+  if (extension === ".svg") {
+    return "image/svg+xml";
+  }
+  if (extension === ".xml") {
+    return "application/xml";
+  }
+  if (extension === ".png") {
+    return "image/png";
+  }
+  if (extension === ".jpg" || extension === ".jpeg") {
+    return "image/jpeg";
+  }
+  throw new CliError(
+    "Cannot infer content type. Supported extensions: .svg, .xml, .png, .jpg, .jpeg."
+  );
+}
+__name(resolveArtifactContentType, "resolveArtifactContentType");
+function parseArtifactContentType(contentType) {
+  if (ARTIFACT_CONTENT_TYPES.includes(contentType)) {
+    return contentType;
+  }
+  throw new CliError(
+    `Invalid content type "${contentType}". Expected one of: ${ARTIFACT_CONTENT_TYPES.join(", ")}.`
+  );
+}
+__name(parseArtifactContentType, "parseArtifactContentType");
+function renderCompletedImport(response) {
+  console.log(
+    renderKeyValue([
+      { label: "Capture ID", value: response.capture.id },
+      { label: "Status", value: response.capture.status },
+      { label: "Type", value: response.capture.type },
+      { label: "Created", value: response.capture.createdAt },
+      { label: "Updated", value: response.capture.updatedAt }
+    ])
+  );
+}
+__name(renderCompletedImport, "renderCompletedImport");
+
+// src/commands/clarity/assign-extra-capture-request.ts
+import { z as z78 } from "zod";
+var responseSchema3 = z78.object({
+  request: clarityProposalExtraCaptureRequestSchema
+});
+function renderRequest(request) {
+  console.log(
+    renderKeyValue([
+      { label: "ID", value: request.id },
+      { label: "Step ID", value: request.step_id },
+      { label: "Status", value: request.status },
+      { label: "Priority", value: request.priority },
+      { label: "Assigned to", value: request.requested_user_id ?? "" },
+      { label: "Gap", value: request.gap },
+      { label: "Updated", value: request.updated_at }
+    ])
+  );
+}
+__name(renderRequest, "renderRequest");
+function registerClarityAssignExtraCaptureRequest(clarity) {
+  clarity.command(
+    "assign-extra-capture-request <process-id> <proposal-id> <request-id>"
+  ).description(
+    "Assign (or unassign) a team member to an extra-capture request"
+  ).option("--user-id <id>", "team member to assign (omit to unassign)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, requestId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests/${encodeURIComponent(requestId)}/assign`,
+      apiKey,
+      apiBaseUrl,
+      body: { user_id: options.userId ?? null }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema3.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    renderRequest(parsed.data.request);
+  }, "action"));
+}
+__name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
+
+// src/commands/clarity/build-automation.ts
+import { z as z79 } from "zod";
+var responseSchema4 = z79.object({
+  automation_run: z79.object({
+    id: z79.string(),
+    status: z79.string()
+  })
+});
+function registerClarityBuildAutomation(clarity) {
+  clarity.command("build-automation <process-id>").description(
+    "Hand the latest transformation proposal off to the workflow-builder pipeline (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/automation`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema4.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { automation_run: run } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "Run ID", value: run.id },
+        { label: "Status", value: run.status }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityBuildAutomation, "registerClarityBuildAutomation");
+
+// src/commands/clarity/create-invite-link.ts
+function registerClarityCreateInviteLink(clarity) {
+  clarity.command("create-invite-link <process-id>").description(
+    "Create or regenerate a Clarity interview invite link for a process"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/invite-link`,
+      apiKey,
+      apiBaseUrl
+    });
+    const parsed = createClarityInviteLinkResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const { invite_link: inviteLink } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: inviteLink.id },
+        { label: "URL", value: inviteLink.url },
+        { label: "Created", value: inviteLink.created_at },
+        { label: "Created by", value: inviteLink.created_by.email ?? "" }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
+
+// src/commands/clarity/render.ts
+var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
+var PROCESS_TABLE_COLUMNS = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "VERSION", cell: /* @__PURE__ */ __name((row) => String(row.version), "cell") },
+  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+  {
+    header: "CAPTURES",
+    cell: /* @__PURE__ */ __name((row) => String(row.capture_count), "cell")
+  },
+  {
+    header: "NAME",
+    cell: /* @__PURE__ */ __name((row) => row.name, "cell"),
+    maxWidth: 48
+  }
+];
+var CAPTURE_TABLE_COLUMNS = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
+  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+  {
+    header: "USABLE",
+    cell: /* @__PURE__ */ __name((row) => describeCaptureUsability(row).usable ? "yes" : "no", "cell")
+  },
+  { header: "USER", cell: /* @__PURE__ */ __name((row) => row.userName ?? row.userId, "cell") },
+  {
+    header: "CREATED",
+    cell: /* @__PURE__ */ __name((row) => formatIso(row.createdAt), "cell")
+  }
+];
+function renderProcessTable(rows) {
+  return renderTable(PROCESS_TABLE_COLUMNS, rows);
+}
+__name(renderProcessTable, "renderProcessTable");
+function renderCapturesTable(rows) {
+  return renderTable(CAPTURE_TABLE_COLUMNS, rows);
 }
 __name(renderCapturesTable, "renderCapturesTable");
 function renderVersionReport(process2) {
@@ -14347,25 +15478,15 @@ function formatOptionalBoolean(value) {
 }
 __name(formatOptionalBoolean, "formatOptionalBoolean");
 
-// src/commands/clarity/get-current-process.ts
-import { z as z76 } from "zod";
-var snapshotSchema = z76.object({
-  snapshot: z76.object({
-    id: z76.string(),
-    status: z76.string(),
-    creator_type: z76.string(),
-    user_id: z76.string().nullable(),
-    sandbox_id: z76.string().nullable(),
-    created_at: z76.string(),
-    updated_at: z76.string()
-  })
-});
-function registerClarityGetCurrentProcess(clarity) {
-  clarity.command("get-current-process <process-id> <snapshot-id>").description("Get a specific current-process snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+// src/commands/clarity/generate-current-process.ts
+function registerClarityGenerateCurrentProcess(clarity) {
+  clarity.command("generate-current-process <process-id>").description(
+    "Trigger current-process generation for a Clarity v2 process (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
-      method: "GET",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process`,
       apiKey,
       apiBaseUrl
     });
@@ -14373,242 +15494,57 @@ function registerClarityGetCurrentProcess(clarity) {
       printJson(raw);
       return;
     }
-    const parsed = snapshotSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const { snapshot } = parsed.data;
-    console.log(
-      renderKeyValue([
-        { label: "ID", value: snapshot.id },
-        { label: "Status", value: snapshot.status },
-        { label: "Creator type", value: snapshot.creator_type },
-        { label: "User ID", value: snapshot.user_id ?? "" },
-        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
-        { label: "Created", value: snapshot.created_at },
-        { label: "Updated", value: snapshot.updated_at }
-      ])
-    );
+    console.log("Generation started.");
   }, "action"));
 }
-__name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
+__name(registerClarityGenerateCurrentProcess, "registerClarityGenerateCurrentProcess");
 
-// 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()
-  })
-});
-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) {
+// 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: "GET",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
+      method: "POST",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal`,
       apiKey,
-      apiBaseUrl
+      apiBaseUrl,
+      body
     });
     if (options.json) {
       printJson(raw);
       return;
     }
-    const parsed = snapshotSchema2.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const { snapshot } = parsed.data;
-    console.log(
-      renderKeyValue([
-        { label: "ID", value: snapshot.id },
-        { label: "Status", value: snapshot.status },
-        { label: "Creator type", value: snapshot.creator_type },
-        { label: "User ID", value: snapshot.user_id ?? "" },
-        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
-        { label: "Created", value: snapshot.created_at },
-        { label: "Updated", value: snapshot.updated_at }
-      ])
-    );
+    console.log("Generation started.");
   }, "action"));
 }
-__name(registerClarityGetTransformationProposal, "registerClarityGetTransformationProposal");
-
-// 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
-    });
-    if (options.json) {
-      printJson(raw);
-      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;
-    console.log(
-      renderKeyValue([
-        { label: "ID", value: process2.id },
-        { label: "Name", value: process2.name },
-        { label: "Status", value: process2.status },
-        { label: "Version", value: String(process2.version) },
-        { label: "Created", value: process2.created_at },
-        { label: "Updated", value: process2.updated_at },
-        {
-          label: "Error",
-          value: process2.generation_error ?? ""
-        },
-        {
-          label: "Custom prompt",
-          value: process2.custom_prompt ?? ""
-        }
-      ])
-    );
-    const {
-      current_process_versions: cpVersions,
-      transformation_proposal_versions: tpVersions
-    } = parsed.data;
-    if (cpVersions.length > 0) {
-      console.log(`
-Current process versions (${cpVersions.length}):`);
-      for (const v of cpVersions) {
-        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
-      }
-    }
-    if (tpVersions.length > 0) {
-      console.log(
-        `
-Transformation proposal versions (${tpVersions.length}):`
-      );
-      for (const v of tpVersions) {
-        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
-      }
-    }
-  }, "getAction"));
-}
-__name(registerClarityGet, "registerClarityGet");
-
-// src/commands/clarity/list-extra-capture-requests.ts
-var DEFAULT_LIMIT5 = 20;
-var MIN_LIMIT5 = 1;
-var MAX_LIMIT5 = 100;
-var TABLE_COLUMNS18 = [
-  {
-    header: "ID",
-    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
-  },
-  {
-    header: "STEP ID",
-    cell: /* @__PURE__ */ __name((row) => row.step_id, "cell")
-  },
-  {
-    header: "STATUS",
-    cell: /* @__PURE__ */ __name((row) => row.status, "cell")
-  },
-  {
-    header: "PRIORITY",
-    cell: /* @__PURE__ */ __name((row) => row.priority, "cell")
-  },
-  {
-    header: "ASSIGNED TO",
-    cell: /* @__PURE__ */ __name((row) => row.requested_user_id ?? "", "cell")
-  },
-  {
-    header: "GAP",
-    cell: /* @__PURE__ */ __name((row) => row.gap, "cell"),
-    maxWidth: 50
+__name(registerClarityGenerateTransformationProposal, "registerClarityGenerateTransformationProposal");
+function buildGenerateTransformationProposalBody(options) {
+  if (options.regenerateFrom !== void 0) {
+    return { regenerate_from: options.regenerateFrom };
   }
-];
-function registerClarityListExtraCaptureRequests(clarity) {
-  clarity.command("list-extra-capture-requests <process-id> <proposal-id>").description("List extra-capture requests for a transformation proposal").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).option("--offset <n>", "number of requests to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
-    const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT5,
-      min: MIN_LIMIT5,
-      max: MAX_LIMIT5
-    });
-    const offset = parseOffset(options.offset);
-    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
-    const searchParams = new URLSearchParams();
-    searchParams.append("limit", String(limit));
-    searchParams.append("offset", String(offset));
-    const raw = await httpRequest({
-      method: "GET",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests`,
-      apiKey,
-      apiBaseUrl,
-      searchParams
-    });
-    if (options.json) {
-      printJson(raw);
-      return;
-    }
-    const parsed = clarityProposalExtraCaptureRequestListResponseSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
-    }
-    const response = parsed.data;
-    if (response.requests.length === 0) {
-      console.log("No extra-capture requests found.");
-      return;
-    }
-    console.log(renderTable(TABLE_COLUMNS18, response.requests));
-    console.log(
-      `Showing ${response.requests.length} of ${response.total} \xB7 offset ${response.offset}`
-    );
-  }, "action"));
+  if (options.currentProcessId !== void 0) {
+    return { current_process_id: options.currentProcessId };
+  }
+  return void 0;
 }
-__name(registerClarityListExtraCaptureRequests, "registerClarityListExtraCaptureRequests");
+__name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
-// 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/get-current-process.ts
+import { z as z80 } from "zod";
 
 // src/commands/clarity/read-api.ts
 var AUTH_ERROR_MARKER = "Unauthorized.";
@@ -14706,6 +15642,19 @@ 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({
@@ -14755,17 +15704,409 @@ function toClarityCliError(error, context) {
   }
   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(toClarityCliError, "toClarityCliError");
+function parseResponse(schema, raw) {
+  const parsed = schema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+__name(parseResponse, "parseResponse");
+
+// src/commands/clarity/get-current-process.ts
+var snapshotSchema = z80.object({
+  snapshot: z80.object({
+    id: z80.string(),
+    status: z80.string(),
+    creator_type: z80.string(),
+    user_id: z80.string().nullable(),
+    sandbox_id: z80.string().nullable(),
+    created_at: z80.string(),
+    updated_at: z80.string()
+  })
+});
+function registerClarityGetCurrentProcess(clarity) {
+  clarity.command("get-current-process <process-id> <snapshot-id>").description("Get a specific current-process snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const config = await requireAuthenticatedConfig(this);
+    const raw = await getClarityJson(config, {
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      resource: "Clarity current-process snapshot"
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "User ID", value: snapshot.user_id ?? "" },
+        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
+
+// src/commands/clarity/get-transformation-proposal.ts
+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 config = await requireAuthenticatedConfig(this);
+    const raw = await getClarityJson(config, {
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
+      resource: "Clarity transformation-proposal snapshot"
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema2.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "User ID", value: snapshot.user_id ?? "" },
+        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityGetTransformationProposal, "registerClarityGetTransformationProposal");
+
+// 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 config = await requireAuthenticatedConfig(this);
+    const result = await requireV2Process(config, processId);
+    if (options.json) {
+      printJson(result);
+      return;
+    }
+    const { process: process2 } = result;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: process2.id },
+        { label: "Name", value: process2.name },
+        { label: "Status", value: process2.status },
+        { label: "Version", value: String(process2.version) },
+        { label: "Created", value: process2.created_at },
+        { label: "Updated", value: process2.updated_at },
+        {
+          label: "Error",
+          value: process2.generation_error ?? ""
+        },
+        {
+          label: "Custom prompt",
+          value: process2.custom_prompt ?? ""
+        }
+      ])
+    );
+    const {
+      current_process_versions: cpVersions,
+      transformation_proposal_versions: tpVersions
+    } = result;
+    if (cpVersions.length > 0) {
+      console.log(`
+Current process versions (${cpVersions.length}):`);
+      for (const v of cpVersions) {
+        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
+      }
+    }
+    if (tpVersions.length > 0) {
+      console.log(
+        `
+Transformation proposal versions (${tpVersions.length}):`
+      );
+      for (const v of tpVersions) {
+        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
+      }
+    }
+  }, "getAction"));
+}
+__name(registerClarityGet, "registerClarityGet");
+
+// src/commands/clarity/list-extra-capture-requests.ts
+var DEFAULT_LIMIT5 = 20;
+var MIN_LIMIT5 = 1;
+var MAX_LIMIT5 = 100;
+var TABLE_COLUMNS19 = [
+  {
+    header: "ID",
+    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
+  },
+  {
+    header: "STEP ID",
+    cell: /* @__PURE__ */ __name((row) => row.step_id, "cell")
+  },
+  {
+    header: "STATUS",
+    cell: /* @__PURE__ */ __name((row) => row.status, "cell")
+  },
+  {
+    header: "PRIORITY",
+    cell: /* @__PURE__ */ __name((row) => row.priority, "cell")
+  },
+  {
+    header: "ASSIGNED TO",
+    cell: /* @__PURE__ */ __name((row) => row.requested_user_id ?? "", "cell")
+  },
+  {
+    header: "GAP",
+    cell: /* @__PURE__ */ __name((row) => row.gap, "cell"),
+    maxWidth: 50
+  }
+];
+function registerClarityListExtraCaptureRequests(clarity) {
+  clarity.command("list-extra-capture-requests <process-id> <proposal-id>").description("List extra-capture requests for a transformation proposal").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).option("--offset <n>", "number of requests to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT5,
+      min: MIN_LIMIT5,
+      max: MAX_LIMIT5
+    });
+    const offset = parseOffset(options.offset);
+    const config = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await getClarityJson(config, {
+      method: "GET",
+      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests`,
+      resource: "Clarity extra-capture requests",
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = clarityProposalExtraCaptureRequestListResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (response.requests.length === 0) {
+      console.log("No extra-capture requests found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS19, response.requests));
+    console.log(
+      `Showing ${response.requests.length} of ${response.total} \xB7 offset ${response.offset}`
+    );
+  }, "action"));
+}
+__name(registerClarityListExtraCaptureRequests, "registerClarityListExtraCaptureRequests");
+
+// 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(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}`
+      );
+    }
+    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}`
+      );
+    }
+    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(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(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(parseResponse, "parseResponse");
+__name(registerClarityStopTransformationProposal, "registerClarityStopTransformationProposal");
 
 // src/commands/clarity/index.ts
 var DEFAULT_LIMIT6 = 50;
@@ -14873,8 +16214,200 @@ var CLARITY_READ_TOOLS = [
       }
     ],
     description: "Read active extra-capture requests for a v2 transformation proposal."
+  },
+  {
+    name: "listClarityArtifactChatConversations",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity artifact-chat-conversations"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/artifact-chat/conversations"
+      }
+    ],
+    description: "List recent artifact-chat conversations for a v2 process and snapshot kind."
+  },
+  {
+    name: "getClarityArtifactChatMessages",
+    scope: "v2",
+    read_only: true,
+    commands: ["duvo clarity artifact-chat-messages"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/clarity-v2/processes/:processId/artifact-chat/conversations/:conversationId/messages"
+      }
+    ],
+    description: "Read messages for one artifact-chat conversation in a v2 process."
+  }
+];
+var CLARITY_WRITE_TOOLS = [
+  {
+    name: "generateClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity generate-current-process"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/current-process"
+      }
+    ],
+    description: "Start asynchronous current-process generation."
+  },
+  {
+    name: "generateClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity generate-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal"
+      }
+    ],
+    description: "Start asynchronous transformation-proposal generation or regeneration."
+  },
+  {
+    name: "promoteClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity promote-current-process"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/current-process/:snapshotId/promote"
+      }
+    ],
+    description: "Promote a current-process snapshot to live."
+  },
+  {
+    name: "promoteClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity promote-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/:proposalId/promote"
+      }
+    ],
+    description: "Promote a transformation-proposal snapshot to live."
+  },
+  {
+    name: "revertClarityCurrentProcess",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity revert-current-process"],
+    endpoints: [
+      {
+        method: "DELETE",
+        path: "/v2/clarity-v2/processes/:processId/current-process/:snapshotId"
+      }
+    ],
+    description: "Delete a current-process snapshot."
+  },
+  {
+    name: "revertClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity revert-transformation-proposal"],
+    endpoints: [
+      {
+        method: "DELETE",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/:proposalId"
+      }
+    ],
+    description: "Delete a transformation-proposal snapshot."
+  },
+  {
+    name: "assignClarityExtraCaptureRequest",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity assign-extra-capture-request"],
+    endpoints: [
+      {
+        method: "PATCH",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposals/:proposalId/extra-capture-requests/:requestId/assign"
+      }
+    ],
+    description: "Assign or unassign an extra-capture request."
+  },
+  {
+    name: "postprocessClaritySnapshot",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity postprocess"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/postprocess"
+      }
+    ],
+    description: "Re-run postprocessing for an existing snapshot."
+  },
+  {
+    name: "buildClarityAutomation",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity build-automation"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/automation"
+      }
+    ],
+    description: "Start workflow-builder automation generation from the latest proposal."
+  },
+  {
+    name: "stopClarityTransformationProposal",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity stop-transformation-proposal"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/transformation-proposal/stop"
+      }
+    ],
+    description: "Stop an in-flight transformation-proposal generation."
+  },
+  {
+    name: "createClarityInviteLink",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity create-invite-link"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/invite-link"
+      }
+    ],
+    description: "Create or regenerate a public Clarity interview invite link."
+  },
+  {
+    name: "importClarityArtifact",
+    scope: "v2",
+    read_only: false,
+    commands: ["duvo clarity import-artifact"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/artifact-imports/create-upload-url"
+      },
+      {
+        method: "POST",
+        path: "/v2/clarity-v2/processes/:processId/artifact-imports/:captureId/complete"
+      }
+    ],
+    description: "Upload and complete a local Miro SVG, XML, PNG, or JPEG export."
   }
 ];
+var CLARITY_TOOLS = [
+  ...CLARITY_READ_TOOLS,
+  ...CLARITY_WRITE_TOOLS
+];
 var CLARITY_TOOL_COLUMNS = [
   { header: "TOOL", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "SCOPE", cell: /* @__PURE__ */ __name((row) => row.scope, "cell") },
@@ -14885,7 +16418,7 @@ var CLARITY_TOOL_COLUMNS = [
   },
   {
     header: "ENDPOINTS",
-    cell: /* @__PURE__ */ __name((row) => row.endpoints.map((endpoint) => endpoint.path).join(", "), "cell"),
+    cell: /* @__PURE__ */ __name((row) => row.endpoints.map((endpoint) => `${endpoint.method} ${endpoint.path}`).join(", "), "cell"),
     maxWidth: 62
   }
 ];
@@ -14912,6 +16445,20 @@ function registerClarity(program) {
   registerClarityGetCurrentProcess(clarity);
   registerClarityGetTransformationProposal(clarity);
   registerClarityListExtraCaptureRequests(clarity);
+  registerClarityArtifactChatConversations(clarity);
+  registerClarityArtifactChatMessages(clarity);
+  registerClarityGenerateCurrentProcess(clarity);
+  registerClarityGenerateTransformationProposal(clarity);
+  registerClarityPromoteCurrentProcess(clarity);
+  registerClarityPromoteTransformationProposal(clarity);
+  registerClarityRevertCurrentProcess(clarity);
+  registerClarityRevertTransformationProposal(clarity);
+  registerClarityAssignExtraCaptureRequest(clarity);
+  registerClarityPostprocess(clarity);
+  registerClarityBuildAutomation(clarity);
+  registerClarityStopTransformationProposal(clarity);
+  registerClarityCreateInviteLink(clarity);
+  registerClarityImportArtifact(clarity);
 }
 __name(registerClarity, "registerClarity");
 function registerList(clarity) {
@@ -15270,7 +16817,7 @@ function registerExport(clarity) {
 __name(registerExport, "registerExport");
 function registerDoctor(clarity) {
   clarity.command("doctor [process-id]").description(
-    "Check auth, API reachability, read-only tools, and optionally one process context"
+    "Check auth, API reachability, Clarity tools, and optionally one process context"
   ).option("--json", "output JSON").action(/* @__PURE__ */ __name(async function doctorAction(processId, options) {
     const environment = await buildEnvironmentDoctorChecks(this);
     const processChecks = processId === void 0 ? [] : await buildProcessDoctorChecks(environment.config, processId);
@@ -15288,15 +16835,15 @@ function registerDoctor(clarity) {
 }
 __name(registerDoctor, "registerDoctor");
 function registerTools(clarity) {
-  clarity.command("tools").description("List read-only Clarity tools used by the CLI").option("--json", "output JSON").action((options) => {
+  clarity.command("tools").description("List Clarity tools used by the CLI").option("--json", "output JSON").action((options) => {
     if (options.json) {
-      printJson({ tools: CLARITY_READ_TOOLS });
+      printJson({ tools: CLARITY_TOOLS });
       return;
     }
-    console.log(renderTable(CLARITY_TOOL_COLUMNS, CLARITY_READ_TOOLS));
+    console.log(renderTable(CLARITY_TOOL_COLUMNS, CLARITY_TOOLS));
     console.log("");
     console.log(
-      "All listed Clarity tools are read-only GET calls. Generation, promotion, revert, assignment, postprocess, and automation-build commands are not exposed."
+      "Clarity tools include read-only GET calls and explicit write commands for generation, promotion, revert, assignment, postprocess, automation, artifact import, and invite links."
     );
   });
 }
@@ -15418,17 +16965,6 @@ async function loadV2Overview(config, processId, options) {
   };
 }
 __name(loadV2Overview, "loadV2Overview");
-async function requireV2Process(config, processId) {
-  try {
-    return await getClarityV2Process(config, processId);
-  } catch (error) {
-    if (isLegacyV2ReadError(error)) {
-      throw new CliError(CLARITY_V2_REQUIRED_MESSAGE);
-    }
-    throw error;
-  }
-}
-__name(requireV2Process, "requireV2Process");
 function buildWarnings(context) {
   const warnings = [];
   const processId = context.process.process.id;
@@ -15507,14 +17043,14 @@ __name(buildProposalAnchorCheck, "buildProposalAnchorCheck");
 async function buildEnvironmentDoctorChecks(command) {
   const checks = [
     {
-      name: "read_only_surface",
+      name: "command_surface",
       ok: true,
-      detail: "The Clarity CLI registers read commands only; generation, promotion, revert, assignment, postprocess, and automation build routes are not exposed."
+      detail: "The Clarity CLI registers read commands and explicit write commands for public Clarity v2 routes."
     },
     {
-      name: "read_tools_available",
+      name: "tools_available",
       ok: true,
-      detail: `${CLARITY_READ_TOOLS.length} read-only Clarity tools available.`,
+      detail: `${CLARITY_TOOLS.length} Clarity tools available.`,
       next_command: "duvo clarity tools"
     }
   ];
@@ -15617,8 +17153,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z79.object({
-  teams: z79.array(z79.object({ id: z79.string() }))
+var listMyTeamsResponseSchema2 = z84.object({
+  teams: z84.array(z84.object({ id: z84.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -16319,7 +17855,7 @@ function registerConnectionsGet(connections) {
 __name(registerConnectionsGet, "registerConnectionsGet");
 
 // src/commands/connections/list.ts
-var TABLE_COLUMNS19 = [
+var TABLE_COLUMNS20 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -16359,26 +17895,26 @@ function registerConnectionsList(connections) {
       console.log("No connections found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS19, rows));
+    console.log(renderTable(TABLE_COLUMNS20, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
 __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_COLUMNS20 = [
+var TABLE_COLUMNS21 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
     header: "DESCRIPTION",
@@ -16438,7 +17974,7 @@ function registerConnectionsProbe(connections) {
       console.log("No tools found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS20, tools));
+    console.log(renderTable(TABLE_COLUMNS21, tools));
     console.log(
       `Showing ${tools.length} tool${tools.length === 1 ? "" : "s"}`
     );
@@ -16594,48 +18130,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z81 } from "zod";
-var dateLike = z81.string();
-var secretSchema = z81.object({
-  id: z81.string(),
-  team_id: z81.string(),
-  user_id: z81.string().nullable(),
-  name: z81.string(),
-  service_slug: z81.string().nullable(),
-  env_var_keys: z81.array(z81.string()),
-  created_by: z81.string(),
+import { z as z86 } from "zod";
+var dateLike = z86.string();
+var secretSchema = z86.object({
+  id: z86.string(),
+  team_id: z86.string(),
+  user_id: z86.string().nullable(),
+  name: z86.string(),
+  service_slug: z86.string().nullable(),
+  env_var_keys: z86.array(z86.string()),
+  created_by: z86.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z81.array(secretSchema);
+var secretsListResponseSchema = z86.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z81.object({
-  id: z81.string(),
-  user_id: z81.string().nullable(),
-  team_id: z81.string(),
-  domain: z81.string(),
-  username: z81.string().nullable(),
+var browserLoginSchema = z86.object({
+  id: z86.string(),
+  user_id: z86.string().nullable(),
+  team_id: z86.string(),
+  domain: z86.string(),
+  username: z86.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z81.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z81.object({
-  id: z81.string(),
-  user_id: z81.string().nullable(),
-  team_id: z81.string().nullable(),
-  domain: z81.string(),
-  username: z81.string().nullable(),
+var browserLoginsListResponseSchema = z86.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z86.object({
+  id: z86.string(),
+  user_id: z86.string().nullable(),
+  team_id: z86.string().nullable(),
+  domain: z86.string(),
+  username: z86.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z81.array(
+var revisionLoginsListResponseSchema = z86.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z81.array(secretSchema);
-var successResponseSchema2 = z81.object({
-  success: z81.boolean()
+var revisionSecretsListResponseSchema = z86.array(secretSchema);
+var successResponseSchema2 = z86.object({
+  success: z86.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -16829,7 +18365,7 @@ function registerCredentialsGet(credentials) {
 __name(registerCredentialsGet, "registerCredentialsGet");
 
 // src/commands/credentials/list.ts
-var TABLE_COLUMNS21 = [
+var TABLE_COLUMNS22 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -16888,7 +18424,7 @@ function registerCredentialsList(credentials) {
       console.log("No credentials found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS21, rows));
+    console.log(renderTable(TABLE_COLUMNS22, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -17168,7 +18704,7 @@ function registerFilesDownloadUrl(files) {
 __name(registerFilesDownloadUrl, "registerFilesDownloadUrl");
 
 // src/commands/files/list.ts
-var TABLE_COLUMNS22 = [
+var TABLE_COLUMNS23 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -17211,7 +18747,7 @@ function registerFilesList(files) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS22, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS23, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "listAction"));
 }
@@ -17473,7 +19009,7 @@ function registerIntegrationsCustom(integrations) {
 __name(registerIntegrationsCustom, "registerIntegrationsCustom");
 
 // src/commands/integrations/list.ts
-var TABLE_COLUMNS23 = [
+var TABLE_COLUMNS24 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -17515,7 +19051,7 @@ function registerIntegrationsList(integrations) {
       console.log("No integrations found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS23, rows));
+    console.log(renderTable(TABLE_COLUMNS24, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -17532,7 +19068,7 @@ function registerIntegrations(program) {
 __name(registerIntegrations, "registerIntegrations");
 
 // src/commands/login.ts
-import { isCancel as isCancel3, password, spinner, text as text2 } from "@clack/prompts";
+import { isCancel as isCancel4, password, spinner, text as text2 } from "@clack/prompts";
 
 // src/oauth/auth0-config.ts
 var BAKED_DOMAIN = "login.duvo.ai" ? "login.duvo.ai" : "login.dev.duvo.ai";
@@ -17924,7 +19460,7 @@ async function resolveProfileName(flag, existingCount) {
       return void 0;
     }, "validate")
   });
-  if (isCancel3(answer)) {
+  if (isCancel4(answer)) {
     throw new CancelCliError("Login cancelled.");
   }
   return answer;
@@ -17943,7 +19479,7 @@ async function resolveApiKey(flag) {
       return void 0;
     }, "validate")
   });
-  if (isCancel3(answer)) {
+  if (isCancel4(answer)) {
     throw new CancelCliError("Login cancelled.");
   }
   return answer;
@@ -18354,7 +19890,7 @@ function parseHeaders(raw) {
   return result;
 }
 __name(parseHeaders, "parseHeaders");
-var TABLE_COLUMNS24 = [
+var TABLE_COLUMNS25 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
 ];
@@ -18412,7 +19948,7 @@ function registerOauthMcpProbe(mcp) {
       console.log("No tools advertised by this MCP server.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS24, rows));
+    console.log(renderTable(TABLE_COLUMNS25, rows));
     console.log(`Showing ${rows.length}`);
   }, "probeMcpAction"));
 }
@@ -18494,7 +20030,7 @@ function registerOauth(program) {
 __name(registerOauth, "registerOauth");
 
 // src/commands/plugins/list.ts
-var TABLE_COLUMNS25 = [
+var TABLE_COLUMNS26 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   {
@@ -18528,7 +20064,7 @@ function registerPluginsList(plugins) {
       console.log("No plugins found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS25, parsed.data.plugins));
+    console.log(renderTable(TABLE_COLUMNS26, parsed.data.plugins));
     console.log(`Showing ${parsed.data.plugins.length}`);
   }, "listAction"));
 }
@@ -18565,12 +20101,12 @@ function padRight(value, width) {
 __name(padRight, "padRight");
 
 // src/commands/profiles/render-list.ts
-var DEFAULT_MARKER = "\u25B6";
+var DEFAULT_MARKER2 = "\u25B6";
 var NON_DEFAULT_MARKER = " ";
 var COLUMNS = [
   {
     header: "",
-    cell: /* @__PURE__ */ __name((item) => item.isDefault ? DEFAULT_MARKER : NON_DEFAULT_MARKER, "cell")
+    cell: /* @__PURE__ */ __name((item) => item.isDefault ? DEFAULT_MARKER2 : NON_DEFAULT_MARKER, "cell")
   },
   { header: "NAME", cell: /* @__PURE__ */ __name((item) => item.name, "cell") },
   {
@@ -18653,7 +20189,7 @@ function registerRename(profiles) {
 __name(registerRename, "registerRename");
 
 // src/commands/profiles/use.ts
-import { isCancel as isCancel4, select } from "@clack/prompts";
+import { isCancel as isCancel5, select as select2 } from "@clack/prompts";
 var NAME_HEADER = "NAME";
 function registerUse(profiles) {
   profiles.command("use [name]").description(
@@ -18685,12 +20221,12 @@ async function pickProfileInteractively(config) {
     );
   }
   const options = buildPickerOptions(profiles);
-  const answer = await select({
+  const answer = await select2({
     message: "Select default profile",
     initialValue: config.defaultProfile ?? profiles[0].name,
     options
   });
-  if (isCancel4(answer)) {
+  if (isCancel5(answer)) {
     throw new CancelCliError("Profile switch cancelled.");
   }
   return answer;
@@ -18705,7 +20241,7 @@ function buildPickerOptions(profiles) {
     ...profiles.map((profile) => profile.name.length)
   );
   return profiles.map((profile, index) => {
-    const marker = profile.isDefault ? DEFAULT_MARKER : NON_DEFAULT_MARKER;
+    const marker = profile.isDefault ? DEFAULT_MARKER2 : NON_DEFAULT_MARKER;
     const label = `${marker} ${padRight(profile.name, nameWidth)}  ${maskedKeys[index]}`;
     return {
       value: profile.name,
@@ -18726,7 +20262,7 @@ function registerProfiles(program) {
 __name(registerProfiles, "registerProfiles");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS26 = [
+var TABLE_COLUMNS27 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "KEY", cell: /* @__PURE__ */ __name((row) => row.key, "cell") },
   { header: "VALUE", cell: /* @__PURE__ */ __name((row) => row.value, "cell") },
@@ -18780,7 +20316,7 @@ function registerList3(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS26, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS27, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
@@ -19534,7 +21070,7 @@ __name(registerQueuesLinkAgent, "registerQueuesLinkAgent");
 var DEFAULT_LIMIT7 = 20;
 var MIN_LIMIT7 = 1;
 var MAX_LIMIT7 = 100;
-var TABLE_COLUMNS27 = [
+var TABLE_COLUMNS28 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -19582,7 +21118,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS27, response.queues));
+    console.log(renderTable(TABLE_COLUMNS28, response.queues));
     const resolvedOffset = response.offset ?? offset;
     const total = response.total ?? null;
     const summary = total === null ? `Showing ${response.queues.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.queues.length} of ${total} \xB7 offset ${resolvedOffset}`;
@@ -19840,7 +21376,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS28 = [
+var TABLE_COLUMNS29 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -19876,7 +21412,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No browser logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, rows));
+    console.log(renderTable(TABLE_COLUMNS29, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -19949,7 +21485,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS29 = [
+var TABLE_COLUMNS30 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -19987,7 +21523,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, rows));
+    console.log(renderTable(TABLE_COLUMNS30, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -20003,94 +21539,176 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z82 } from "zod";
-var publicRunSchema = z82.object({
-  id: z82.string(),
-  agent_id: z82.string(),
-  build_id: z82.string(),
-  status: z82.string(),
-  source: z82.string().nullish(),
-  sandbox_id: z82.string().nullish(),
-  started_at: z82.string().nullish(),
-  completed_at: z82.string().nullish(),
-  created_at: z82.string(),
-  updated_at: z82.string().nullish(),
-  human_in_the_loop_enabled: z82.boolean().nullish()
-});
-var startRunResponseSchema = z82.object({
+import { z as z87 } from "zod";
+var publicRunSchema = z87.object({
+  id: z87.string(),
+  agent_id: z87.string(),
+  build_id: z87.string(),
+  status: z87.string(),
+  source: z87.string().nullish(),
+  sandbox_id: z87.string().nullish(),
+  started_at: z87.string().nullish(),
+  completed_at: z87.string().nullish(),
+  created_at: z87.string(),
+  updated_at: z87.string().nullish(),
+  human_in_the_loop_enabled: z87.boolean().nullish()
+});
+var startRunResponseSchema = z87.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z82.object({
-  label: z82.string(),
-  description: z82.string().nullish()
-});
-var questionSchema = z82.object({
-  question: z82.string(),
-  header: z82.string().nullish(),
-  options: z82.array(questionOptionSchema).nullish(),
-  multi_select: z82.boolean().nullish()
-});
-var pendingHumanRequestSchema = z82.object({
-  id: z82.string(),
-  title: z82.string(),
-  description: z82.string().nullish(),
-  created_at: z82.string(),
-  type: z82.string(),
-  questions: z82.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z82.object({
+var questionOptionSchema = z87.object({
+  label: z87.string(),
+  description: z87.string().nullish()
+});
+var questionSchema = z87.object({
+  question: z87.string(),
+  header: z87.string().nullish(),
+  options: z87.array(questionOptionSchema).nullish(),
+  multi_select: z87.boolean().nullish()
+});
+var pendingHumanRequestSchema = z87.object({
+  id: z87.string(),
+  title: z87.string(),
+  description: z87.string().nullish(),
+  created_at: z87.string(),
+  type: z87.string(),
+  questions: z87.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z87.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z82.object({
-  success: z82.boolean(),
-  message: z82.string().nullish()
-});
-var runMessageSchema = z82.object({
-  id: z82.string(),
-  type: z82.string(),
-  role: z82.string(),
-  timestamp: z82.string(),
-  text_content: z82.string().nullish(),
-  tool_call: z82.object({
-    id: z82.string(),
-    name: z82.string(),
-    arguments: z82.record(z82.string(), z82.unknown()).nullish()
+var stopRunResponseSchema = z87.object({
+  success: z87.boolean(),
+  message: z87.string().nullish()
+});
+var runMessageSchema = z87.object({
+  id: z87.string(),
+  type: z87.string(),
+  role: z87.string(),
+  timestamp: z87.string(),
+  text_content: z87.string().nullish(),
+  tool_call: z87.object({
+    id: z87.string(),
+    name: z87.string(),
+    arguments: z87.record(z87.string(), z87.unknown()).nullish()
   }).nullish(),
-  tool_result: z82.object({
-    tool_call_id: z82.string(),
-    result: z82.unknown().nullish(),
-    error: z82.string().nullish()
+  tool_result: z87.object({
+    tool_call_id: z87.string(),
+    result: z87.unknown().nullish(),
+    error: z87.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z82.object({
-  messages: z82.array(runMessageSchema),
-  total: z82.number().nullish(),
-  limit: z82.number().nullish(),
-  offset: z82.number().nullish()
+var listRunMessagesResponseSchema = z87.object({
+  messages: z87.array(runMessageSchema),
+  total: z87.number().nullish(),
+  limit: z87.number().nullish(),
+  offset: z87.number().nullish()
 });
-var postedMessageSchema = z82.object({
-  id: z82.string(),
-  type: z82.string(),
-  role: z82.string(),
-  timestamp: z82.string(),
-  text_content: z82.string()
+var postedMessageSchema = z87.object({
+  id: z87.string(),
+  type: z87.string(),
+  role: z87.string(),
+  timestamp: z87.string(),
+  text_content: z87.string()
 });
-var postRunMessageResponseSchema = z82.object({
+var postRunMessageResponseSchema = z87.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z82.object({
-  human_request: z82.object({
-    id: z82.string(),
-    run_id: z82.string(),
-    title: z82.string(),
-    description: z82.string().nullish(),
-    response: z82.string().nullish(),
-    responded_at: z82.string().nullish(),
-    created_at: z82.string()
+var respondHumanRequestResponseSchema = z87.object({
+  human_request: z87.object({
+    id: z87.string(),
+    run_id: z87.string(),
+    title: z87.string(),
+    description: z87.string().nullish(),
+    response: z87.string().nullish(),
+    responded_at: z87.string().nullish(),
+    created_at: z87.string()
   })
 });
 
+// src/commands/runs/evaluation.ts
+async function resolveAgentId(runId, apiKey, apiBaseUrl) {
+  const raw = await httpRequest({
+    method: "GET",
+    path: `/v2/runs/${encodeURIComponent(runId)}`,
+    apiKey,
+    apiBaseUrl
+  });
+  const parsed = getRunResponseSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new CliError(
+      `Unexpected response from the API: ${parsed.error.message}`
+    );
+  }
+  const { run } = parsed.data;
+  if (!run) {
+    throw new CliError(`Run "${runId}" not found.`);
+  }
+  return run.agent_id;
+}
+__name(resolveAgentId, "resolveAgentId");
+function registerRunsEvaluation(runs) {
+  runs.command("evaluation <run-id>").alias("eval").description("Get the latest evaluation for an agent run").option(
+    "--agent <agent-id>",
+    "agent ID for the run (resolved from the run automatically when omitted)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function evaluationAction(runId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const agentId = options.agent ?? await resolveAgentId(runId, apiKey, apiBaseUrl);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v2/agent/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/evaluation`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = runEvaluationResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const evaluation = parsed.data.data;
+    if (!evaluation) {
+      console.log(`No evaluation available for run "${runId}".`);
+      return;
+    }
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: evaluation.id },
+        { label: "Run", value: evaluation.run_id },
+        { label: "Source", value: evaluation.source ?? "" },
+        { label: "Created", value: evaluation.created_at }
+      ])
+    );
+    const flags = Object.entries(evaluation.output.data).filter(
+      ([key]) => key !== "final_comment"
+    );
+    if (flags.length > 0) {
+      console.log("");
+      console.log("Rubric:");
+      console.log(
+        renderKeyValue(
+          flags.map(([key, value]) => ({
+            label: key,
+            value: value === null ? "" : String(value)
+          }))
+        )
+      );
+    }
+    const finalComment = evaluation.output.data.final_comment;
+    if (typeof finalComment === "string" && finalComment.length > 0) {
+      console.log("");
+      console.log("Final comment:");
+      console.log(finalComment);
+    }
+  }, "evaluationAction"));
+}
+__name(registerRunsEvaluation, "registerRunsEvaluation");
+
 // src/commands/runs/get.ts
 function registerRunsGet(runs) {
   runs.command("get <id>").description("Get an agent run by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(id, options) {
@@ -20156,7 +21774,7 @@ var MAX_LIMIT8 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS30 = [
+var TABLE_COLUMNS31 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "RUN#", cell: /* @__PURE__ */ __name((row) => String(row.run_number), "cell") },
   { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
@@ -20257,7 +21875,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS30, response.data));
+    console.log(renderTable(TABLE_COLUMNS31, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -20367,7 +21985,7 @@ var DEFAULT_LIMIT9 = 20;
 var MIN_LIMIT9 = 1;
 var MAX_LIMIT9 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS31 = [
+var TABLE_COLUMNS32 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "ROLE", cell: /* @__PURE__ */ __name((row) => row.role, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -20432,7 +22050,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS31, response.messages));
+    console.log(renderTable(TABLE_COLUMNS32, response.messages));
     const resolvedOffset = response.offset ?? offset;
     const summary = response.total === null || response.total === void 0 ? `Showing ${response.messages.length} \xB7 offset ${resolvedOffset}` : `Showing ${response.messages.length} of ${response.total} \xB7 offset ${resolvedOffset}`;
     console.log(summary);
@@ -20691,6 +22309,7 @@ function registerRuns(program) {
   registerRunsStart(runs);
   registerRunsList(runs);
   registerRunsGet(runs);
+  registerRunsEvaluation(runs);
   registerRunsMessages(runs);
   registerRunsSendMessage(runs);
   registerRunsRespond(runs);
@@ -20699,28 +22318,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z83 } from "zod";
-var createSandboxResponseSchema = z83.object({
-  sandbox_id: z83.string(),
-  expires_at: z83.string()
+import { z as z88 } from "zod";
+var createSandboxResponseSchema = z88.object({
+  sandbox_id: z88.string(),
+  expires_at: z88.string()
 });
-var createSandboxUploadUrlResponseSchema = z83.object({
-  upload_url: z83.string(),
-  path: z83.string(),
-  expires_in_seconds: z83.number()
+var createSandboxUploadUrlResponseSchema = z88.object({
+  upload_url: z88.string(),
+  path: z88.string(),
+  expires_in_seconds: z88.number()
 });
-var sandboxFileSchema = z83.object({
-  name: z83.string(),
-  path: z83.string(),
-  type: z83.enum(["file", "dir"]),
-  size_bytes: z83.number()
+var sandboxFileSchema = z88.object({
+  name: z88.string(),
+  path: z88.string(),
+  type: z88.enum(["file", "dir"]),
+  size_bytes: z88.number()
 });
-var listSandboxFilesResponseSchema = z83.object({
-  files: z83.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z88.object({
+  files: z88.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z83.object({
-  path: z83.string(),
-  size_bytes: z83.number()
+var uploadSandboxFileResponseSchema = z88.object({
+  path: z88.string(),
+  size_bytes: z88.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -20757,7 +22376,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS32 = [
+var TABLE_COLUMNS33 = [
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
@@ -20795,7 +22414,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS32, files));
+    console.log(renderTable(TABLE_COLUMNS33, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -20848,8 +22467,8 @@ function registerSandboxesPrepareUploadUrl(sandboxes) {
 __name(registerSandboxesPrepareUploadUrl, "registerSandboxesPrepareUploadUrl");
 
 // src/commands/sandboxes/upload.ts
-import { readFile as readFile5, stat } from "node:fs/promises";
-import { basename } from "node:path";
+import { readFile as readFile6, stat } from "node:fs/promises";
+import { basename as basename2 } from "node:path";
 var MAX_DIRECT_UPLOAD_BYTES = 10 * 1024 * 1024;
 function registerSandboxesUpload(sandboxes) {
   sandboxes.command("upload <sandbox_id> <file>").description(
@@ -20875,11 +22494,11 @@ function registerSandboxesUpload(sandboxes) {
         `File "${file}" is ${stats.size} bytes, larger than the ${MAX_DIRECT_UPLOAD_BYTES}-byte direct-upload limit. Use \`duvo sandboxes prepare-upload-url\` for larger files.`
       );
     }
-    const content = await readFile5(file).catch((error) => {
+    const content = await readFile6(file).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       throw new CliError(`Could not read file "${file}": ${message}`);
     });
-    const filename = basename(file);
+    const filename = basename2(file);
     const formData = new FormData();
     formData.append("file", new Blob([new Uint8Array(content)]), filename);
     if (trimmedPath !== void 0) {
@@ -21140,7 +22759,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS33 = [
+var TABLE_COLUMNS34 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -21184,7 +22803,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS33, rows));
+    console.log(renderTable(TABLE_COLUMNS34, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -21295,7 +22914,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS34 = [
+var TABLE_COLUMNS35 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -21323,7 +22942,7 @@ function registerSkillsAssignments(skills) {
       console.log("No assignments use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS34, assignments));
+    console.log(renderTable(TABLE_COLUMNS35, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -21331,13 +22950,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { z as z84 } from "zod";
-var createSkillResponseSchema = z84.object({
-  skill: z84.object({
-    id: z84.string(),
-    name: z84.string(),
-    description: z84.string(),
-    team_id: z84.string()
+import { z as z89 } from "zod";
+var createSkillResponseSchema = z89.object({
+  skill: z89.object({
+    id: z89.string(),
+    name: z89.string(),
+    description: z89.string(),
+    team_id: z89.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -21605,7 +23224,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS35 = [
+var TABLE_COLUMNS36 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -21644,7 +23263,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS35, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS36, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -21701,13 +23320,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z85 } from "zod";
-var installSkillResponseSchema = z85.object({
-  skill: z85.object({
-    id: z85.string(),
-    name: z85.string(),
-    description: z85.string(),
-    team_id: z85.string()
+import { z as z90 } from "zod";
+var installSkillResponseSchema = z90.object({
+  skill: z90.object({
+    id: z90.string(),
+    name: z90.string(),
+    description: z90.string(),
+    team_id: z90.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -21895,15 +23514,15 @@ function registerSkillsSystem(skills) {
 __name(registerSkillsSystem, "registerSkillsSystem");
 
 // src/commands/skills/upload.ts
-import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
-import { basename as basename2 } from "node:path";
-import { z as z86 } from "zod";
-var uploadSkillResponseSchema = z86.object({
-  skill: z86.object({
-    id: z86.string(),
-    name: z86.string(),
-    description: z86.string(),
-    team_id: z86.string()
+import { readFile as readFile7, stat as stat2 } from "node:fs/promises";
+import { basename as basename3 } from "node:path";
+import { z as z91 } from "zod";
+var uploadSkillResponseSchema = z91.object({
+  skill: z91.object({
+    id: z91.string(),
+    name: z91.string(),
+    description: z91.string(),
+    team_id: z91.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -21917,11 +23536,11 @@ function registerSkillsUpload(skills) {
     if (!fileStats.isFile()) {
       throw new CliError(`Could not read file "${file}": not a regular file`);
     }
-    const content = await readFile6(file).catch((error) => {
+    const content = await readFile7(file).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       throw new CliError(`Could not read file "${file}": ${message}`);
     });
-    const filename = basename2(file);
+    const filename = basename3(file);
     const formData = new FormData();
     formData.append("file", new Blob([new Uint8Array(content)]), filename);
     const config = await requireAuthenticatedConfig(this);
@@ -22058,7 +23677,7 @@ __name(registerTeamGet, "registerTeamGet");
 var DEFAULT_LIMIT10 = 50;
 var MIN_LIMIT10 = 1;
 var MAX_LIMIT10 = 100;
-var TABLE_COLUMNS36 = [
+var TABLE_COLUMNS37 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name ?? "", "cell") },
   { header: "EMAIL", cell: /* @__PURE__ */ __name((row) => row.email, "cell") },
@@ -22109,7 +23728,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS36, response.members));
+    console.log(renderTable(TABLE_COLUMNS37, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -22118,11 +23737,11 @@ function registerTeamMembers(team) {
 __name(registerTeamMembers, "registerTeamMembers");
 
 // src/commands/team/use.ts
-import { z as z87 } from "zod";
+import { z as z92 } from "zod";
 var TEAM_ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var teamIdSchema = z87.string().regex(TEAM_ID_SHAPE);
-var listMyTeamsResponseSchema3 = z87.object({
-  teams: z87.array(z87.object({ id: z87.string() }))
+var teamIdSchema = z92.string().regex(TEAM_ID_SHAPE);
+var listMyTeamsResponseSchema3 = z92.object({
+  teams: z92.array(z92.object({ id: z92.string() }))
 });
 function registerTeamUse(team) {
   team.command("use <team-id>").description(
@@ -22204,14 +23823,14 @@ function registerTeam(program) {
 __name(registerTeam, "registerTeam");
 
 // src/commands/teams/list.ts
-import { z as z88 } from "zod";
-var teamApiSchema2 = z88.object({
-  id: z88.string(),
-  name: z88.string(),
-  organization_id: z88.string().nullable()
+import { z as z93 } from "zod";
+var teamApiSchema2 = z93.object({
+  id: z93.string(),
+  name: z93.string(),
+  organization_id: z93.string().nullable()
 });
-var listMyTeamsResponseSchema4 = z88.object({
-  teams: z88.array(teamApiSchema2)
+var listMyTeamsResponseSchema4 = z93.object({
+  teams: z93.array(teamApiSchema2)
 });
 function registerTeamsList(program) {
   const teams = program.command("teams").description("Inspect the teams your credentials can act on");
@@ -22307,7 +23926,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.2.0";
+    return "1.4.0";
   }
   const packageJsonPath = join2(
     dirname2(fileURLToPath(import.meta.url)),
@@ -22376,7 +23995,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.2.0" };
+    return { name: "@duvoai/cli", version: "1.4.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");