@duvoai/cli 1.7.1 → 1.8.0

package/dist/bin/duvo.js

@@ -85,9 +85,9 @@ import { z as z47 } from "zod";
 import { z as z48 } from "zod";
 import { z as z50 } from "zod";
 import { z as z49 } from "zod";
+import { z as z52 } from "zod";
 import { z as z51 } from "zod";
 import { z as z53 } from "zod";
-import { z as z52 } from "zod";
 import { z as z54 } from "zod";
 import { z as z55 } from "zod";
 import { z as z56 } from "zod";
@@ -99,14 +99,13 @@ 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 z66 } from "zod";
 import { z as z65 } from "zod";
 import { z as z67 } from "zod";
-import { z as z66 } from "zod";
 import { z as z68 } from "zod";
 import { z as z69 } from "zod";
 import { z as z70 } from "zod";
 import { z as z71 } from "zod";
-import { z as z72 } from "zod";
 
 // ../node_modules/.pnpm/jsonrepair@3.13.2/node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
 var JSONRepairError = class extends Error {
@@ -833,7 +832,6 @@ var PLAN_FEATURE = {
   CUSTOM_MCP_SERVERS: "custom_mcp_servers",
   CASE_QUEUE: "case_queue",
   CLARITY: "clarity",
-  CLARITY_OVERVIEW: "clarity_overview",
   PORTFOLIO_INTELLIGENCE: "portfolio_intelligence",
   SSO: "sso",
   AUDIT_LOGS: "audit_logs",
@@ -847,7 +845,7 @@ var PLAN_FEATURE = {
 };
 var PLAN_VERSIONS = {
   free_v1: {
-    name: "Pro Trial Plan",
+    name: "Free",
     basePlan: "free",
     maxAgents: "unlimited",
     maxAgentRunsPerMonth: 100,
@@ -875,7 +873,6 @@ var PLAN_VERSIONS = {
       PLAN_FEATURE.CUSTOM_MCP_SERVERS,
       PLAN_FEATURE.CASE_QUEUE,
       PLAN_FEATURE.CLARITY,
-      PLAN_FEATURE.CLARITY_OVERVIEW,
       PLAN_FEATURE.PORTFOLIO_INTELLIGENCE,
       PLAN_FEATURE.LEARNINGS,
       PLAN_FEATURE.BROWSING_SKILL_RECORDING,
@@ -899,7 +896,6 @@ var PLAN_VERSIONS = {
       PLAN_FEATURE.CUSTOM_MCP_SERVERS,
       PLAN_FEATURE.CASE_QUEUE,
       PLAN_FEATURE.CLARITY,
-      PLAN_FEATURE.CLARITY_OVERVIEW,
       PLAN_FEATURE.PORTFOLIO_INTELLIGENCE,
       PLAN_FEATURE.SSO,
       PLAN_FEATURE.AUDIT_LOGS,
@@ -928,11 +924,7 @@ var PLAN_VERSIONS = {
     maxAgentRunsPerMonth: 0,
     runCountingMode: "monthly",
     maxConcurrentRuns: 0,
-    features: [
-      PLAN_FEATURE.CLARITY,
-      PLAN_FEATURE.CLARITY_OVERVIEW,
-      PLAN_FEATURE.PORTFOLIO_INTELLIGENCE
-    ],
+    features: [PLAN_FEATURE.CLARITY, PLAN_FEATURE.PORTFOLIO_INTELLIGENCE],
     isActive: true,
     monthlyPriceCents: 0
     // Custom pricing
@@ -1125,7 +1117,6 @@ var CAPABILITY = {
   ADVANCED_INTEGRATIONS: "advanced_integrations",
   CUSTOM_MCP_SERVERS: "custom_mcp_servers",
   CASE_QUEUE: "case_queue",
-  CLARITY_OVERVIEW: "clarity_overview",
   PORTFOLIO_INTELLIGENCE: "portfolio_intelligence",
   SSO: "sso",
   AUDIT_LOGS: "audit_logs",
@@ -1141,7 +1132,6 @@ var CAPABILITY_KEYS = [
   CAPABILITY.ADVANCED_INTEGRATIONS,
   CAPABILITY.CUSTOM_MCP_SERVERS,
   CAPABILITY.CASE_QUEUE,
-  CAPABILITY.CLARITY_OVERVIEW,
   CAPABILITY.PORTFOLIO_INTELLIGENCE,
   CAPABILITY.SSO,
   CAPABILITY.AUDIT_LOGS,
@@ -1167,7 +1157,6 @@ var CAPABILITY_PRODUCT = {
   [CAPABILITY.ADVANCED_INTEGRATIONS]: PRODUCT.AUTOMATION,
   [CAPABILITY.CUSTOM_MCP_SERVERS]: PRODUCT.AUTOMATION,
   [CAPABILITY.CASE_QUEUE]: PRODUCT.AUTOMATION,
-  [CAPABILITY.CLARITY_OVERVIEW]: PRODUCT.CLARITY,
   [CAPABILITY.PORTFOLIO_INTELLIGENCE]: PRODUCT.CLARITY,
   [CAPABILITY.SSO]: PRODUCT.PLATFORM,
   [CAPABILITY.AUDIT_LOGS]: PRODUCT.PLATFORM,
@@ -1183,7 +1172,6 @@ var CAPABILITY_FEATURE_COMPATIBILITY = {
   [CAPABILITY.ADVANCED_INTEGRATIONS]: PLAN_FEATURE.ADVANCED_INTEGRATIONS,
   [CAPABILITY.CUSTOM_MCP_SERVERS]: PLAN_FEATURE.CUSTOM_MCP_SERVERS,
   [CAPABILITY.CASE_QUEUE]: PLAN_FEATURE.CASE_QUEUE,
-  [CAPABILITY.CLARITY_OVERVIEW]: PLAN_FEATURE.CLARITY_OVERVIEW,
   [CAPABILITY.PORTFOLIO_INTELLIGENCE]: PLAN_FEATURE.PORTFOLIO_INTELLIGENCE,
   [CAPABILITY.SSO]: PLAN_FEATURE.SSO,
   [CAPABILITY.AUDIT_LOGS]: PLAN_FEATURE.AUDIT_LOGS,
@@ -1231,7 +1219,6 @@ var PLAN_PRESET_ENTITLEMENTS = {
       CAPABILITY.ADVANCED_INTEGRATIONS,
       CAPABILITY.CUSTOM_MCP_SERVERS,
       CAPABILITY.CASE_QUEUE,
-      CAPABILITY.CLARITY_OVERVIEW,
       CAPABILITY.PORTFOLIO_INTELLIGENCE,
       CAPABILITY.LEARNINGS,
       CAPABILITY.BROWSING_SKILL_RECORDING,
@@ -1247,7 +1234,6 @@ var PLAN_PRESET_ENTITLEMENTS = {
       CAPABILITY.ADVANCED_INTEGRATIONS,
       CAPABILITY.CUSTOM_MCP_SERVERS,
       CAPABILITY.CASE_QUEUE,
-      CAPABILITY.CLARITY_OVERVIEW,
       CAPABILITY.PORTFOLIO_INTELLIGENCE,
       CAPABILITY.SSO,
       CAPABILITY.AUDIT_LOGS,
@@ -1262,10 +1248,7 @@ var PLAN_PRESET_ENTITLEMENTS = {
   },
   clarity_v1: {
     products: [PRODUCT.CLARITY],
-    capabilities: [
-      CAPABILITY.CLARITY_OVERVIEW,
-      CAPABILITY.PORTFOLIO_INTELLIGENCE
-    ],
+    capabilities: [CAPABILITY.PORTFOLIO_INTELLIGENCE],
     limits: getLimitsFromPlan(PLAN_VERSIONS.clarity_v1)
   }
 };
@@ -1481,7 +1464,6 @@ var PLAN_FEATURE_LABELS = {
   [PLAN_FEATURE.CUSTOM_MCP_SERVERS]: "Custom MCP Servers",
   [PLAN_FEATURE.CASE_QUEUE]: "Queue",
   [PLAN_FEATURE.CLARITY]: "Clarity",
-  [PLAN_FEATURE.CLARITY_OVERVIEW]: "Clarity Overview",
   [PLAN_FEATURE.PORTFOLIO_INTELLIGENCE]: "Portfolio Intelligence",
   [PLAN_FEATURE.SSO]: "Single Sign-On (SSO)",
   [PLAN_FEATURE.AUDIT_LOGS]: "Audit Logs",
@@ -1586,9 +1568,18 @@ var duvoSystemSessionStartedMessageSchema = duvoBaseSystemMessageSchema.and(
     type: z8.literal("session_started")
   })
 );
+var sessionPhaseTimingsSchema = z8.object({
+  setupMs: z8.number().optional(),
+  preflightMs: z8.number().optional(),
+  warmupMs: z8.number().nullable().optional(),
+  warmupOutcome: z8.enum(["warmed", "skipped", "failed"]).optional(),
+  modelTtftMs: z8.number().optional(),
+  firstTokenMs: z8.number().optional()
+});
 var duvoSystemSessionCompletedMessageSchema = duvoBaseSystemMessageSchema.and(
   z8.object({
-    type: z8.literal("session_completed")
+    type: z8.literal("session_completed"),
+    phases: sessionPhaseTimingsSchema.optional()
   })
 );
 var duvoSystemSessionInterruptedMessageSchema = duvoBaseSystemMessageSchema.and(
@@ -2620,9 +2611,10 @@ var CLARITY_CAPTURE_TYPES = [
   "video",
   "interview",
   "document",
-  "screenshare"
+  "screenshare",
+  "meeting"
 ];
-var clarityCaptureTypeSchema = z13.enum(CLARITY_CAPTURE_TYPES);
+var clarityCaptureTypeSchema = extensibleEnum(CLARITY_CAPTURE_TYPES);
 var conversationMessageSchema = z13.object({
   source: z13.enum(["ai", "user", "interviewer"]),
   message: z13.string().min(1),
@@ -3064,6 +3056,37 @@ var initiateClarityPhoneInterviewResponseSchema = z13.object({
   captureId: z13.string().uuid(),
   status: z13.literal("calling")
 });
+var MEETING_PLATFORM_HOST_PATTERNS = [
+  { platform: "google_meet", pattern: /(^|\.)meet\.google\.com$/ },
+  {
+    platform: "microsoft_teams",
+    pattern: /(^|\.)(teams\.microsoft\.com|teams\.live\.com)$/
+  },
+  { platform: "zoom", pattern: /(^|\.)zoom\.(us|com)$/ },
+  { platform: "webex", pattern: /(^|\.)webex\.com$/ }
+];
+function detectMeetingPlatform(meetingUrl) {
+  let host;
+  try {
+    host = new URL(meetingUrl).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+  const match = MEETING_PLATFORM_HOST_PATTERNS.find(
+    ({ pattern }) => pattern.test(host)
+  );
+  return match?.platform ?? null;
+}
+__name(detectMeetingPlatform, "detectMeetingPlatform");
+__name2(detectMeetingPlatform, "detectMeetingPlatform");
+var inviteClarityNotetakerSchema = z13.object({
+  meetingUrl: z13.url().max(2048),
+  extraCaptureRequestId: z13.guid().optional()
+});
+var inviteClarityNotetakerResponseSchema = z13.object({
+  captureId: z13.guid(),
+  status: z13.literal("pending")
+});
 var publicClarityProcessSchema = z13.object({
   id: z13.guid(),
   name: z13.string(),
@@ -3861,6 +3884,11 @@ var clarityVersionStatusChangedEventDataSchema = z17.object({
   versionId: z17.guid(),
   status: clarityV2SnapshotStatusSchema
 });
+var clarityCaptureTranscriptReadyEventDataSchema = z17.object({
+  processId: z17.guid(),
+  captureId: z17.guid(),
+  status: clarityCaptureStatusSchema
+});
 var clarityProcessRoomPayloadSchema = z17.object({
   processId: z17.guid()
 });
@@ -4040,7 +4068,10 @@ var clarityTransformationProposalSnapshotKindDetailResponseSchema = z18.object({
 var saveClarityProcessSnapshotBodySchema = z18.object({
   steps: z18.array(postprocessClarityStepBaseSchema).min(1).superRefine(refineStepGraph),
   baselineSnapshotId: z18.guid(),
-  clarityCurrentProcessId: z18.guid().optional()
+  clarityCurrentProcessId: z18.guid().optional(),
+  ...swotAnalysisAgentCurrentProcessSchema.shape,
+  ...processSummaryAgentCurrentProcessSchema.shape,
+  ...projectedImpactAgentTransformationProposalSchema.shape
 });
 var saveClarityProcessSnapshotResponseSchema = clarityProcessSnapshotDetailResponseSchema;
 var clarityV2ProcessReadModelSchema = z18.object({
@@ -4309,6 +4340,32 @@ function clarityStepsToEaseDocument(steps) {
 }
 __name(clarityStepsToEaseDocument, "clarityStepsToEaseDocument");
 __name2(clarityStepsToEaseDocument, "clarityStepsToEaseDocument");
+function pickAllowedRoots(value) {
+  if (!isJsonObject(value)) {
+    return {};
+  }
+  const roots = {};
+  if (value.summary !== void 0) {
+    roots.summary = value.summary;
+  }
+  if (value.swot !== void 0) {
+    roots.swot = value.swot;
+  }
+  if (value.projectedImpact !== void 0) {
+    roots.projectedImpact = value.projectedImpact;
+  }
+  return roots;
+}
+__name(pickAllowedRoots, "pickAllowedRoots");
+__name2(pickAllowedRoots, "pickAllowedRoots");
+function clarityDataToEaseDocument(data) {
+  return {
+    ...pickAllowedRoots(data),
+    ...clarityStepsToEaseDocument(data.steps)
+  };
+}
+__name(clarityDataToEaseDocument, "clarityDataToEaseDocument");
+__name2(clarityDataToEaseDocument, "clarityDataToEaseDocument");
 function assertEaseDocument(value) {
   if (!isJsonObject(value)) {
     throw new Error("EASE document must be an object");
@@ -4366,6 +4423,7 @@ function assertEaseDocument(value) {
     }
   }
   return {
+    ...pickAllowedRoots(value),
     stepOrder,
     stepsById: Object.fromEntries(stepEntries)
   };
@@ -4375,6 +4433,7 @@ __name2(assertEaseDocument, "assertEaseDocument");
 function materializeEaseDocument(easeDocument) {
   const ease = assertEaseDocument(easeDocument);
   return {
+    ...pickAllowedRoots(ease),
     steps: ease.stepOrder.map((stepId) => ({
       id: stepId,
       ...ease.stepsById[stepId]
@@ -4383,32 +4442,125 @@ function materializeEaseDocument(easeDocument) {
 }
 __name(materializeEaseDocument, "materializeEaseDocument");
 __name2(materializeEaseDocument, "materializeEaseDocument");
+function clarityOutputToEaseDocument(output) {
+  return {
+    ...pickAllowedRoots(output),
+    ...clarityStepsToEaseDocument(output.steps)
+  };
+}
+__name(clarityOutputToEaseDocument, "clarityOutputToEaseDocument");
+__name2(clarityOutputToEaseDocument, "clarityOutputToEaseDocument");
 function mergeCurrentProcessPostprocessSlices(previous, steps) {
   return { ...previous, steps: mergeSteps(previous.steps, steps) };
 }
 __name(mergeCurrentProcessPostprocessSlices, "mergeCurrentProcessPostprocessSlices");
 __name2(mergeCurrentProcessPostprocessSlices, "mergeCurrentProcessPostprocessSlices");
+function stripProposalOnlyStepSlices(steps) {
+  return steps.map((step) => {
+    if (typeof step !== "object" || step === null) {
+      return step;
+    }
+    return Object.fromEntries(
+      Object.entries(step).filter(
+        ([key]) => key !== "readiness" && key !== "readinessRationale" && key !== "extraCaptureNeeded"
+      )
+    );
+  });
+}
+__name(stripProposalOnlyStepSlices, "stripProposalOnlyStepSlices");
+__name2(stripProposalOnlyStepSlices, "stripProposalOnlyStepSlices");
 function mergeTransformationProposalPostprocessSlices(previous, steps) {
   return { ...previous, steps: mergeSteps(previous.steps, steps) };
 }
 __name(mergeTransformationProposalPostprocessSlices, "mergeTransformationProposalPostprocessSlices");
 __name2(mergeTransformationProposalPostprocessSlices, "mergeTransformationProposalPostprocessSlices");
-function createBaseCurrentProcessData(previous, steps) {
+function resolveEditedRoot(edited, previous, pending = false) {
+  if (edited !== void 0) {
+    return edited;
+  }
+  return pending ? void 0 : previous;
+}
+__name(resolveEditedRoot, "resolveEditedRoot");
+__name2(resolveEditedRoot, "resolveEditedRoot");
+function materializeCurrentProcessEdit(previous, easeOutput, options = {}) {
   return postprocessClarityCurrentProcessDataSchema.parse({
-    version: previous.version,
-    steps: steps.map((step) => clarityStepBaseSchema.parse(step))
+    ...previous,
+    summary: resolveEditedRoot(
+      easeOutput.summary,
+      previous.summary,
+      options.pendingSummary
+    ),
+    swot: resolveEditedRoot(
+      easeOutput.swot,
+      previous.swot,
+      options.pendingSwot
+    ),
+    steps: stripProposalOnlyStepSlices(
+      coerceStepsOutput([...easeOutput.steps])
+    )
   });
 }
-__name(createBaseCurrentProcessData, "createBaseCurrentProcessData");
-__name2(createBaseCurrentProcessData, "createBaseCurrentProcessData");
-function createBaseTransformationProposalData(previous, steps) {
+__name(materializeCurrentProcessEdit, "materializeCurrentProcessEdit");
+__name2(materializeCurrentProcessEdit, "materializeCurrentProcessEdit");
+function materializeProposalEdit(previous, easeOutput, options = {}) {
+  const steps = coerceStepsOutput([
+    ...easeOutput.steps
+  ]);
   return postprocessClarityTransformationProposalDataSchema.parse({
-    version: previous.version,
-    steps: steps.map((step) => clarityStepBaseSchema.parse(step))
+    ...previous,
+    summary: resolveEditedRoot(
+      easeOutput.summary,
+      previous.summary,
+      options.pendingSummary
+    ),
+    projectedImpact: resolveEditedRoot(
+      easeOutput.projectedImpact,
+      previous.projectedImpact,
+      options.pendingProjectedImpact
+    ),
+    steps: options.preserveVolatileSlices ? preserveProposalVolatileSlices(previous.steps, steps) : clearProposalVolatileSlices(steps)
+  });
+}
+__name(materializeProposalEdit, "materializeProposalEdit");
+__name2(materializeProposalEdit, "materializeProposalEdit");
+function clearProposalVolatileSlices(steps) {
+  return steps.map((step) => {
+    if (typeof step !== "object" || step === null) {
+      return step;
+    }
+    const proposalStep = step;
+    const {
+      readiness: _readiness,
+      readinessRationale: _readinessRationale,
+      extraCaptureNeeded: _extraCaptureNeeded,
+      ...baseStep
+    } = proposalStep;
+    return baseStep;
+  });
+}
+__name(clearProposalVolatileSlices, "clearProposalVolatileSlices");
+__name2(clearProposalVolatileSlices, "clearProposalVolatileSlices");
+function preserveProposalVolatileSlices(previousSteps, steps) {
+  const previousById = new Map(previousSteps.map((step) => [step.id, step]));
+  return clearProposalVolatileSlices(steps).map((step) => {
+    if (typeof step !== "object" || step === null || !("id" in step)) {
+      return step;
+    }
+    const stepId = typeof step.id === "string" ? step.id : null;
+    const prev = stepId === null ? void 0 : previousById.get(stepId);
+    if (!prev) {
+      return step;
+    }
+    return {
+      ...step,
+      ...prev.readiness === void 0 ? {} : { readiness: prev.readiness },
+      ...prev.readinessRationale === void 0 ? {} : { readinessRationale: prev.readinessRationale },
+      ...prev.extraCaptureNeeded === void 0 ? {} : { extraCaptureNeeded: prev.extraCaptureNeeded }
+    };
   });
 }
-__name(createBaseTransformationProposalData, "createBaseTransformationProposalData");
-__name2(createBaseTransformationProposalData, "createBaseTransformationProposalData");
+__name(preserveProposalVolatileSlices, "preserveProposalVolatileSlices");
+__name2(preserveProposalVolatileSlices, "preserveProposalVolatileSlices");
 function mergeSteps(previousSteps, steps) {
   const previousById = new Map(previousSteps.map((step) => [step.id, step]));
   return steps.map((step) => {
@@ -4857,6 +5009,7 @@ var INTEGRATION_SLUGS = [
   "workday",
   "coupa",
   "signavio",
+  "sap-ecc",
   "msteams",
   "human-in-the-loop",
   "email-attachments-reader",
@@ -5239,11 +5392,15 @@ var artifactMessageSchema = z24.object({
   // rows, whose visible text lives in `content`.
   message: z24.unknown().nullable().optional()
 });
+var artifactListScopeSchema = z24.enum(["created", "shared"]);
 var artifactListResponseSchema = z24.object({
-  created: z24.array(artifactSchema),
-  sharedWithMe: z24.array(artifactSchema)
+  artifacts: z24.array(artifactSchema),
+  total: z24.number(),
+  limit: z24.number(),
+  offset: z24.number()
 });
-var artifactDetailResponseSchema = artifactSchema.extend({
+var artifactDetailResponseSchema = z24.object({
+  artifact: artifactSchema,
   is_creator: z24.boolean(),
   messages: z24.array(artifactMessageSchema)
 });
@@ -5278,8 +5435,8 @@ var createArtifactBodySchema = z24.object({
   message: z24.string().min(1).max(1e4)
 });
 var createArtifactResponseSchema = z24.object({
-  artifactId: z24.guid(),
-  userMessage: artifactMessageSchema
+  artifact_id: z24.guid(),
+  user_message: artifactMessageSchema
 });
 var pulseSelectedElementSchema = z24.object({
   // Best-effort CSS path to the element (id-anchored where possible).
@@ -5302,8 +5459,7 @@ var sendArtifactMessageBodySchema = z24.object({
   selected_element: pulseSelectedElementSchema.optional()
 });
 var sendArtifactMessageResponseSchema = z24.object({
-  ok: z24.literal(true),
-  userMessage: artifactMessageSchema
+  user_message: artifactMessageSchema
 });
 var answerArtifactQuestionBodySchema = z24.object({
   toolCallId: z24.string().min(1),
@@ -5318,7 +5474,7 @@ var updateArtifactBodySchema = z24.object({
   title: z24.string().trim().min(1).max(120)
 }).strict();
 var deleteArtifactResponseSchema = z24.object({
-  ok: z24.literal(true)
+  success: z24.literal(true)
 });
 var browserReplayScreenshotSchema = z25.object({
   id: z25.guid(),
@@ -5388,7 +5544,8 @@ var startInterviewCaptureBodySchema = z26.object({
   type: clarityCaptureSubTypeSchema,
   captureId: z26.guid().optional(),
   language: clarityInterviewLanguageSchema.optional(),
-  extraCaptureRequestId: z26.guid().optional()
+  extraCaptureRequestId: z26.guid().optional(),
+  processNodeId: z26.guid().optional()
 });
 var startInterviewCaptureResponseSchema = clarityCaptureSchema.extend({
   createdAt: z26.string(),
@@ -5424,6 +5581,77 @@ var startInterviewCaptureResponseSchema = clarityCaptureSchema.extend({
    */
   extraCaptureGuidance: interviewExtraCaptureGuidanceSchema.nullable()
 });
+var CLARITY_INTERVIEW_STATUSES = [
+  "pending",
+  "recording",
+  "complete",
+  "failed"
+];
+var clarityInterviewStatusSchema = z26.enum(CLARITY_INTERVIEW_STATUSES);
+var CLARITY_INTERVIEW_SCOPES = ["team", "organization"];
+var clarityInterviewScopeSchema = z26.enum(CLARITY_INTERVIEW_SCOPES);
+var teamInterviewSummarySchema = z26.object({
+  id: z26.guid(),
+  userId: z26.guid(),
+  title: z26.string(),
+  status: clarityInterviewStatusSchema,
+  createdAt: z26.string(),
+  updatedAt: z26.string()
+});
+var organizationInterviewSummarySchema = teamInterviewSummarySchema.extend({
+  scope: clarityInterviewScopeSchema,
+  teamId: z26.guid().nullable(),
+  teamName: z26.string().nullable(),
+  organizationId: z26.guid()
+});
+var clarityInterviewSchema = z26.object({
+  id: z26.guid(),
+  scope: clarityInterviewScopeSchema,
+  teamId: z26.guid().nullable(),
+  organizationId: z26.guid().nullable(),
+  processId: z26.guid().nullable(),
+  processNodeId: z26.guid().nullable(),
+  userId: z26.guid(),
+  title: z26.string(),
+  status: clarityInterviewStatusSchema,
+  recordingUrl: z26.string().nullable(),
+  transcript: z26.array(conversationMessageSchema).nullable(),
+  createdAt: z26.string(),
+  updatedAt: z26.string()
+});
+var teamInterviewSchema = clarityInterviewSchema.extend({
+  scope: z26.literal("team"),
+  teamId: z26.guid()
+});
+var organizationInterviewSchema = clarityInterviewSchema.extend({
+  scope: z26.literal("organization"),
+  teamId: z26.null(),
+  organizationId: z26.guid()
+});
+var listTeamInterviewResponseSchema = z26.object({
+  interviews: z26.array(teamInterviewSummarySchema)
+});
+var listOrganizationInterviewResponseSchema = z26.object({
+  interviews: z26.array(organizationInterviewSummarySchema)
+});
+var startTeamInterviewResponseSchema = teamInterviewSchema.extend({
+  openaiToken: z26.string(),
+  openaiTokenExpiresAt: z26.string(),
+  provider: clarityInterviewVoiceProviderSchema,
+  providerConfig: voiceProviderConfigSchema,
+  instructions: z26.string().min(1),
+  processGuidance: z26.null(),
+  extraCaptureGuidance: z26.null()
+});
+var startOrganizationInterviewResponseSchema = organizationInterviewSchema.extend({
+  openaiToken: z26.string(),
+  openaiTokenExpiresAt: z26.string(),
+  provider: clarityInterviewVoiceProviderSchema,
+  providerConfig: voiceProviderConfigSchema,
+  instructions: z26.string().min(1),
+  processGuidance: z26.null(),
+  extraCaptureGuidance: z26.null()
+});
 var MAX_INTERVIEW_FRAMES_PER_CAPTURE = 300;
 var interviewUploadUrlsBodySchema = z26.object({
   type: clarityCaptureSubTypeSchema,
@@ -5759,6 +5987,11 @@ var adminMemoryStoreSummarySchema = z32.object({
   totalSizeBytes: z32.number().int().nonnegative(),
   /** `memory_file_version.written_by` of the store's most recent write. */
   lastWriter: z32.string().nullable(),
+  /** `agent_run_id` of that most recent write, when it came from an agent run
+   *  (the `assignment` writer). Null for non-run writers (user, meta-agent) or
+   *  when no run id was recorded. Lets the admin UI link the last writer to its
+   *  originating run (`/admin/run/:id`). */
+  lastWriterAgentRunId: z32.guid().nullable(),
   lastUpdatedAt: z32.string(),
   archivedAt: z32.string().nullable(),
   deletedAt: z32.string().nullable(),
@@ -7435,323 +7668,75 @@ var batchQueueAgentsResponseSchema = z50.object({
     })
   )
 });
-var CLARITY_OVERVIEW_STATUSES = [
-  "draft",
-  "collecting",
-  "generating",
-  "review",
-  "complete",
-  "generation_failed"
-];
-var clarityOverviewStatusSchema = z51.enum(CLARITY_OVERVIEW_STATUSES);
-var CLARITY_OVERVIEW_CAPTURE_STATUSES = [
-  "pending",
-  "recording",
-  "processing",
-  "complete",
-  "failed"
-];
-var CLARITY_OVERVIEW_CAPTURE_TYPES = [
-  "video",
-  "interview",
-  "document",
-  "screenshare"
-];
-var clarityOverviewCaptureSchema = z51.object({
-  id: z51.guid(),
-  overviewId: z51.guid(),
-  userId: z51.guid(),
-  userName: z51.string().optional(),
-  type: z51.enum(CLARITY_OVERVIEW_CAPTURE_TYPES),
-  videoUrl: z51.string().nullable(),
-  videoTranscript: z51.string().nullable(),
-  transcript: z51.array(conversationMessageSchema).nullable(),
-  status: z51.enum(CLARITY_OVERVIEW_CAPTURE_STATUSES),
-  createdAt: z51.coerce.date(),
-  updatedAt: z51.coerce.date()
-});
-var OverviewKpi = z51.object({
-  id: z51.guid(),
-  name: z51.string(),
-  value: z51.string(),
-  description: z51.string()
-});
-var OverviewHeadcount = z51.object({
-  approximate: z51.int().nonnegative(),
-  notes: z51.string().optional()
-});
-var OverviewTeamMember = z51.object({
-  id: z51.guid(),
-  name: z51.string(),
-  role: z51.string()
-});
-var OverviewTeam = z51.object({
-  id: z51.guid(),
-  name: z51.string(),
-  leadId: z51.guid().nullable(),
-  description: z51.string(),
-  memberCount: z51.int().nonnegative().optional(),
-  people: z51.array(OverviewTeamMember)
+var createTeamInviteLinkRequestSchema = z51.object({
+  frontendUrl: z51.url()
 });
-var OverviewInsight = z51.object({
-  id: z51.guid(),
-  title: z51.string(),
-  description: z51.string()
+var getTeamInviteLinkQuerySchema = z51.object({
+  frontendUrl: z51.url()
 });
-var OverviewHelpNeeded = z51.object({
+var teamInviteLinkCreatorSchema = z51.object({
   id: z51.guid(),
-  title: z51.string(),
-  description: z51.string(),
-  fromWhom: z51.string()
-});
-var DepartmentOverview = z51.object({
-  mission: z51.string().nullable(),
-  kpis: z51.array(OverviewKpi),
-  headcount: OverviewHeadcount.nullable(),
-  teams: z51.array(OverviewTeam),
-  worksWell: z51.array(OverviewInsight),
-  doesNotWorkWell: z51.array(OverviewInsight),
-  needsHelp: z51.array(OverviewHelpNeeded)
-});
-var DocumentationStatus = z51.enum(["documented", "draft", "not_started"]);
-var VulnerabilitySeverity = z51.enum(["warning", "critical"]);
-var AccountabilityTag = z51.enum([
-  "owner",
-  // Decision-maker, shown with "owner" badge
-  "spof",
-  // Single point of failure — highlighted as risk
-  "external",
-  // Outside the org (e.g. Supplier)
-  "notified"
-  // Receives updates but doesn't act (e.g. Supply Chain)
-]);
-var SystemRef = z51.object({
-  /** Stable identifier for the system, used for deduplication across processes */
-  id: z51.string(),
-  /** Display name as it appears in the UI: "Product Pantry", "Rohlik Admin", "Google Sheets" */
-  name: z51.string(),
-  /** URL to the system's icon/logo. Null if we don't have one — FE shows a generic fallback */
-  iconUrl: z51.url().nullable()
-});
-var PersonRole = z51.object({
-  id: z51.guid(),
-  /** Person's display name: "Tereza", "Kristyna" */
-  name: z51.string(),
-  /**
-   * Their role title within this process, not their org-wide job title.
-   * e.g. "Listing Specialist", "Senior Category Manager"
-   */
-  role: z51.string(),
-  /**
-   * Accountability tags for this person within THIS process.
-   * Same person can be "owner" in one process and have no tags in another.
-   */
-  tags: z51.array(AccountabilityTag).default([]),
-  /**
-   * Full-time equivalent headcount allocated to this role.
-   * Optional — only set when the capture interview surfaced it.
-   * e.g. 2.25 FTE for a Listing Specialist team of 3 part-timers.
-   */
-  fte: z51.number().positive().optional()
+  name: z51.string().nullable(),
+  email: z51.email()
 });
-var Vulnerability = z51.object({
+var teamInviteLinkSchema = z51.object({
   id: z51.guid(),
-  /** Warning = operational concern, Critical = structural/blocking risk */
-  severity: VulnerabilitySeverity,
-  /**
-   * Human-readable description surfaced from the interview.
-   * e.g. "Tereza alone covers fresh listing"
-   * e.g. "75-95% of obvious approvals still needs human"
-   */
-  description: z51.string(),
-  /**
-   * IDs of people directly tied to this vulnerability.
-   * Enables FE to highlight affected people in the detail view.
-   * e.g. SPOF vulnerability → [terezaId]
-   */
-  affectedPersonIds: z51.array(z51.string()).optional()
+  url: z51.url().optional(),
+  createdAt: z51.string(),
+  createdBy: teamInviteLinkCreatorSchema
 });
-var FrictionSignal = z51.object({
-  id: z51.guid(),
-  /**
-   * Operational pain point captured during interview.
-   * e.g. "40 unresolved bugs, periodic outages"
-   * These feed into the maturity score (future iteration) as penalties.
-   */
-  description: z51.string(),
-  /** Systems where this friction manifests — used for cross-referencing */
-  relatedSystemIds: z51.array(z51.string()).optional()
+var getTeamInviteLinkResponseSchema = z51.object({
+  hasLink: z51.boolean(),
+  link: teamInviteLinkSchema.optional()
 });
-var Process = z51.object({
-  id: z51.guid(),
-  /** Process name as displayed in card headers: "Product Listing", "Price Proposals" */
-  name: z51.string(),
-  /**
-   * Tracks where this process is in the Clarity documentation pipeline.
-   * - "documented": fully captured and reviewed
-   * - "draft": interview done, output not yet validated
-   * - "not_started": identified but not yet interviewed
-   */
-  documentationStatus: DocumentationStatus,
-  clarityProcessId: z51.guid().nullable().optional(),
-  // --- Content ---
-  /**
-   * Short summary for overview cards (1-2 sentences).
-   * e.g. "End-to-end workflow of listing new products into the catalog..."
-   */
-  summary: z51.string(),
-  /**
-   * Rich description shown in the detail panel.
-   * May include emphasized metrics (FE handles bold rendering).
-   * e.g. "Listing **660–880 new SKUs every month** from the commercial decision..."
-   */
-  description: z51.string(),
-  /**
-   * Authored narrative describing the system flow / toolchain.
-   * Comes from the Duvo capture output, not computed.
-   * e.g. "Product Pantry portal → Rohlik Admin backend → ChatGPT for description rewrites → ..."
-   */
-  systemNarrative: z51.string().optional(),
-  /**
-   * Authored narrative describing who does what and how accountability flows.
-   * e.g. "Senior CMs decide. Junior CMs configure. The Listing Specialist team finalizes everything."
-   */
-  accountabilityNarrative: z51.string().optional(),
-  /**
-   * Free-text frequency because the real-world cadences are too varied to enumerate.
-   * e.g. "Continuous", "Weekly + monthly slowmover", "10–15 per CM / month", "Ad-hoc, no fixed cadence"
-   */
-  frequency: z51.string(),
-  // --- Relations ---
-  people: z51.array(PersonRole),
-  systems: z51.array(SystemRef),
-  vulnerabilities: z51.array(Vulnerability),
-  frictionSignals: z51.array(FrictionSignal)
-});
-var ProcessOverviewItem = Process.extend({
-  /**
-   * Pre-computed count so FE doesn't need to re-count the people array.
-   * Displayed as "5 involved" on overview cards.
-   */
-  peopleCount: z51.int(),
-  /**
-   * First N systems (typically 4) to render the icon row.
-   */
-  systemPreviews: z51.array(SystemRef),
-  /**
-   * How many systems beyond systemPreviews exist.
-   * Rendered as "+3" badge after the icon row. 0 means all systems fit.
-   */
-  systemOverflowCount: z51.int().default(0)
+var joinLinkInfoResponseSchema = z51.object({
+  valid: z51.boolean(),
+  teamName: z51.string().optional(),
+  teamId: z51.guid().optional(),
+  reason: z51.enum(["invalid", "expired"]).optional()
 });
-var ClarityOverviewResponse = z51.object({
-  /** Explicit count for the "Processes Captured" KPI tile */
-  processCount: z51.int(),
-  /**
-   * Count of processes with at least one SPOF vulnerability.
-   * Powers the "Single point of failure" KPI tile.
-   */
-  singlePointOfFailureCount: z51.int(),
-  processes: z51.array(ProcessOverviewItem),
-  // Department-level overview sections
-  mission: z51.string().nullable(),
-  kpis: z51.array(OverviewKpi),
-  headcount: OverviewHeadcount.nullable(),
-  teams: z51.array(OverviewTeam),
-  worksWell: z51.array(OverviewInsight),
-  doesNotWorkWell: z51.array(OverviewInsight),
-  needsHelp: z51.array(OverviewHelpNeeded)
-});
-var clarityOverviewDetailSchema = z51.object({
-  id: z51.guid(),
-  teamId: z51.guid(),
-  userId: z51.guid(),
-  status: clarityOverviewStatusSchema,
-  processCount: z51.int(),
-  singlePointOfFailureCount: z51.int(),
-  processes: z51.array(ProcessOverviewItem),
-  // Department-level overview sections
-  mission: z51.string().nullable(),
-  kpis: z51.array(OverviewKpi),
-  headcount: OverviewHeadcount.nullable(),
-  teams: z51.array(OverviewTeam),
-  worksWell: z51.array(OverviewInsight),
-  doesNotWorkWell: z51.array(OverviewInsight),
-  needsHelp: z51.array(OverviewHelpNeeded),
-  generationError: z51.string().nullable(),
-  captures: z51.array(clarityOverviewCaptureSchema),
-  createdAt: z51.coerce.date(),
-  updatedAt: z51.coerce.date()
-});
-var createTeamInviteLinkRequestSchema = z52.object({
-  frontendUrl: z52.url()
+var acceptJoinLinkResponseSchema = z51.object({
+  success: z51.boolean(),
+  teamId: z51.guid()
 });
-var getTeamInviteLinkQuerySchema = z52.object({
+var createClarityProcessInviteLinkRequestSchema = z52.object({
   frontendUrl: z52.url()
 });
-var teamInviteLinkCreatorSchema = z52.object({
-  id: z52.guid(),
-  name: z52.string().nullable(),
-  email: z52.email()
-});
-var teamInviteLinkSchema = z52.object({
-  id: z52.guid(),
-  url: z52.url().optional(),
-  createdAt: z52.string(),
-  createdBy: teamInviteLinkCreatorSchema
-});
-var getTeamInviteLinkResponseSchema = z52.object({
+var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
+var getClarityProcessInviteLinkResponseSchema = z52.object({
   hasLink: z52.boolean(),
-  link: teamInviteLinkSchema.optional()
+  link: clarityProcessInviteLinkSchema.optional()
 });
-var joinLinkInfoResponseSchema = z52.object({
+var clarityJoinLinkInfoResponseSchema = z52.object({
   valid: z52.boolean(),
-  teamName: z52.string().optional(),
+  processName: z52.string().optional(),
+  processId: z52.guid().optional(),
   teamId: z52.guid().optional(),
   reason: z52.enum(["invalid", "expired"]).optional()
 });
-var acceptJoinLinkResponseSchema = z52.object({
+var acceptClarityJoinLinkResponseSchema = z52.object({
   success: z52.boolean(),
-  teamId: z52.guid()
-});
-var createClarityProcessInviteLinkRequestSchema = z53.object({
-  frontendUrl: z53.url()
-});
-var clarityProcessInviteLinkSchema = teamInviteLinkSchema;
-var getClarityProcessInviteLinkResponseSchema = z53.object({
-  hasLink: z53.boolean(),
-  link: clarityProcessInviteLinkSchema.optional()
-});
-var clarityJoinLinkInfoResponseSchema = z53.object({
-  valid: z53.boolean(),
-  processName: z53.string().optional(),
-  processId: z53.guid().optional(),
-  teamId: z53.guid().optional(),
-  reason: z53.enum(["invalid", "expired"]).optional()
-});
-var acceptClarityJoinLinkResponseSchema = z53.object({
-  success: z53.boolean(),
-  processId: z53.guid()
-});
-var credentialPreviewSchema = z54.object({
-  id: z54.guid().describe("Credential ID"),
-  domain: z54.string().describe("Domain for the credential"),
-  username: z54.string().nullable().describe("Username (if any)"),
-  hasEnabledTOTP: z54.boolean().describe("Whether TOTP is enabled"),
-  hasPassword: z54.boolean().describe("Whether a password is stored"),
-  user_id: z54.string().nullable().describe("Owner user id; null when shared with the team")
-});
-var otpResponseSchema = z54.object({
-  code: z54.string().describe("The TOTP code"),
-  expiresAt: z54.number().describe("Expiration timestamp in milliseconds")
-});
-var encryptedDataSchema = z54.object({
-  encrypted_data: z54.string().describe("Base64-encoded encrypted data"),
-  key_version: z54.string().describe("KMS key version or 'base64' for dev")
-});
-var credentialDetailSchema = z54.object({
-  domain: z54.string().describe("Domain for the credential"),
-  username: z54.string().nullable().describe("Username (if any)"),
+  processId: z52.guid()
+});
+var credentialPreviewSchema = z53.object({
+  id: z53.guid().describe("Credential ID"),
+  domain: z53.string().describe("Domain for the credential"),
+  username: z53.string().nullable().describe("Username (if any)"),
+  hasEnabledTOTP: z53.boolean().describe("Whether TOTP is enabled"),
+  hasPassword: z53.boolean().describe("Whether a password is stored"),
+  user_id: z53.string().nullable().describe("Owner user id; null when shared with the team")
+});
+var otpResponseSchema = z53.object({
+  code: z53.string().describe("The TOTP code"),
+  expiresAt: z53.number().describe("Expiration timestamp in milliseconds")
+});
+var encryptedDataSchema = z53.object({
+  encrypted_data: z53.string().describe("Base64-encoded encrypted data"),
+  key_version: z53.string().describe("KMS key version or 'base64' for dev")
+});
+var credentialDetailSchema = z53.object({
+  domain: z53.string().describe("Domain for the credential"),
+  username: z53.string().nullable().describe("Username (if any)"),
   password: encryptedDataSchema.nullable().describe("Encrypted password data")
 });
 var FEATURE_FLAG_CATALOGUE = {
@@ -7840,15 +7825,10 @@ var FEATURE_FLAG_CATALOGUE = {
     defaultValue: false,
     description: "Enables the L1-L4 Clarity process hierarchy surfaces, including the process landscape tree and related organize/auto-sort workflows."
   },
-  CLARITY_ON_DISK_CAPTURES: {
-    key: "clarity_on_disk_captures",
-    defaultValue: false,
-    description: "When enabled, the Clarity generation agent receives capture content (transcripts, documents, video transcripts, screenshare frames) as files on the sandbox filesystem and is instructed to read them via a hard checklist, instead of having the content inlined into the prompt."
-  },
-  CLARITY_OVERVIEW: {
-    key: "clarity_overview",
+  CLARITY_NOTETAKER: {
+    key: "clarity_notetaker",
     defaultValue: false,
-    description: "Enables the Clarity Overview executive dashboard showing high-level process KPIs, maturity scores, and drill-down cards across all captured processes."
+    description: "Enables the Clarity meeting notetaker (Recall.ai bot). When disabled, the 'Meeting Notetaker' option is hidden in the Add Content menu and the POST /clarity/processes/:id/captures/meeting invite route returns 404; the Recall webhook callback is unaffected. Off-by-default for staged rollout."
   },
   CLARITY_VOICE_ELEVENLABS: {
     key: "clarity_voice_elevenlabs",
@@ -7963,160 +7943,160 @@ function coerceFlagValue(value) {
 }
 __name(coerceFlagValue, "coerceFlagValue");
 __name2(coerceFlagValue, "coerceFlagValue");
-var teamFileItemSchema = z55.object({
-  id: z55.string(),
-  name: z55.string(),
-  path: z55.string(),
-  created_at: z55.string().optional(),
-  updated_at: z55.string().optional(),
-  metadata: z55.object({
-    mimetype: z55.string().optional(),
-    size: z55.number().optional()
+var teamFileItemSchema = z54.object({
+  id: z54.string(),
+  name: z54.string(),
+  path: z54.string(),
+  created_at: z54.string().optional(),
+  updated_at: z54.string().optional(),
+  metadata: z54.object({
+    mimetype: z54.string().optional(),
+    size: z54.number().optional()
   }).nullable().optional()
 });
-var listTeamFilesResponseSchema = z55.object({
-  files: z55.array(teamFileItemSchema)
-});
-var createTeamFileUploadUrlBodySchema = z55.object({
-  fileName: z55.string().min(1),
-  contentType: z55.string().min(1)
-});
-var createTeamFileUploadUrlResponseSchema = z55.object({
-  signedUrl: z55.url(),
-  expiresAt: z55.iso.datetime(),
-  filePath: z55.string()
-});
-var renameTeamFileBodySchema = z55.object({
-  relativePath: z55.string().min(1),
-  newFilenameOnly: z55.string().min(1)
-});
-var teamFileSuccessResponseSchema = z55.object({
-  success: z55.boolean()
-});
-var teamFileDownloadUrlResponseSchema = z55.object({
-  url: z55.url(),
-  expiresAt: z55.iso.datetime()
-});
-var teamFileContentResponseSchema = z55.object({
-  content: z55.string(),
-  path: z55.string(),
-  contentType: z55.string().optional()
-});
-var updateTeamFileContentBodySchema = z55.object({
-  content: z55.string()
-});
-var globalAdminApiSchema = z56.object({
-  id: z56.guid(),
-  email: z56.string(),
-  userId: z56.guid(),
-  userName: z56.string().nullable(),
-  addedByUserId: z56.guid().nullable(),
-  createdAt: z56.string()
-});
-var globalAdminListResponseSchema = z56.object({
-  admins: z56.array(globalAdminApiSchema)
-});
-var globalAdminSearchResponseSchema = z56.object({
-  users: z56.array(
-    z56.object({
-      id: z56.guid(),
-      name: z56.string().nullable(),
-      email: z56.string(),
-      createdAt: z56.string().nullable()
+var listTeamFilesResponseSchema = z54.object({
+  files: z54.array(teamFileItemSchema)
+});
+var createTeamFileUploadUrlBodySchema = z54.object({
+  fileName: z54.string().min(1),
+  contentType: z54.string().min(1)
+});
+var createTeamFileUploadUrlResponseSchema = z54.object({
+  signedUrl: z54.url(),
+  expiresAt: z54.iso.datetime(),
+  filePath: z54.string()
+});
+var renameTeamFileBodySchema = z54.object({
+  relativePath: z54.string().min(1),
+  newFilenameOnly: z54.string().min(1)
+});
+var teamFileSuccessResponseSchema = z54.object({
+  success: z54.boolean()
+});
+var teamFileDownloadUrlResponseSchema = z54.object({
+  url: z54.url(),
+  expiresAt: z54.iso.datetime()
+});
+var teamFileContentResponseSchema = z54.object({
+  content: z54.string(),
+  path: z54.string(),
+  contentType: z54.string().optional()
+});
+var updateTeamFileContentBodySchema = z54.object({
+  content: z54.string()
+});
+var globalAdminApiSchema = z55.object({
+  id: z55.guid(),
+  email: z55.string(),
+  userId: z55.guid(),
+  userName: z55.string().nullable(),
+  addedByUserId: z55.guid().nullable(),
+  createdAt: z55.string()
+});
+var globalAdminListResponseSchema = z55.object({
+  admins: z55.array(globalAdminApiSchema)
+});
+var globalAdminSearchResponseSchema = z55.object({
+  users: z55.array(
+    z55.object({
+      id: z55.guid(),
+      name: z55.string().nullable(),
+      email: z55.string(),
+      createdAt: z55.string().nullable()
     })
   )
 });
-var globalAdminCreateRequestSchema = z56.object({
-  userId: z56.guid()
+var globalAdminCreateRequestSchema = z55.object({
+  userId: z55.guid()
 });
-var globalAdminCreateResponseSchema = z56.object({
+var globalAdminCreateResponseSchema = z55.object({
   admin: globalAdminApiSchema
 });
-var globalAdminDeleteResponseSchema = z56.object({
-  success: z56.literal(true)
+var globalAdminDeleteResponseSchema = z55.object({
+  success: z55.literal(true)
 });
-var adminAccessCheckResponseSchema = z56.object({
-  isGlobalAdmin: z56.boolean()
+var adminAccessCheckResponseSchema = z55.object({
+  isGlobalAdmin: z55.boolean()
 });
 var JOB_LIST_SORT_COLUMNS = ["created_at"];
-var jobListSortColumnSchema = z57.enum(JOB_LIST_SORT_COLUMNS);
-var jobListIssueSeveritySchema = z57.enum(
+var jobListSortColumnSchema = z56.enum(JOB_LIST_SORT_COLUMNS);
+var jobListIssueSeveritySchema = z56.enum(
   ALL_EVALUATION_RUBRIC_SEVERITIES
 );
-var jobListItemSchema = z57.object({
-  id: z57.guid(),
-  created_at: z57.coerce.date(),
-  updated_at: z57.coerce.date(),
-  started_at: z57.coerce.date().nullable(),
-  completed_at: z57.coerce.date().nullable(),
+var jobListItemSchema = z56.object({
+  id: z56.guid(),
+  created_at: z56.coerce.date(),
+  updated_at: z56.coerce.date(),
+  started_at: z56.coerce.date().nullable(),
+  completed_at: z56.coerce.date().nullable(),
   status: agentRunStatusSchema,
-  source: z57.string().nullable(),
-  title: z57.string(),
-  run_number: z57.number(),
+  source: z56.string().nullable(),
+  title: z56.string(),
+  run_number: z56.number(),
   // Agent info
-  agent_id: z57.guid(),
-  agent_name: z57.string(),
-  build_id: z57.guid(),
+  agent_id: z56.guid(),
+  agent_name: z56.string(),
+  build_id: z56.guid(),
   // User info
-  user_id: z57.guid().nullable(),
+  user_id: z56.guid().nullable(),
   // Case info
-  case_queue_item_id: z57.guid().nullable(),
-  case_queue_id: z57.guid().nullable(),
-  case_queue_name: z57.string().nullable(),
-  case_title: z57.string().nullable(),
-  postponed_to: z57.coerce.date().nullable(),
-  submitted_prompt_count: z57.number().int().min(0),
+  case_queue_item_id: z56.guid().nullable(),
+  case_queue_id: z56.guid().nullable(),
+  case_queue_name: z56.string().nullable(),
+  case_title: z56.string().nullable(),
+  postponed_to: z56.coerce.date().nullable(),
+  submitted_prompt_count: z56.number().int().min(0),
   eval_summaries: evalSummarySchema.nullable().optional()
 });
-var jobListResponseSchema = z57.object({
-  data: z57.array(jobListItemSchema),
-  total: z57.number()
+var jobListResponseSchema = z56.object({
+  data: z56.array(jobListItemSchema),
+  total: z56.number()
 });
-var jobFilterOptionsSchema = z57.object({
-  agents: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string(),
-      folder_id: z57.string().nullable()
+var jobFilterOptionsSchema = z56.object({
+  agents: z56.array(
+    z56.object({
+      id: z56.string(),
+      name: z56.string(),
+      folder_id: z56.string().nullable()
     })
   ),
-  folders: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string(),
-      parent_folder_id: z57.string().nullable()
+  folders: z56.array(
+    z56.object({
+      id: z56.string(),
+      name: z56.string(),
+      parent_folder_id: z56.string().nullable()
     })
   ),
-  users: z57.array(
-    z57.object({
-      id: z57.string(),
-      name: z57.string().nullable(),
-      email: z57.string()
+  users: z56.array(
+    z56.object({
+      id: z56.string(),
+      name: z56.string().nullable(),
+      email: z56.string()
     })
   ),
-  caseQueues: z57.array(z57.object({ id: z57.string(), name: z57.string() }))
-});
-var mcpStepSchema = z58.object({
-  tool: z58.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
-  params: z58.record(z58.string(), z58.unknown()).describe("Tool-specific parameters"),
-  fallbackSelectors: z58.array(z58.string()).optional().describe("Alternative CSS selectors if primary fails"),
-  description: z58.string().optional().describe("Human-readable step description"),
-  screenshot: z58.string().optional().describe("Base64 screenshot at this step for visual context"),
-  snapshot: z58.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
-  framePath: z58.array(z58.number()).optional().describe(
+  caseQueues: z56.array(z56.object({ id: z56.string(), name: z56.string() }))
+});
+var mcpStepSchema = z57.object({
+  tool: z57.string().describe("MCP tool name (e.g., click, fill, navigate_page)"),
+  params: z57.record(z57.string(), z57.unknown()).describe("Tool-specific parameters"),
+  fallbackSelectors: z57.array(z57.string()).optional().describe("Alternative CSS selectors if primary fails"),
+  description: z57.string().optional().describe("Human-readable step description"),
+  screenshot: z57.string().optional().describe("Base64 screenshot at this step for visual context"),
+  snapshot: z57.string().optional().describe("DOM snapshot in accessibility tree format at this step"),
+  framePath: z57.array(z57.number()).optional().describe(
     "Index-based path to the target iframe (e.g., [0] for first child iframe, [1, 0] for nested)"
   )
 });
-var mcpWorkflowSchema = z58.object({
-  name: z58.string(),
-  startUrl: z58.string(),
-  viewport: z58.object({
-    width: z58.number(),
-    height: z58.number()
+var mcpWorkflowSchema = z57.object({
+  name: z57.string(),
+  startUrl: z57.string(),
+  viewport: z57.object({
+    width: z57.number(),
+    height: z57.number()
   }),
-  steps: z58.array(mcpStepSchema)
+  steps: z57.array(mcpStepSchema)
 });
-var MCP_WORKFLOW_JSON_SCHEMA = z58.toJSONSchema(mcpWorkflowSchema, {
+var MCP_WORKFLOW_JSON_SCHEMA = z57.toJSONSchema(mcpWorkflowSchema, {
   reused: "inline"
 });
 var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
@@ -8125,52 +8105,52 @@ var MCP_WORKFLOW_SCHEMA_DOCS = JSON.stringify(
   2
 );
 var ORG_BROWSER_CONFIG_VERSION = 1;
-var organizationBrowserConfigDataSchema = z59.object({
+var organizationBrowserConfigDataSchema = z58.object({
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z59.boolean()
+  enforced: z58.boolean()
 });
-var organizationBrowserConfigSchema = z59.object({
-  version: z59.literal(ORG_BROWSER_CONFIG_VERSION),
+var organizationBrowserConfigSchema = z58.object({
+  version: z58.literal(ORG_BROWSER_CONFIG_VERSION),
   data: organizationBrowserConfigDataSchema
 });
-var organizationBrowserSettingsSchema = z59.object({
-  organizationId: z59.guid(),
+var organizationBrowserSettingsSchema = z58.object({
+  organizationId: z58.guid(),
   browserProvider: BrowserProviderTypeSchema.nullable(),
   dataResidency: DataResidencySchema.nullable(),
   dataHandling: DataHandlingSchema.nullable(),
-  enforced: z59.boolean(),
-  createdAt: z59.string(),
-  updatedAt: z59.string()
+  enforced: z58.boolean(),
+  createdAt: z58.string(),
+  updatedAt: z58.string()
 });
-var getOrganizationBrowserSettingsResponseSchema = z59.object({
+var getOrganizationBrowserSettingsResponseSchema = z58.object({
   settings: organizationBrowserSettingsSchema.nullable()
 });
-var updateOrganizationBrowserSettingsRequestSchema = z59.object({
+var updateOrganizationBrowserSettingsRequestSchema = z58.object({
   browserProvider: BrowserProviderTypeSchema.nullable().optional(),
   dataResidency: DataResidencySchema.nullable().optional(),
   dataHandling: DataHandlingSchema.nullable().optional(),
-  enforced: z59.boolean().optional()
+  enforced: z58.boolean().optional()
 });
-var updateOrganizationBrowserSettingsResponseSchema = z59.object({
+var updateOrganizationBrowserSettingsResponseSchema = z58.object({
   settings: organizationBrowserSettingsSchema
 });
-var catalogPluginSchema = z60.object({
-  name: z60.string().describe("Identifier to pass in the build's plugins array."),
+var catalogPluginSchema = z59.object({
+  name: z59.string().describe("Identifier to pass in the build's plugins array."),
   type: extensibleEnum(["duvo-platform", "knowledge-work", "github"], {
     description: "Plugin source. 'duvo-platform' plugins are pre-baked into the Duvo runtime; 'knowledge-work' plugins are role-oriented bundles (engineering, sales, legal, \u2026) also baked into the runtime; 'github' plugins are downloaded from a user-supplied repository URL at run time."
   }),
-  description: z60.string()
+  description: z59.string()
 });
-var pluginCatalogResponseSchema = z60.object({
-  plugins: z60.array(catalogPluginSchema)
+var pluginCatalogResponseSchema = z59.object({
+  plugins: z59.array(catalogPluginSchema)
 });
-var limitValueSchema = z61.union([
-  z61.number().int().nonnegative(),
-  z61.literal("unlimited")
+var limitValueSchema = z60.union([
+  z60.number().int().nonnegative(),
+  z60.literal("unlimited")
 ]);
-var runCountingModeSchema = z61.enum(["monthly", "lifetime"]);
+var runCountingModeSchema = z60.enum(["monthly", "lifetime"]);
 function addDuplicateKeyIssues({
   ctx,
   items,
@@ -8182,7 +8162,7 @@ function addDuplicateKeyIssues({
     const key = keyFor(item);
     if (seen.has(key)) {
       ctx.addIssue({
-        code: z61.ZodIssueCode.custom,
+        code: z60.ZodIssueCode.custom,
         message: `Duplicate Product Access grant key: ${key}`,
         path: [...path, index]
       });
@@ -8193,34 +8173,34 @@ function addDuplicateKeyIssues({
 }
 __name(addDuplicateKeyIssues, "addDuplicateKeyIssues");
 __name2(addDuplicateKeyIssues, "addDuplicateKeyIssues");
-var productAccessOwnerSchema = z61.discriminatedUnion("type", [
-  z61.object({
-    type: z61.literal("organization"),
-    organizationId: z61.guid()
+var productAccessOwnerSchema = z60.discriminatedUnion("type", [
+  z60.object({
+    type: z60.literal("organization"),
+    organizationId: z60.guid()
   }),
-  z61.object({
-    type: z61.literal("team"),
-    teamId: z61.guid(),
-    organizationId: z61.guid().nullable()
+  z60.object({
+    type: z60.literal("team"),
+    teamId: z60.guid(),
+    organizationId: z60.guid().nullable()
   })
 ]);
-var productAccessGrantSetSchema = z61.object({
-  products: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+var productAccessGrantSetSchema = z60.object({
+  products: z60.array(
+    z60.object({
+      productKey: z60.enum(PRODUCT_KEYS),
+      enabled: z60.boolean()
     })
   ),
-  capabilities: z61.array(
-    z61.object({
-      capabilityKey: z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      enabled: z61.boolean()
+  capabilities: z60.array(
+    z60.object({
+      capabilityKey: z60.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      enabled: z60.boolean()
     })
   ),
-  limits: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
+  limits: z60.array(
+    z60.object({
+      productKey: z60.enum(PRODUCT_KEYS),
+      limitKey: z60.enum(ENTITLEMENT_LIMIT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable()
     })
@@ -8245,51 +8225,51 @@ var productAccessGrantSetSchema = z61.object({
     path: ["limits"]
   });
 });
-var productAccessSnapshotSchema = z61.object({
-  products: z61.array(
-    z61.object({
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+var productAccessSnapshotSchema = z60.object({
+  products: z60.array(
+    z60.object({
+      productKey: z60.enum(PRODUCT_KEYS),
+      enabled: z60.boolean()
     })
   ),
-  capabilities: z61.array(
-    z61.object({
-      capabilityKey: z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
-      productKey: z61.enum(PRODUCT_KEYS),
-      enabled: z61.boolean()
+  capabilities: z60.array(
+    z60.object({
+      capabilityKey: z60.enum(PRODUCT_ACCESS_CAPABILITY_KEYS),
+      productKey: z60.enum(PRODUCT_KEYS),
+      enabled: z60.boolean()
     })
   ),
-  limits: z61.array(
-    z61.object({
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
-      productKey: z61.enum(PRODUCT_KEYS),
+  limits: z60.array(
+    z60.object({
+      limitKey: z60.enum(ENTITLEMENT_LIMIT_KEYS),
+      productKey: z60.enum(PRODUCT_KEYS),
       limitValue: limitValueSchema,
       countingMode: runCountingModeSchema.nullable(),
-      label: z61.literal("per_team")
+      label: z60.literal("per_team")
     })
   )
 });
-var billingPlanSchema = z61.object({
-  planVersionId: z61.string(),
-  planName: z61.string(),
-  basePlan: z61.enum(["free", "pro", "enterprise"])
+var billingPlanSchema = z60.object({
+  planVersionId: z60.string(),
+  planName: z60.string(),
+  basePlan: z60.enum(["free", "pro", "enterprise"])
 });
-var inheritedFromSchema = z61.discriminatedUnion("type", [
-  z61.object({
-    type: z61.literal("organization"),
-    organizationId: z61.guid()
+var inheritedFromSchema = z60.discriminatedUnion("type", [
+  z60.object({
+    type: z60.literal("organization"),
+    organizationId: z60.guid()
   }),
-  z61.object({
-    type: z61.literal("team_subscription"),
-    planVersionId: z61.string()
+  z60.object({
+    type: z60.literal("team_subscription"),
+    planVersionId: z60.string()
   })
 ]);
-var productAccessReadResponseSchema = z61.object({
+var productAccessReadResponseSchema = z60.object({
   owner: productAccessOwnerSchema,
-  source: z61.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
-  accessRevision: z61.string().min(1),
+  source: z60.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  accessRevision: z60.string().min(1),
   displayPreset: displayPresetSchema,
-  hasExplicitTeamAccess: z61.boolean(),
+  hasExplicitTeamAccess: z60.boolean(),
   inheritedFrom: inheritedFromSchema.nullable(),
   billingPlan: billingPlanSchema.nullable(),
   grants: productAccessSnapshotSchema,
@@ -8297,67 +8277,67 @@ var productAccessReadResponseSchema = z61.object({
 }).superRefine((value, ctx) => {
   if (value.owner.type === "team" && value.source === "organization" && value.inheritedFrom?.type !== "organization") {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "inheritedFrom organization context is required when team source is organization",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team_subscription" && value.inheritedFrom?.type !== "team_subscription") {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "inheritedFrom subscription context is required when team source is team_subscription",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "team" && value.source === "team" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "inheritedFrom must be null for direct team Product Access",
       path: ["inheritedFrom"]
     });
   }
   if (value.owner.type === "organization" && value.billingPlan !== null) {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "billingPlan must be null for organization Product Access",
       path: ["billingPlan"]
     });
   }
   if (value.owner.type === "organization" && value.source !== "organization") {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "organization Product Access source must be organization",
       path: ["source"]
     });
   }
   if (value.owner.type === "organization" && value.inheritedFrom !== null) {
     ctx.addIssue({
-      code: z61.ZodIssueCode.custom,
+      code: z60.ZodIssueCode.custom,
       message: "inheritedFrom must be null for organization Product Access",
       path: ["inheritedFrom"]
     });
   }
 });
-var productAccessImpactRequestSchema = z61.object({
+var productAccessImpactRequestSchema = z60.object({
   proposedGrants: productAccessGrantSetSchema
 });
-var productAccessWriteRequestSchema = z61.object({
+var productAccessWriteRequestSchema = z60.object({
   proposedGrants: productAccessGrantSetSchema,
-  accessRevision: z61.string().min(1),
-  impactFingerprint: z61.string().min(1).optional()
-});
-var productAccessTeamResetRequestSchema = z61.object({
-  accessRevision: z61.string().min(1),
-  impactFingerprint: z61.string().min(1).optional()
-});
-var productAccessChangeSummarySchema = z61.object({
-  addedProducts: z61.array(z61.enum(PRODUCT_KEYS)),
-  removedProducts: z61.array(z61.enum(PRODUCT_KEYS)),
-  addedCapabilities: z61.array(z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  removedCapabilities: z61.array(z61.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
-  limitChanges: z61.array(
-    z61.object({
-      limitKey: z61.enum(ENTITLEMENT_LIMIT_KEYS),
+  accessRevision: z60.string().min(1),
+  impactFingerprint: z60.string().min(1).optional()
+});
+var productAccessTeamResetRequestSchema = z60.object({
+  accessRevision: z60.string().min(1),
+  impactFingerprint: z60.string().min(1).optional()
+});
+var productAccessChangeSummarySchema = z60.object({
+  addedProducts: z60.array(z60.enum(PRODUCT_KEYS)),
+  removedProducts: z60.array(z60.enum(PRODUCT_KEYS)),
+  addedCapabilities: z60.array(z60.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  removedCapabilities: z60.array(z60.enum(PRODUCT_ACCESS_CAPABILITY_KEYS)),
+  limitChanges: z60.array(
+    z60.object({
+      limitKey: z60.enum(ENTITLEMENT_LIMIT_KEYS),
       currentValue: limitValueSchema,
       currentCountingMode: runCountingModeSchema.nullable(),
       proposedValue: limitValueSchema,
@@ -8365,61 +8345,61 @@ var productAccessChangeSummarySchema = z61.object({
     })
   )
 });
-var productAccessImpactResponseSchema = z61.object({
+var productAccessImpactResponseSchema = z60.object({
   owner: productAccessOwnerSchema,
-  impactFingerprint: z61.string().min(1),
-  affectedTeamCount: z61.number().int().nonnegative(),
-  affectedTeamsTruncated: z61.boolean(),
+  impactFingerprint: z60.string().min(1),
+  affectedTeamCount: z60.number().int().nonnegative(),
+  affectedTeamsTruncated: z60.boolean(),
   changes: productAccessChangeSummarySchema,
-  sideEffects: z61.object({
-    automationWillPause: z61.boolean(),
-    clarityWillHide: z61.boolean()
+  sideEffects: z60.object({
+    automationWillPause: z60.boolean(),
+    clarityWillHide: z60.boolean()
   }),
-  affectedTeamsPreview: z61.array(
-    z61.object({
-      teamId: z61.guid(),
-      teamName: z61.string(),
-      source: z61.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
+  affectedTeamsPreview: z60.array(
+    z60.object({
+      teamId: z60.guid(),
+      teamName: z60.string(),
+      source: z60.enum(PLAN_ENTITLEMENTS_SOURCE_VALUES),
       changes: productAccessChangeSummarySchema
     })
   )
 });
-var publicProfileSchema = z62.object({
-  id: z62.guid(),
-  name: z62.string().nullable(),
-  email: z62.email(),
-  teamId: z62.guid().nullable()
+var publicProfileSchema = z61.object({
+  id: z61.guid(),
+  name: z61.string().nullable(),
+  email: z61.email(),
+  teamId: z61.guid().nullable()
 });
-var publicProfileResponseSchema = z62.object({
+var publicProfileResponseSchema = z61.object({
   profile: publicProfileSchema
 });
-var elementSelectorsSchema = z63.object({
-  css: z63.string().optional(),
-  cssPath: z63.string().optional(),
-  xpath: z63.string().optional(),
-  testId: z63.string().optional(),
-  ariaSelector: z63.string().optional(),
-  text: z63.string().optional()
+var elementSelectorsSchema = z62.object({
+  css: z62.string().optional(),
+  cssPath: z62.string().optional(),
+  xpath: z62.string().optional(),
+  testId: z62.string().optional(),
+  ariaSelector: z62.string().optional(),
+  text: z62.string().optional()
 });
-var elementInfoSchema = z63.object({
-  uid: z63.string().optional(),
+var elementInfoSchema = z62.object({
+  uid: z62.string().optional(),
   selectors: elementSelectorsSchema,
-  tagName: z63.string(),
-  textContent: z63.string().optional(),
-  ariaLabel: z63.string().optional(),
-  computedRole: z63.string().optional(),
-  attributes: z63.record(z63.string(), z63.string()).optional(),
-  framePath: z63.array(z63.number()).optional(),
-  frameUrl: z63.string().optional()
-});
-var recordedEventSchema = z63.looseObject({
-  id: z63.string(),
-  type: z63.string(),
-  timestamp: z63.number(),
-  url: z63.string(),
-  tabId: z63.number().optional(),
-  frameId: z63.number().optional(),
-  framePath: z63.array(z63.number()).optional(),
+  tagName: z62.string(),
+  textContent: z62.string().optional(),
+  ariaLabel: z62.string().optional(),
+  computedRole: z62.string().optional(),
+  attributes: z62.record(z62.string(), z62.string()).optional(),
+  framePath: z62.array(z62.number()).optional(),
+  frameUrl: z62.string().optional()
+});
+var recordedEventSchema = z62.looseObject({
+  id: z62.string(),
+  type: z62.string(),
+  timestamp: z62.number(),
+  url: z62.string(),
+  tabId: z62.number().optional(),
+  frameId: z62.number().optional(),
+  framePath: z62.array(z62.number()).optional(),
   element: elementInfoSchema.optional()
 });
 var DUVO_CLIENT_HEADER = "x-duvo-client";
@@ -8439,63 +8419,63 @@ function resolveRequestSourceFromClientHeader(header) {
 }
 __name(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
 __name2(resolveRequestSourceFromClientHeader, "resolveRequestSourceFromClientHeader");
-var RedactedMcpServerConfigSchema = z64.object({
+var RedactedMcpServerConfigSchema = z63.object({
   type: TransportTypeSchema,
   integrationSlug: IntegrationSlugSchema,
-  instanceId: z64.string().nullable()
+  instanceId: z63.string().nullable()
 });
-var ThreadContextMessageSchema = z64.object({
-  role: z64.enum(["user", "assistant"]),
-  content: z64.string()
+var ThreadContextMessageSchema = z63.object({
+  role: z63.enum(["user", "assistant"]),
+  content: z63.string()
 });
-var ChatFileReferenceSchema = z64.object({
-  id: z64.string(),
-  name: z64.string(),
-  mimetype: z64.string(),
-  size: z64.number(),
-  platform: z64.enum(["slack", "teams"]),
-  workspaceId: z64.string(),
-  channelId: z64.string()
-});
-var ResolvedSubAgentSchema = z64.object({
-  agentId: z64.string().uuid(),
-  buildId: z64.string().uuid(),
-  name: z64.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
+var ChatFileReferenceSchema = z63.object({
+  id: z63.string(),
+  name: z63.string(),
+  mimetype: z63.string(),
+  size: z63.number(),
+  platform: z63.enum(["slack", "teams"]),
+  workspaceId: z63.string(),
+  channelId: z63.string()
+});
+var ResolvedSubAgentSchema = z63.object({
+  agentId: z63.string().uuid(),
+  buildId: z63.string().uuid(),
+  name: z63.string().min(1).max(64).regex(/^[a-z0-9-]+$/).describe(
     "Stable slug used as the Claude Code subagent name (kebab-case, \u226464 chars)"
   ),
-  description: z64.string().describe(
+  description: z63.string().describe(
     "Routing description Claude uses to decide when to delegate to this subagent"
   ),
-  prompt: z64.string().describe("System prompt (AOP) for this subagent"),
-  model: z64.string().optional().describe("Optional Claude model identifier override for this subagent"),
-  mcpServers: z64.record(z64.string(), RedactedMcpServerConfigSchema).default({}).describe(
+  prompt: z63.string().describe("System prompt (AOP) for this subagent"),
+  model: z63.string().optional().describe("Optional Claude model identifier override for this subagent"),
+  mcpServers: z63.record(z63.string(), RedactedMcpServerConfigSchema).default({}).describe(
     "Redacted MCP server configs scoped to this subagent. Secrets resolved at execution time."
   )
 });
 var RunConfigSchema = AgentConfigSchema.extend({
-  task: z64.string(),
-  mcpServers: z64.record(z64.string(), RedactedMcpServerConfigSchema),
-  subAgents: z64.array(ResolvedSubAgentSchema).optional().default([]),
-  conversationHistory: z64.array(ThreadContextMessageSchema).optional(),
-  chatFiles: z64.array(ChatFileReferenceSchema).optional(),
+  task: z63.string(),
+  mcpServers: z63.record(z63.string(), RedactedMcpServerConfigSchema),
+  subAgents: z63.array(ResolvedSubAgentSchema).optional().default([]),
+  conversationHistory: z63.array(ThreadContextMessageSchema).optional(),
+  chatFiles: z63.array(ChatFileReferenceSchema).optional(),
   /** IANA timezone (e.g. `"Europe/Prague"`). Consumers should fall back to UTC when absent. */
-  timezone: z64.string().optional(),
+  timezone: z63.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: z64.string().optional()
+  sessionStartedAt: z63.string().optional()
 });
-var StoredRunConfigV0Schema = z64.object({
-  version: z64.literal("v0")
+var StoredRunConfigV0Schema = z63.object({
+  version: z63.literal("v0")
 });
-var StoredRunConfigV1Schema = z64.object({
-  version: z64.literal("v1"),
+var StoredRunConfigV1Schema = z63.object({
+  version: z63.literal("v1"),
   data: RunConfigSchema
 });
-var StoredRunConfigSchema = z64.union([
+var StoredRunConfigSchema = z63.union([
   StoredRunConfigV0Schema,
   StoredRunConfigV1Schema
 ]);
@@ -8514,177 +8494,177 @@ function isRunConfig(config) {
 }
 __name(isRunConfig, "isRunConfig");
 __name2(isRunConfig, "isRunConfig");
-var skillApiSchema = z65.object({
-  id: z65.string(),
-  name: z65.string(),
-  description: z65.string(),
+var skillApiSchema = z64.object({
+  id: z64.string(),
+  name: z64.string(),
+  description: z64.string(),
   // System skills have null team_id.
-  team_id: z65.string().nullable()
+  team_id: z64.string().nullable()
 });
-var listSkillsResponseSchema = z65.object({
-  skills: z65.array(skillApiSchema)
+var listSkillsResponseSchema = z64.object({
+  skills: z64.array(skillApiSchema)
 });
-var systemSkillSchema = z65.object({
-  id: z65.string(),
-  name: z65.string(),
-  description: z65.string()
-});
-var listSystemSkillsResponseSchema = z65.object({
-  skills: z65.array(systemSkillSchema)
-});
-var skillFileItemSchema = z65.object({
-  name: z65.string(),
-  path: z65.string(),
-  size: z65.number().optional(),
-  contentType: z65.string().optional(),
-  updatedAt: z65.string().optional()
-});
-var listSkillFilesResponseSchema = z65.object({
-  files: z65.array(skillFileItemSchema)
-});
-var getSkillFileContentResponseSchema = z65.object({
-  content: z65.string(),
-  path: z65.string(),
-  contentType: z65.string().optional()
-});
-var updateSkillFileBodySchema = z65.object({
-  content: z65.string()
-});
-var updateSkillFileResponseSchema = z65.object({
-  success: z65.boolean(),
-  message: z65.string(),
-  skill: z65.object({
-    id: z65.string(),
-    name: z65.string(),
-    description: z65.string()
-  }).optional()
+var systemSkillSchema = z64.object({
+  id: z64.string(),
+  name: z64.string(),
+  description: z64.string()
 });
-var deleteSkillResponseSchema = z65.object({
-  success: z65.boolean(),
-  message: z65.string()
+var listSystemSkillsResponseSchema = z64.object({
+  skills: z64.array(systemSkillSchema)
 });
-var generateSkillBodySchema = z65.object({
-  prompt: z65.string().min(1).max(2e3),
-  existingContent: z65.string().max(2e4).optional()
+var skillFileItemSchema = z64.object({
+  name: z64.string(),
+  path: z64.string(),
+  size: z64.number().optional(),
+  contentType: z64.string().optional(),
+  updatedAt: z64.string().optional()
 });
-var generateSkillResponseSchema = z65.object({
-  content: z65.string()
+var listSkillFilesResponseSchema = z64.object({
+  files: z64.array(skillFileItemSchema)
 });
-var skillAssignmentSchema = z65.object({
-  id: z65.string(),
-  name: z65.string()
+var getSkillFileContentResponseSchema = z64.object({
+  content: z64.string(),
+  path: z64.string(),
+  contentType: z64.string().optional()
 });
-var listSkillAssignmentsResponseSchema = z65.object({
-  assignments: z65.array(skillAssignmentSchema),
-  total: z65.number()
+var updateSkillFileBodySchema = z64.object({
+  content: z64.string()
 });
-var teamInvitationApiSchema = z66.object({
-  id: z66.string(),
-  team_id: z66.string(),
-  email: z66.email(),
-  invited_by: z66.string(),
-  role: z66.string(),
-  status: z66.string(),
-  name: z66.string().nullable(),
-  created_at: z66.string(),
-  process_id: z66.guid().nullable().optional()
+var updateSkillFileResponseSchema = z64.object({
+  success: z64.boolean(),
+  message: z64.string(),
+  skill: z64.object({
+    id: z64.string(),
+    name: z64.string(),
+    description: z64.string()
+  }).optional()
 });
-var teamInvitationDetailApiSchema = z66.object({
-  id: z66.string(),
-  team_id: z66.string(),
-  email: z66.email(),
-  invited_by: z66.string(),
-  role: z66.string(),
-  status: z66.string(),
-  name: z66.string().nullable(),
-  created_at: z66.string(),
-  process_id: z66.guid().nullable().optional(),
-  team: z66.object({
-    id: z66.string(),
-    name: z66.string()
+var deleteSkillResponseSchema = z64.object({
+  success: z64.boolean(),
+  message: z64.string()
+});
+var generateSkillBodySchema = z64.object({
+  prompt: z64.string().min(1).max(2e3),
+  existingContent: z64.string().max(2e4).optional()
+});
+var generateSkillResponseSchema = z64.object({
+  content: z64.string()
+});
+var skillAssignmentSchema = z64.object({
+  id: z64.string(),
+  name: z64.string()
+});
+var listSkillAssignmentsResponseSchema = z64.object({
+  assignments: z64.array(skillAssignmentSchema),
+  total: z64.number()
+});
+var teamInvitationApiSchema = z65.object({
+  id: z65.string(),
+  team_id: z65.string(),
+  email: z65.email(),
+  invited_by: z65.string(),
+  role: z65.string(),
+  status: z65.string(),
+  name: z65.string().nullable(),
+  created_at: z65.string(),
+  process_id: z65.guid().nullable().optional()
+});
+var teamInvitationDetailApiSchema = z65.object({
+  id: z65.string(),
+  team_id: z65.string(),
+  email: z65.email(),
+  invited_by: z65.string(),
+  role: z65.string(),
+  status: z65.string(),
+  name: z65.string().nullable(),
+  created_at: z65.string(),
+  process_id: z65.guid().nullable().optional(),
+  team: z65.object({
+    id: z65.string(),
+    name: z65.string()
   }),
-  invitedBy: z66.object({
-    id: z66.string(),
-    name: z66.string().nullable(),
-    email: z66.email()
+  invitedBy: z65.object({
+    id: z65.string(),
+    name: z65.string().nullable(),
+    email: z65.email()
   }),
-  process: z66.object({
-    id: z66.string(),
-    name: z66.string()
+  process: z65.object({
+    id: z65.string(),
+    name: z65.string()
   }).optional()
 });
-var createTeamInvitationRequestSchema = z66.object({
-  email: z66.email(),
-  role: z66.string(),
-  processId: z66.guid().optional()
+var createTeamInvitationRequestSchema = z65.object({
+  email: z65.email(),
+  role: z65.string(),
+  processId: z65.guid().optional()
 });
-var acceptTeamInvitationRequestSchema = z66.object({
-  name: z66.string().optional()
+var acceptTeamInvitationRequestSchema = z65.object({
+  name: z65.string().optional()
 });
-var bulkInviteResponseSchema = z66.object({
-  succeeded: z66.number(),
-  skipped: z66.number(),
-  failed: z66.number()
+var bulkInviteResponseSchema = z65.object({
+  succeeded: z65.number(),
+  skipped: z65.number(),
+  failed: z65.number()
 });
-var teamDiscoveryModeSchema = z67.enum(["request", "auto"]);
-var BrowserRegionSchema = z67.enum([
+var teamDiscoveryModeSchema = z66.enum(["request", "auto"]);
+var BrowserRegionSchema = z66.enum([
   "us-west-2",
   "us-east-1",
   "eu-central-1",
   "ap-southeast-1"
 ]);
-var BrowserLocationSchema = z67.union([
-  z67.literal("cz"),
-  z67.literal("de"),
-  z67.literal("fr"),
-  z67.literal("gb"),
-  z67.literal("it"),
-  z67.literal("pl"),
-  z67.literal("sk")
+var BrowserLocationSchema = z66.union([
+  z66.literal("cz"),
+  z66.literal("de"),
+  z66.literal("fr"),
+  z66.literal("gb"),
+  z66.literal("it"),
+  z66.literal("pl"),
+  z66.literal("sk")
 ]);
-var teamMemberApiSchema = z67.object({
-  id: z67.guid(),
-  name: z67.string().nullable(),
-  email: z67.email(),
-  role: z67.string(),
-  inheritedFromOrg: z67.boolean().default(false)
-});
-var listTeamMembersResponseSchema = z67.object({
-  members: z67.array(teamMemberApiSchema),
-  total: z67.number().int().nonnegative(),
-  limit: z67.number().int().positive(),
-  offset: z67.number().int().nonnegative()
-});
-var updateMemberRoleRequestSchema = z67.object({
-  role: z67.string()
-});
-var removeMemberResponseSchema = z67.object({
-  success: z67.literal(true),
-  nextTeamId: z67.guid().nullable(),
-  planType: z67.enum(["pro", "enterprise"]).nullable()
-});
-var getMemberMeResponseSchema = z67.object({
-  role: z67.string().nullable()
-});
-var addTeamMemberRequestSchema = z67.object({
-  userId: z67.guid(),
-  role: z67.string()
-});
-var updateTeamRequestSchema = z67.object({
-  name: z67.string().min(1).optional(),
-  slack_team_id: z67.string().optional(),
+var teamMemberApiSchema = z66.object({
+  id: z66.guid(),
+  name: z66.string().nullable(),
+  email: z66.email(),
+  role: z66.string(),
+  inheritedFromOrg: z66.boolean().default(false)
+});
+var listTeamMembersResponseSchema = z66.object({
+  members: z66.array(teamMemberApiSchema),
+  total: z66.number().int().nonnegative(),
+  limit: z66.number().int().positive(),
+  offset: z66.number().int().nonnegative()
+});
+var updateMemberRoleRequestSchema = z66.object({
+  role: z66.string()
+});
+var removeMemberResponseSchema = z66.object({
+  success: z66.literal(true),
+  nextTeamId: z66.guid().nullable(),
+  planType: z66.enum(["pro", "enterprise"]).nullable()
+});
+var getMemberMeResponseSchema = z66.object({
+  role: z66.string().nullable()
+});
+var addTeamMemberRequestSchema = z66.object({
+  userId: z66.guid(),
+  role: z66.string()
+});
+var updateTeamRequestSchema = z66.object({
+  name: z66.string().min(1).optional(),
+  slack_team_id: z66.string().optional(),
   discovery_mode: teamDiscoveryModeSchema.optional()
 });
-var teamApiSchema = z67.object({
-  id: z67.guid(),
-  name: z67.string(),
-  created_at: z67.string(),
-  organization_id: z67.guid().nullable(),
-  slack_team_id: z67.string().nullable(),
+var teamApiSchema = z66.object({
+  id: z66.guid(),
+  name: z66.string(),
+  created_at: z66.string(),
+  organization_id: z66.guid().nullable(),
+  slack_team_id: z66.string().nullable(),
   discovery_mode: teamDiscoveryModeSchema
 });
 var TEAM_CONFIG_VERSION = 1;
-var teamConfigDataSchema = z67.object({
+var teamConfigDataSchema = z66.object({
   browserProviderOverride: BrowserProviderTypeSchema.nullable().optional(),
   // Egress identity (proxy country) — what the target site sees.
   browserLocationOverride: BrowserLocationSchema.nullable().optional(),
@@ -8695,182 +8675,182 @@ var teamConfigDataSchema = z67.object({
   // Kept optional so existing v1 rows still parse; the resolver reads the new
   // fields first and falls back to these. Do not surface in the UI.
   browserRegionOverride: BrowserRegionSchema.nullable().optional(),
-  sessionRecordingOverride: z67.boolean().nullable().optional()
+  sessionRecordingOverride: z66.boolean().nullable().optional()
 });
-var teamConfigSchema = z67.object({
-  version: z67.literal(TEAM_CONFIG_VERSION),
+var teamConfigSchema = z66.object({
+  version: z66.literal(TEAM_CONFIG_VERSION),
   data: teamConfigDataSchema
 });
-var listTeamInvitesResponseSchema = z67.object({
-  invitations: z67.array(teamInvitationApiSchema)
+var listTeamInvitesResponseSchema = z66.object({
+  invitations: z66.array(teamInvitationApiSchema)
 });
-var teamInsightsCopilotSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string(),
-  teamName: z68.string().nullable().optional(),
-  created_at: z68.string().nullable(),
-  updated_at: z68.string().nullable(),
-  team_id: z68.string().nullable(),
-  thread_id: z68.string().nullable(),
-  slack_enabled: z68.boolean().nullable()
-});
-var teamInsightsUserProfileSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string().nullable(),
-  email: z68.string()
+var teamInsightsCopilotSchema = z67.object({
+  id: z67.guid(),
+  name: z67.string(),
+  teamName: z67.string().nullable().optional(),
+  created_at: z67.string().nullable(),
+  updated_at: z67.string().nullable(),
+  team_id: z67.string().nullable(),
+  thread_id: z67.string().nullable(),
+  slack_enabled: z67.boolean().nullable()
+});
+var teamInsightsUserProfileSchema = z67.object({
+  id: z67.guid(),
+  name: z67.string().nullable(),
+  email: z67.string()
 });
 var teamInsightsUserUsageSchema = teamInsightsUserProfileSchema.extend(
   {
-    runCount: z68.number(),
-    lastRun: z68.string().nullable()
+    runCount: z67.number(),
+    lastRun: z67.string().nullable()
   }
 );
-var teamInsightsMetricSourceSchema = z68.object({
+var teamInsightsMetricSourceSchema = z67.object({
   source: agentRunSourceSchema,
-  runsTotal: z68.number(),
-  completedRuns: z68.number()
+  runsTotal: z67.number(),
+  completedRuns: z67.number()
 });
 var teamInsightsCopilotWithRunsSchema = teamInsightsCopilotSchema.extend({
-  integrations: z68.array(z68.string()),
-  uniqueUsersCount: z68.number(),
-  users: z68.array(teamInsightsUserUsageSchema),
-  totalRuns: z68.number(),
-  completedRuns: z68.number(),
-  totalTimeSpentMs: z68.number(),
-  averageTimeSpentMs: z68.number(),
-  completedRunsWithTiming: z68.number(),
-  sources: z68.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsAgentsRunResponseSchema = z68.object({
-  data: z68.array(teamInsightsCopilotWithRunsSchema),
-  total: z68.number()
-});
-var teamInsightsMetricsResponseSchema = z68.object({
-  runsTotal: z68.number(),
-  completedRuns: z68.number(),
-  sources: z68.array(teamInsightsMetricSourceSchema)
-});
-var teamInsightsUserAgentRunSchema = z68.object({
-  id: z68.guid(),
-  created_at: z68.string(),
-  updated_at: z68.string(),
-  agent_id: z68.guid(),
-  agent_name: z68.string(),
-  build_id: z68.guid(),
-  source: z68.string().nullable(),
-  started_at: z68.string().nullable(),
-  completed_at: z68.string().nullable()
-});
-var teamInsightsAgentSchema = z68.object({
-  id: z68.guid(),
-  name: z68.string(),
-  teamName: z68.string().nullable().optional(),
-  runs: z68.array(teamInsightsUserAgentRunSchema)
+  integrations: z67.array(z67.string()),
+  uniqueUsersCount: z67.number(),
+  users: z67.array(teamInsightsUserUsageSchema),
+  totalRuns: z67.number(),
+  completedRuns: z67.number(),
+  totalTimeSpentMs: z67.number(),
+  averageTimeSpentMs: z67.number(),
+  completedRunsWithTiming: z67.number(),
+  sources: z67.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsAgentsRunResponseSchema = z67.object({
+  data: z67.array(teamInsightsCopilotWithRunsSchema),
+  total: z67.number()
+});
+var teamInsightsMetricsResponseSchema = z67.object({
+  runsTotal: z67.number(),
+  completedRuns: z67.number(),
+  sources: z67.array(teamInsightsMetricSourceSchema)
+});
+var teamInsightsUserAgentRunSchema = z67.object({
+  id: z67.guid(),
+  created_at: z67.string(),
+  updated_at: z67.string(),
+  agent_id: z67.guid(),
+  agent_name: z67.string(),
+  build_id: z67.guid(),
+  source: z67.string().nullable(),
+  started_at: z67.string().nullable(),
+  completed_at: z67.string().nullable()
+});
+var teamInsightsAgentSchema = z67.object({
+  id: z67.guid(),
+  name: z67.string(),
+  teamName: z67.string().nullable().optional(),
+  runs: z67.array(teamInsightsUserAgentRunSchema)
 });
 var teamInsightsUserWithAgentsAndRunsSchema = teamInsightsUserProfileSchema.extend({
-  agents: z68.array(teamInsightsAgentSchema),
-  runs: z68.array(teamInsightsUserAgentRunSchema),
-  totalRuns: z68.number()
-});
-var teamInsightsUsersResponseSchema = z68.object({
-  data: z68.array(teamInsightsUserWithAgentsAndRunsSchema),
-  total: z68.number()
-});
-var guardrailsAuthorSchema = z69.object({
-  id: z69.guid(),
-  name: z69.string().nullable(),
-  email: z69.email()
-});
-var guardrailsRevisionSchema = z69.object({
-  id: z69.guid(),
-  teamId: z69.guid(),
-  guardrailsText: z69.string().nullable(),
-  blockedDomains: z69.array(z69.string()),
-  createdAt: z69.string(),
+  agents: z67.array(teamInsightsAgentSchema),
+  runs: z67.array(teamInsightsUserAgentRunSchema),
+  totalRuns: z67.number()
+});
+var teamInsightsUsersResponseSchema = z67.object({
+  data: z67.array(teamInsightsUserWithAgentsAndRunsSchema),
+  total: z67.number()
+});
+var guardrailsAuthorSchema = z68.object({
+  id: z68.guid(),
+  name: z68.string().nullable(),
+  email: z68.email()
+});
+var guardrailsRevisionSchema = z68.object({
+  id: z68.guid(),
+  teamId: z68.guid(),
+  guardrailsText: z68.string().nullable(),
+  blockedDomains: z68.array(z68.string()),
+  createdAt: z68.string(),
   createdBy: guardrailsAuthorSchema
 });
-var getTeamGuardrailsResponseSchema = z69.object({
+var getTeamGuardrailsResponseSchema = z68.object({
   current: guardrailsRevisionSchema.nullable()
 });
-var listTeamGuardrailsRevisionsQuerySchema = z69.object({
-  limit: z69.coerce.number().int().min(1).max(100).default(20),
-  offset: z69.coerce.number().int().min(0).default(0)
+var listTeamGuardrailsRevisionsQuerySchema = z68.object({
+  limit: z68.coerce.number().int().min(1).max(100).default(20),
+  offset: z68.coerce.number().int().min(0).default(0)
 });
-var listTeamGuardrailsRevisionsResponseSchema = z69.object({
-  revisions: z69.array(guardrailsRevisionSchema),
-  total: z69.number().int().nonnegative()
+var listTeamGuardrailsRevisionsResponseSchema = z68.object({
+  revisions: z68.array(guardrailsRevisionSchema),
+  total: z68.number().int().nonnegative()
 });
-var createTeamGuardrailsRevisionRequestSchema = z69.object({
-  guardrailsText: z69.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
-  blockedDomains: z69.array(z69.string()).max(MAX_BLOCKED_DOMAINS)
+var createTeamGuardrailsRevisionRequestSchema = z68.object({
+  guardrailsText: z68.string().max(MAX_GUARDRAILS_TEXT_LENGTH).nullable().transform((value) => value && value.trim().length > 0 ? value : null),
+  blockedDomains: z68.array(z68.string()).max(MAX_BLOCKED_DOMAINS)
 });
-var userDismissalListResponseSchema = z70.object({
-  data: z70.array(z70.string())
+var userDismissalListResponseSchema = z69.object({
+  data: z69.array(z69.string())
 });
-var userDismissalMutationSchema = z70.object({
-  elementKey: z70.string()
+var userDismissalMutationSchema = z69.object({
+  elementKey: z69.string()
 });
 var PASSWORD_MIN = 1;
 var PASSWORD_MAX = 1024;
 var NAME_MAX = 200;
 var URL_MAX = 500;
 var USERNAME_MAX = 200;
-var vpnProxyConfigSummarySchema = z71.object({
-  id: z71.guid(),
-  name: z71.string(),
-  server: z71.string(),
-  username: z71.string(),
-  enabled: z71.boolean(),
-  passwordSet: z71.boolean(),
-  organizationCount: z71.number().int().nonnegative(),
-  createdAt: z71.string(),
-  updatedAt: z71.string()
-});
-var vpnProxyConfigListResponseSchema = z71.object({
-  configs: z71.array(vpnProxyConfigSummarySchema)
-});
-var vpnProxyConfigCreateRequestSchema = z71.object({
-  name: z71.string().trim().min(1).max(NAME_MAX),
-  server: z71.string().trim().min(1).max(URL_MAX).url(),
-  username: z71.string().trim().min(1).max(USERNAME_MAX),
-  password: z71.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
-  enabled: z71.boolean().prefault(true)
-});
-var vpnProxyConfigCreateResponseSchema = z71.object({
+var vpnProxyConfigSummarySchema = z70.object({
+  id: z70.guid(),
+  name: z70.string(),
+  server: z70.string(),
+  username: z70.string(),
+  enabled: z70.boolean(),
+  passwordSet: z70.boolean(),
+  organizationCount: z70.number().int().nonnegative(),
+  createdAt: z70.string(),
+  updatedAt: z70.string()
+});
+var vpnProxyConfigListResponseSchema = z70.object({
+  configs: z70.array(vpnProxyConfigSummarySchema)
+});
+var vpnProxyConfigCreateRequestSchema = z70.object({
+  name: z70.string().trim().min(1).max(NAME_MAX),
+  server: z70.string().trim().min(1).max(URL_MAX).url(),
+  username: z70.string().trim().min(1).max(USERNAME_MAX),
+  password: z70.string().min(PASSWORD_MIN).max(PASSWORD_MAX),
+  enabled: z70.boolean().prefault(true)
+});
+var vpnProxyConfigCreateResponseSchema = z70.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigUpdateRequestSchema = z71.object({
-  name: z71.string().trim().min(1).max(NAME_MAX).optional(),
-  server: z71.string().trim().min(1).max(URL_MAX).url().optional(),
-  username: z71.string().trim().min(1).max(USERNAME_MAX).optional(),
-  password: z71.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
-  enabled: z71.boolean().optional()
+var vpnProxyConfigUpdateRequestSchema = z70.object({
+  name: z70.string().trim().min(1).max(NAME_MAX).optional(),
+  server: z70.string().trim().min(1).max(URL_MAX).url().optional(),
+  username: z70.string().trim().min(1).max(USERNAME_MAX).optional(),
+  password: z70.string().min(PASSWORD_MIN).max(PASSWORD_MAX).optional(),
+  enabled: z70.boolean().optional()
 });
-var vpnProxyConfigUpdateResponseSchema = z71.object({
+var vpnProxyConfigUpdateResponseSchema = z70.object({
   config: vpnProxyConfigSummarySchema
 });
-var vpnProxyConfigDeleteResponseSchema = z71.object({
-  success: z71.literal(true)
+var vpnProxyConfigDeleteResponseSchema = z70.object({
+  success: z70.literal(true)
 });
-var vpnProxyConfigOrganizationSchema = z71.object({
-  id: z71.guid(),
-  organizationId: z71.guid(),
-  organizationName: z71.string(),
-  attachedAt: z71.string()
+var vpnProxyConfigOrganizationSchema = z70.object({
+  id: z70.guid(),
+  organizationId: z70.guid(),
+  organizationName: z70.string(),
+  attachedAt: z70.string()
 });
-var vpnProxyConfigOrganizationListResponseSchema = z71.object({
-  organizations: z71.array(vpnProxyConfigOrganizationSchema)
+var vpnProxyConfigOrganizationListResponseSchema = z70.object({
+  organizations: z70.array(vpnProxyConfigOrganizationSchema)
 });
-var vpnProxyConfigAttachOrganizationRequestSchema = z71.object({
-  organizationId: z71.guid()
+var vpnProxyConfigAttachOrganizationRequestSchema = z70.object({
+  organizationId: z70.guid()
 });
-var vpnProxyConfigAttachOrganizationResponseSchema = z71.object({
+var vpnProxyConfigAttachOrganizationResponseSchema = z70.object({
   attachment: vpnProxyConfigOrganizationSchema
 });
-var vpnProxyConfigDetachOrganizationResponseSchema = z71.object({
-  success: z71.literal(true)
+var vpnProxyConfigDetachOrganizationResponseSchema = z70.object({
+  success: z70.literal(true)
 });
-var vpnProxyConfigForOrganizationResponseSchema = z71.object({
+var vpnProxyConfigForOrganizationResponseSchema = z70.object({
   config: vpnProxyConfigSummarySchema.nullable()
 });
 function canonicalizeSopInput(config) {
@@ -8891,7 +8871,7 @@ function canonicalizeSopInput(config) {
 }
 __name(canonicalizeSopInput, "canonicalizeSopInput");
 __name2(canonicalizeSopInput, "canonicalizeSopInput");
-var caseFilterStatusSchema = z72.enum([
+var caseFilterStatusSchema = z71.enum([
   "pending",
   "claimed",
   "completed",
@@ -8899,19 +8879,19 @@ var caseFilterStatusSchema = z72.enum([
   "needs_input",
   "postponed"
 ]);
-var casesFiltersSchema = z72.object({
-  status: z72.array(caseFilterStatusSchema).optional(),
-  created_at_from: z72.string().optional(),
-  updated_at_from: z72.string().optional(),
-  labels: z72.record(z72.string(), z72.array(z72.string())).optional()
+var casesFiltersSchema = z71.object({
+  status: z71.array(caseFilterStatusSchema).optional(),
+  created_at_from: z71.string().optional(),
+  updated_at_from: z71.string().optional(),
+  labels: z71.record(z71.string(), z71.array(z71.string())).optional()
 });
-var casesListRequestBodySchema = z72.object({
+var casesListRequestBodySchema = z71.object({
   filters: casesFiltersSchema.default({}),
-  limit: z72.int().min(1).max(100).default(25),
-  offset: z72.int().min(0).default(0),
-  sort_by: z72.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
-  sort_order: z72.enum(["asc", "desc"]).default("desc"),
-  search: z72.string().optional()
+  limit: z71.int().min(1).max(100).default(25),
+  offset: z71.int().min(0).default(0),
+  sort_by: z71.enum(["created_at", "updated_at", "postponed_to"]).default("created_at"),
+  sort_order: z71.enum(["asc", "desc"]).default("desc"),
+  search: z71.string().optional()
 });
 function toBase64(input) {
   if (typeof btoa === "function") {
@@ -9006,7 +8986,7 @@ function setFilterValuesByCategoryKey(filters, categoryKey, values) {
       const { status: _, ...rest } = filters;
       return rest;
     }
-    const parsed = z72.array(caseFilterStatusSchema).safeParse(values);
+    const parsed = z71.array(caseFilterStatusSchema).safeParse(values);
     if (!parsed.success) {
       return filters;
     }
@@ -9252,6 +9232,91 @@ function safeParseJson(input, log2, schema) {
 }
 __name(safeParseJson, "safeParseJson");
 __name2(safeParseJson, "safeParseJson");
+var QUEUE_MENTION_REGEX_SOURCE = `<DUVO:QUEUE\\s+id="((?:[^"\\\\]|\\\\.)*)"\\s+name="((?:[^"\\\\]|\\\\.)*)">`;
+function escapeAttrValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+__name(escapeAttrValue, "escapeAttrValue");
+__name2(escapeAttrValue, "escapeAttrValue");
+function unescapeAttrValue2(value) {
+  return value.replace(/\\(.)/g, "$1");
+}
+__name(unescapeAttrValue2, "unescapeAttrValue2");
+__name2(unescapeAttrValue2, "unescapeAttrValue");
+function createQueueMentionRegex() {
+  return new RegExp(QUEUE_MENTION_REGEX_SOURCE, "g");
+}
+__name(createQueueMentionRegex, "createQueueMentionRegex");
+__name2(createQueueMentionRegex, "createQueueMentionRegex");
+function serializeQueueMention(id, name) {
+  return `<DUVO:QUEUE id="${escapeAttrValue(id)}" name="${escapeAttrValue(name)}">`;
+}
+__name(serializeQueueMention, "serializeQueueMention");
+__name2(serializeQueueMention, "serializeQueueMention");
+function parseQueueMentionSegments(text3) {
+  if (!text3) {
+    return [];
+  }
+  const segments = [];
+  let lastIndex = 0;
+  for (const match of text3.matchAll(createQueueMentionRegex())) {
+    const matchStart = match.index ?? 0;
+    if (matchStart > lastIndex) {
+      segments.push({ type: "text", value: text3.slice(lastIndex, matchStart) });
+    }
+    segments.push({
+      type: "mention",
+      id: unescapeAttrValue2(match[1]),
+      name: unescapeAttrValue2(match[2])
+    });
+    lastIndex = matchStart + match[0].length;
+  }
+  if (lastIndex < text3.length) {
+    segments.push({ type: "text", value: text3.slice(lastIndex) });
+  }
+  return segments;
+}
+__name(parseQueueMentionSegments, "parseQueueMentionSegments");
+__name2(parseQueueMentionSegments, "parseQueueMentionSegments");
+function extractQueueMentions(text3) {
+  if (!text3) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const mentions = [];
+  for (const match of text3.matchAll(createQueueMentionRegex())) {
+    const id = unescapeAttrValue2(match[1]);
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    mentions.push({ id, name: unescapeAttrValue2(match[2]) });
+  }
+  return mentions;
+}
+__name(extractQueueMentions, "extractQueueMentions");
+__name2(extractQueueMentions, "extractQueueMentions");
+function textContainsQueueMention(text3) {
+  if (!text3) {
+    return false;
+  }
+  return createQueueMentionRegex().test(text3);
+}
+__name(textContainsQueueMention, "textContainsQueueMention");
+__name2(textContainsQueueMention, "textContainsQueueMention");
+function formatQueueMentionsAsText(text3) {
+  if (!text3) {
+    return text3;
+  }
+  return text3.replace(
+    createQueueMentionRegex(),
+    (_match, _id, name) => {
+      return `@${unescapeAttrValue2(name)}`;
+    }
+  );
+}
+__name(formatQueueMentionsAsText, "formatQueueMentionsAsText");
+__name2(formatQueueMentionsAsText, "formatQueueMentionsAsText");
 var BASE_HUES = [0, 30, 50, 90, 145, 175, 215, 270, 330];
 function isLabelHue(value) {
   return BASE_HUES.includes(value);
@@ -10146,11 +10211,11 @@ function emptyConfig() {
 __name(emptyConfig, "emptyConfig");
 
 // src/config/env.ts
-import { z as z73 } from "zod";
-var optionalEnvString = z73.string().optional().transform(
+import { z as z72 } from "zod";
+var optionalEnvString = z72.string().optional().transform(
   (value) => value === void 0 || value === "" ? void 0 : value
 );
-var CliEnvSchema = z73.object({
+var CliEnvSchema = z72.object({
   DUVO_PROFILE: optionalEnvString,
   DUVO_API_KEY: optionalEnvString,
   DUVO_API_BASE_URL: optionalEnvString,
@@ -10646,9 +10711,9 @@ async function requireAuthenticatedConfig(command) {
 __name(requireAuthenticatedConfig, "requireAuthenticatedConfig");
 
 // src/commands/shared/team-context.ts
-import { z as z74 } from "zod";
-var teamSchema = z74.object({ id: z74.string() });
-var listMyTeamsResponseSchema = z74.object({ teams: z74.array(teamSchema) });
+import { z as z73 } from "zod";
+var teamSchema = z73.object({ id: z73.string() });
+var listMyTeamsResponseSchema = z73.object({ teams: z73.array(teamSchema) });
 async function resolveRequiredTeamId(config, options = {}) {
   if (options.override) {
     return options.override;
@@ -11436,56 +11501,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 z76 } from "zod";
+import { z as z75 } from "zod";
 
 // src/api/json-value.ts
-import { z as z75 } from "zod";
-var jsonValueSchema = z75.lazy(
-  () => z75.union([
-    z75.string(),
-    z75.number(),
-    z75.boolean(),
-    z75.null(),
-    z75.array(jsonValueSchema),
-    z75.record(z75.string(), jsonValueSchema)
+import { z as z74 } from "zod";
+var jsonValueSchema = z74.lazy(
+  () => z74.union([
+    z74.string(),
+    z74.number(),
+    z74.boolean(),
+    z74.null(),
+    z74.array(jsonValueSchema),
+    z74.record(z74.string(), jsonValueSchema)
   ])
 );
 
 // src/api/agent-schemas.ts
-var publicAgentSchema = z76.object({
-  id: z76.string(),
-  name: z76.string(),
-  slack_enabled: z76.boolean().nullish(),
-  microsoft_teams_enabled: z76.boolean().nullish(),
-  agentic_memory_enabled: z76.boolean().nullish(),
-  thread_id: z76.string().nullish(),
-  created_at: z76.string().nullish(),
-  updated_at: z76.string().nullish(),
-  latest_build: z76.object({ config: jsonValueSchema.nullish() }).nullish()
-});
-var publicBuildSchema = z76.object({
-  id: z76.string(),
-  agent_id: z76.string(),
-  name: z76.string(),
-  revision_number: z76.number().nullish(),
-  created_at: z76.string().nullish(),
-  updated_at: z76.string().nullish()
-});
-var listAgentsResponseSchema = z76.object({
-  agents: z76.array(publicAgentSchema),
-  total: z76.number().nullish(),
-  limit: z76.number().nullish(),
-  offset: z76.number().nullish()
-});
-var getAgentResponseSchema = z76.object({
+var publicAgentSchema = z75.object({
+  id: z75.string(),
+  name: z75.string(),
+  slack_enabled: z75.boolean().nullish(),
+  microsoft_teams_enabled: z75.boolean().nullish(),
+  agentic_memory_enabled: z75.boolean().nullish(),
+  thread_id: z75.string().nullish(),
+  created_at: z75.string().nullish(),
+  updated_at: z75.string().nullish(),
+  latest_build: z75.object({ config: jsonValueSchema.nullish() }).nullish()
+});
+var publicBuildSchema = z75.object({
+  id: z75.string(),
+  agent_id: z75.string(),
+  name: z75.string(),
+  revision_number: z75.number().nullish(),
+  created_at: z75.string().nullish(),
+  updated_at: z75.string().nullish()
+});
+var listAgentsResponseSchema = z75.object({
+  agents: z75.array(publicAgentSchema),
+  total: z75.number().nullish(),
+  limit: z75.number().nullish(),
+  offset: z75.number().nullish()
+});
+var getAgentResponseSchema = z75.object({
   agent: publicAgentSchema
 });
-var createAgentResponseSchema = z76.object({
+var createAgentResponseSchema = z75.object({
   agent: publicAgentSchema,
   build: publicBuildSchema.optional()
 });
-var deleteAgentResponseSchema = z76.object({
-  success: z76.literal(true)
+var deleteAgentResponseSchema = z75.object({
+  success: z75.literal(true)
 });
 var buildConfigSchema = StoredAgentConfigSchemaV2;
 var DEFAULT_NEW_AGENT_NAME = DEFAULT_AGENT_NAME;
@@ -11935,29 +12000,29 @@ function registerAgentsEvalScores(agents) {
 __name(registerAgentsEvalScores, "registerAgentsEvalScores");
 
 // src/api/build-schemas.ts
-import { z as z77 } from "zod";
-var publicBuildSchema2 = z77.object({
-  id: z77.string(),
-  agent_id: z77.string(),
-  name: z77.string(),
-  status: z77.string().nullish(),
+import { z as z76 } from "zod";
+var publicBuildSchema2 = z76.object({
+  id: z76.string(),
+  agent_id: z76.string(),
+  name: z76.string(),
+  status: z76.string().nullish(),
   config: jsonValueSchema.nullish(),
-  revision_number: z77.number().nullish(),
-  created_at: z77.string().nullish(),
-  updated_at: z77.string().nullish()
+  revision_number: z76.number().nullish(),
+  created_at: z76.string().nullish(),
+  updated_at: z76.string().nullish()
 });
-var listBuildsResponseSchema2 = z77.object({
-  builds: z77.array(publicBuildSchema2),
-  total: z77.number().nullish(),
-  limit: z77.number().nullish(),
-  offset: z77.number().nullish()
+var listBuildsResponseSchema2 = z76.object({
+  builds: z76.array(publicBuildSchema2),
+  total: z76.number().nullish(),
+  limit: z76.number().nullish(),
+  offset: z76.number().nullish()
 });
-var getBuildResponseSchema = z77.object({
+var getBuildResponseSchema = z76.object({
   build: publicBuildSchema2
 });
-var createBuildResponseSchema = z77.object({
+var createBuildResponseSchema = z76.object({
   build: publicBuildSchema2,
-  agent: z77.object({ id: z77.string() })
+  agent: z76.object({ id: z76.string() })
 });
 
 // src/commands/agents/get.ts
@@ -12207,30 +12272,30 @@ function registerAgentsModels(agents) {
 __name(registerAgentsModels, "registerAgentsModels");
 
 // src/api/schedule-schemas.ts
-import { z as z78 } from "zod";
-var publicScheduleSchema = z78.object({
-  id: z78.string(),
-  build_id: z78.string(),
-  agent_id: z78.string(),
-  user_id: z78.string(),
-  enabled: z78.boolean(),
-  frequency: z78.string(),
-  time: z78.string().nullish(),
-  timezone: z78.string(),
-  day: z78.string().nullish(),
-  day_of_month: z78.number().nullish(),
-  cron: z78.string().nullish(),
-  source: z78.string().nullish(),
-  task: z78.string().nullish(),
-  recurring: z78.boolean().nullish(),
-  created_at: z78.string(),
-  updated_at: z78.string()
-});
-var listSchedulesResponseSchema = z78.object({
-  schedules: z78.array(publicScheduleSchema)
-});
-var deleteScheduleResponseSchema = z78.object({
-  success: z78.literal(true)
+import { z as z77 } from "zod";
+var publicScheduleSchema = z77.object({
+  id: z77.string(),
+  build_id: z77.string(),
+  agent_id: z77.string(),
+  user_id: z77.string(),
+  enabled: z77.boolean(),
+  frequency: z77.string(),
+  time: z77.string().nullish(),
+  timezone: z77.string(),
+  day: z77.string().nullish(),
+  day_of_month: z77.number().nullish(),
+  cron: z77.string().nullish(),
+  source: z77.string().nullish(),
+  task: z77.string().nullish(),
+  recurring: z77.boolean().nullish(),
+  created_at: z77.string(),
+  updated_at: z77.string()
+});
+var listSchedulesResponseSchema = z77.object({
+  schedules: z77.array(publicScheduleSchema)
+});
+var deleteScheduleResponseSchema = z77.object({
+  success: z77.literal(true)
 });
 
 // src/commands/agents/schedules/render-schedule.ts
@@ -12678,33 +12743,33 @@ function registerAgentsSetModel(agents) {
 __name(registerAgentsSetModel, "registerAgentsSetModel");
 
 // src/api/trigger-schemas.ts
-import { z as z79 } from "zod";
-var triggerSchema = z79.object({
-  id: z79.string(),
-  agent_id: z79.string(),
-  user_id: z79.string(),
-  integration_slug: z79.string(),
-  trigger_type: z79.string(),
-  filter_config: z79.record(z79.string(), z79.unknown()),
-  integration_instance_id: z79.string(),
-  enabled: z79.boolean(),
-  created_at: z79.string(),
-  updated_at: z79.string()
+import { z as z78 } from "zod";
+var triggerSchema = z78.object({
+  id: z78.string(),
+  agent_id: z78.string(),
+  user_id: z78.string(),
+  integration_slug: z78.string(),
+  trigger_type: z78.string(),
+  filter_config: z78.record(z78.string(), z78.unknown()),
+  integration_instance_id: z78.string(),
+  enabled: z78.boolean(),
+  created_at: z78.string(),
+  updated_at: z78.string()
 });
-var listTriggersResponseSchema = z79.object({
-  triggers: z79.array(triggerSchema)
+var listTriggersResponseSchema = z78.object({
+  triggers: z78.array(triggerSchema)
 });
-var triggerTypeSchema = z79.object({
-  integration_slug: z79.string(),
-  integration_name: z79.string(),
-  icon_url: z79.string(),
-  trigger_type: z79.string(),
-  label: z79.string(),
-  description: z79.string(),
-  filter_schema: z79.record(z79.string(), z79.unknown())
+var triggerTypeSchema = z78.object({
+  integration_slug: z78.string(),
+  integration_name: z78.string(),
+  icon_url: z78.string(),
+  trigger_type: z78.string(),
+  label: z78.string(),
+  description: z78.string(),
+  filter_schema: z78.record(z78.string(), z78.unknown())
 });
-var listTriggerTypesResponseSchema = z79.object({
-  trigger_types: z79.array(triggerTypeSchema)
+var listTriggerTypesResponseSchema = z78.object({
+  trigger_types: z78.array(triggerTypeSchema)
 });
 
 // src/commands/agents/triggers/list.ts
@@ -13328,55 +13393,55 @@ function fieldsToSearchParams(fields) {
 __name(fieldsToSearchParams, "fieldsToSearchParams");
 
 // src/api/integration-schemas.ts
-import { z as z80 } from "zod";
-var integrationSchema = z80.object({
-  id: z80.string(),
-  name: z80.string(),
-  type: z80.string(),
-  provider: z80.string(),
-  user_id: z80.string().nullable(),
-  team_id: z80.string(),
-  server_url: z80.string().optional(),
-  transport_type: z80.string().optional(),
-  auth_method: z80.string().nullish(),
-  composio_mcp_id: z80.string().nullish(),
-  custom_integration_id: z80.string().nullish(),
-  icon_url: z80.string().nullish(),
-  oauth_provider: z80.string().nullish(),
-  oauth_provider_key: z80.string().nullish(),
-  oauth_scopes: z80.array(z80.string()).nullish(),
-  integration_id: z80.string().nullish(),
-  created_at: z80.string(),
-  updated_at: z80.string()
-});
-var integrationsListResponseSchema2 = z80.object({
-  integrations: z80.array(integrationSchema)
+import { z as z79 } from "zod";
+var integrationSchema = z79.object({
+  id: z79.string(),
+  name: z79.string(),
+  type: z79.string(),
+  provider: z79.string(),
+  user_id: z79.string().nullable(),
+  team_id: z79.string(),
+  server_url: z79.string().optional(),
+  transport_type: z79.string().optional(),
+  auth_method: z79.string().nullish(),
+  composio_mcp_id: z79.string().nullish(),
+  custom_integration_id: z79.string().nullish(),
+  icon_url: z79.string().nullish(),
+  oauth_provider: z79.string().nullish(),
+  oauth_provider_key: z79.string().nullish(),
+  oauth_scopes: z79.array(z79.string()).nullish(),
+  integration_id: z79.string().nullish(),
+  created_at: z79.string(),
+  updated_at: z79.string()
+});
+var integrationsListResponseSchema2 = z79.object({
+  integrations: z79.array(integrationSchema)
 });
 var connectionResponseSchema = integrationSchema;
-var buildIntegrationConfigSchema2 = z80.object({
-  id: z80.string(),
-  integration_id: z80.string().nullable(),
-  custom_integration_id: z80.string().nullable(),
-  integration_type: z80.string(),
-  integration_name: z80.string(),
-  created_at: z80.string()
+var buildIntegrationConfigSchema2 = z79.object({
+  id: z79.string(),
+  integration_id: z79.string().nullable(),
+  custom_integration_id: z79.string().nullable(),
+  integration_type: z79.string(),
+  integration_name: z79.string(),
+  created_at: z79.string()
 });
-var listBuildIntegrationsResponseSchema2 = z80.object({
-  integrations: z80.array(buildIntegrationConfigSchema2)
+var listBuildIntegrationsResponseSchema2 = z79.object({
+  integrations: z79.array(buildIntegrationConfigSchema2)
 });
-var attachBuildIntegrationsResponseSchema = z80.object({
-  success: z80.boolean(),
-  count: z80.number()
+var attachBuildIntegrationsResponseSchema = z79.object({
+  success: z79.boolean(),
+  count: z79.number()
 });
-var buildIntegrationConnectionSchema = z80.object({
-  connection_id: z80.string(),
-  created_at: z80.string()
+var buildIntegrationConnectionSchema = z79.object({
+  connection_id: z79.string(),
+  created_at: z79.string()
 });
-var listBuildIntegrationConnectionsResponseSchema = z80.object({
-  connections: z80.array(buildIntegrationConnectionSchema)
+var listBuildIntegrationConnectionsResponseSchema = z79.object({
+  connections: z79.array(buildIntegrationConnectionSchema)
 });
-var successResponseSchema = z80.object({
-  success: z80.boolean()
+var successResponseSchema = z79.object({
+  success: z79.boolean()
 });
 
 // src/commands/build-integrations/attach.ts
@@ -13419,15 +13484,15 @@ function registerBuildIntegrationsAttach(buildIntegrations) {
 __name(registerBuildIntegrationsAttach, "registerBuildIntegrationsAttach");
 
 // src/commands/build-integrations/case-queue-setup.ts
-import { z as z81 } from "zod";
-var slotSchema = z81.object({
-  config_id: z81.string(),
-  integration_type: z81.string(),
-  linked_queue_count: z81.number()
+import { z as z80 } from "zod";
+var slotSchema = z80.object({
+  config_id: z80.string(),
+  integration_type: z80.string(),
+  linked_queue_count: z80.number()
 });
-var responseSchema2 = z81.object({
-  configs: z81.array(slotSchema),
-  has_available_queues: z81.boolean()
+var responseSchema2 = z80.object({
+  configs: z80.array(slotSchema),
+  has_available_queues: z80.boolean()
 });
 var TABLE_COLUMNS10 = [
   { header: "SLOT ID", cell: /* @__PURE__ */ __name((row) => row.config_id, "cell") },
@@ -13922,9 +13987,9 @@ function registerBuildsList(builds) {
 __name(registerBuildsList, "registerBuildsList");
 
 // src/commands/builds/promote.ts
-import { z as z82 } from "zod";
-var promoteResponseSchema = z82.object({
-  success: z82.boolean()
+import { z as z81 } from "zod";
+var promoteResponseSchema = z81.object({
+  success: z81.boolean()
 });
 function registerBuildsPromote(builds) {
   builds.command("promote <id>").description(
@@ -14935,7 +15000,7 @@ function parseSortOrder(raw) {
 __name(parseSortOrder, "parseSortOrder");
 
 // src/commands/cases/runs.ts
-import { z as z83 } from "zod";
+import { z as z82 } from "zod";
 var MIN_LIMIT4 = 1;
 var MAX_LIMIT4 = 10;
 var DEFAULT_LIMIT4 = 3;
@@ -14953,17 +15018,17 @@ var RUNS_TABLE_COLUMNS = [
     cell: /* @__PURE__ */ __name((row) => row.has_pending_human_request ? row.pending_human_request_title ?? "(unknown)" : "", "cell")
   }
 ];
-var recentMessageSchema = z83.object({
-  id: z83.string(),
-  type: z83.string(),
-  role: z83.string(),
-  timestamp: z83.string(),
-  text_content: z83.string().nullish(),
-  tool_call: z83.object({ id: z83.string(), name: z83.string() }).passthrough().nullish(),
-  tool_result: z83.object({ tool_call_id: z83.string() }).passthrough().nullish()
-});
-var recentMessagesResponseSchema = z83.object({
-  messages: z83.array(recentMessageSchema)
+var recentMessageSchema = 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() }).passthrough().nullish(),
+  tool_result: z82.object({ tool_call_id: z82.string() }).passthrough().nullish()
+});
+var recentMessagesResponseSchema = z82.object({
+  messages: z82.array(recentMessageSchema)
 });
 var TEXT_PREVIEW_WIDTH = 60;
 var MESSAGES_TABLE_COLUMNS = [
@@ -15092,55 +15157,55 @@ function registerCases(program) {
 __name(registerCases, "registerCases");
 
 // src/api/clarity-schemas.ts
-import { z as z84 } from "zod";
-var clarityListProcessSchema = z84.object({
-  id: z84.guid(),
-  name: z84.string(),
+import { z as z83 } from "zod";
+var clarityListProcessSchema = z83.object({
+  id: z83.guid(),
+  name: z83.string(),
   status: clarityProcessStatusSchema,
   visibility: clarityProcessVisibilitySchema,
-  version: z84.number().int(),
-  capture_count: z84.number().int(),
-  capture_counts: z84.object({
-    video: z84.number().int(),
-    interview: z84.number().int(),
-    document: z84.number().int()
+  version: z83.number().int(),
+  capture_count: z83.number().int(),
+  capture_counts: z83.object({
+    video: z83.number().int(),
+    interview: z83.number().int(),
+    document: z83.number().int()
   }).optional(),
-  pending_invitation_count: z84.number().int(),
-  contributors: z84.array(
-    z84.object({
-      user_id: z84.string(),
-      user_name: z84.string()
+  pending_invitation_count: z83.number().int(),
+  contributors: z83.array(
+    z83.object({
+      user_id: z83.string(),
+      user_name: z83.string()
     })
   ),
-  created_at: z84.string(),
-  created_by_name: z84.string().nullable()
-});
-var listClarityProcessesResponseSchema = z84.object({
-  processes: z84.array(clarityListProcessSchema),
-  total: z84.number().int(),
-  limit: z84.number().int(),
-  offset: z84.number().int()
-});
-var createClarityInviteLinkResponseSchema = z84.object({
-  invite_link: z84.object({
-    id: z84.guid(),
-    url: z84.url(),
-    created_at: z84.string(),
-    created_by: z84.object({
-      id: z84.guid(),
-      email: z84.email().nullable()
+  created_at: z83.string(),
+  created_by_name: z83.string().nullable()
+});
+var listClarityProcessesResponseSchema = z83.object({
+  processes: z83.array(clarityListProcessSchema),
+  total: z83.number().int(),
+  limit: z83.number().int(),
+  offset: z83.number().int()
+});
+var createClarityInviteLinkResponseSchema = z83.object({
+  invite_link: z83.object({
+    id: z83.guid(),
+    url: z83.url(),
+    created_at: z83.string(),
+    created_by: z83.object({
+      id: z83.guid(),
+      email: z83.email().nullable()
     })
   })
 });
-var createArtifactImportUploadUrlResponseSchema = z84.object({
-  signed_url: z84.url(),
-  capture_id: z84.guid(),
-  expires_at: z84.iso.datetime()
+var createArtifactImportUploadUrlResponseSchema = z83.object({
+  signed_url: z83.url(),
+  capture_id: z83.guid(),
+  expires_at: z83.iso.datetime()
 });
-var completeArtifactImportResponseSchema = z84.object({
+var completeArtifactImportResponseSchema = z83.object({
   capture: clarityCaptureSchema.extend({
-    createdAt: z84.iso.datetime(),
-    updatedAt: z84.iso.datetime()
+    createdAt: z83.iso.datetime(),
+    updatedAt: z83.iso.datetime()
   })
 });
 var legacyClarityProcessResponseSchema = legacyClarityProcessDetailSchema;
@@ -15579,8 +15644,8 @@ function renderCompletedImport(response) {
 __name(renderCompletedImport, "renderCompletedImport");
 
 // src/commands/clarity/assign-extra-capture-request.ts
-import { z as z85 } from "zod";
-var responseSchema3 = z85.object({
+import { z as z84 } from "zod";
+var responseSchema3 = z84.object({
   request: clarityProposalExtraCaptureRequestSchema
 });
 function renderRequest(request) {
@@ -15627,11 +15692,11 @@ function registerClarityAssignExtraCaptureRequest(clarity) {
 __name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
 // src/commands/clarity/build-automation.ts
-import { z as z86 } from "zod";
-var responseSchema4 = z86.object({
-  automation_run: z86.object({
-    id: z86.string(),
-    status: z86.string()
+import { z as z85 } from "zod";
+var responseSchema4 = z85.object({
+  automation_run: z85.object({
+    id: z85.string(),
+    status: z85.string()
   })
 });
 function registerClarityBuildAutomation(clarity) {
@@ -15702,7 +15767,7 @@ function registerClarityCreateInviteLink(clarity) {
 __name(registerClarityCreateInviteLink, "registerClarityCreateInviteLink");
 
 // src/commands/clarity/doctor.ts
-import { z as z87 } from "zod";
+import { z as z86 } from "zod";
 
 // src/commands/clarity/render.ts
 var DEFAULT_HUMAN_SUMMARY_LIMIT = 1200;
@@ -16934,6 +16999,19 @@ var CLARITY_READ_TOOLS = [
       }
     ],
     description: "Read messages for one artifact-chat conversation in a v2 process."
+  },
+  {
+    name: "listClarityProcessLinks",
+    scope: "v1+v2",
+    read_only: true,
+    commands: ["duvo clarity process-links list"],
+    endpoints: [
+      {
+        method: "GET",
+        path: "/v2/teams/:teamId/clarity/hierarchy/process-links"
+      }
+    ],
+    description: "List process-to-process links in the Clarity process landscape."
   }
 ];
 var CLARITY_WRITE_TOOLS = [
@@ -17131,6 +17209,45 @@ var CLARITY_WRITE_TOOLS = [
       }
     ],
     description: "Upload and complete a local Miro SVG, XML, PNG, or JPEG export."
+  },
+  {
+    name: "createClarityProcessLink",
+    scope: "v1+v2",
+    read_only: false,
+    commands: ["duvo clarity process-links create"],
+    endpoints: [
+      {
+        method: "POST",
+        path: "/v2/teams/:teamId/clarity/hierarchy/process-links"
+      }
+    ],
+    description: "Create a process-to-process link in the Clarity landscape."
+  },
+  {
+    name: "updateClarityProcessLink",
+    scope: "v1+v2",
+    read_only: false,
+    commands: ["duvo clarity process-links update"],
+    endpoints: [
+      {
+        method: "PATCH",
+        path: "/v2/teams/:teamId/clarity/hierarchy/process-links/:process_link_id"
+      }
+    ],
+    description: "Update a process-to-process link in the Clarity landscape."
+  },
+  {
+    name: "deleteClarityProcessLink",
+    scope: "v1+v2",
+    read_only: false,
+    commands: ["duvo clarity process-links delete"],
+    endpoints: [
+      {
+        method: "DELETE",
+        path: "/v2/teams/:teamId/clarity/hierarchy/process-links/:process_link_id"
+      }
+    ],
+    description: "Delete a process-to-process link from the Clarity landscape."
   }
 ];
 var CLARITY_TOOLS = [
@@ -17160,7 +17277,7 @@ function registerClarityTools(clarity) {
     console.log(renderTable(CLARITY_TOOL_COLUMNS, CLARITY_TOOLS));
     console.log("");
     console.log(
-      "Clarity tools include read-only GET calls and explicit write commands for generation, promotion, revert, assignment, postprocess, automation, artifact import, and invite links."
+      "Clarity tools include read-only GET calls and explicit write commands for generation, promotion, revert, assignment, postprocess, automation, artifact import, invite links, and process links."
     );
   });
 }
@@ -17303,8 +17420,8 @@ async function buildTeamContextCheck(config) {
   }
 }
 __name(buildTeamContextCheck, "buildTeamContextCheck");
-var listMyTeamsResponseSchema2 = z87.object({
-  teams: z87.array(z87.object({ id: z87.string() }))
+var listMyTeamsResponseSchema2 = z86.object({
+  teams: z86.array(z86.object({ id: z86.string() }))
 });
 async function buildClarityApiReachableCheck(command, config) {
   let teamId;
@@ -17922,19 +18039,19 @@ function buildGenerateTransformationProposalBody(options) {
 __name(buildGenerateTransformationProposalBody, "buildGenerateTransformationProposalBody");
 
 // src/commands/clarity/get-current-process.ts
-import { z as z88 } from "zod";
-var snapshotSchema = z88.object({
-  snapshot: z88.object({
-    id: z88.string(),
-    kind: z88.string(),
-    source_snapshot_id: z88.string().nullable(),
-    parent_id: z88.string().nullable(),
-    status: z88.string(),
-    creator_type: z88.string(),
-    user_id: z88.string().nullable(),
-    sandbox_id: z88.string().nullable(),
-    created_at: z88.string(),
-    updated_at: z88.string()
+import { z as z87 } from "zod";
+var snapshotSchema = z87.object({
+  snapshot: z87.object({
+    id: z87.string(),
+    kind: z87.string(),
+    source_snapshot_id: z87.string().nullable(),
+    parent_id: z87.string().nullable(),
+    status: z87.string(),
+    creator_type: z87.string(),
+    user_id: z87.string().nullable(),
+    sandbox_id: z87.string().nullable(),
+    created_at: z87.string(),
+    updated_at: z87.string()
   })
 });
 function registerClarityGetCurrentProcess(clarity) {
@@ -17978,19 +18095,19 @@ function registerClarityGetCurrentProcess(clarity) {
 __name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
 
 // src/commands/clarity/get-transformation-proposal.ts
-import { z as z89 } from "zod";
-var snapshotSchema2 = z89.object({
-  snapshot: z89.object({
-    id: z89.string(),
-    kind: z89.string(),
-    source_snapshot_id: z89.string().nullable(),
-    parent_id: z89.string().nullable(),
-    status: z89.string(),
-    creator_type: z89.string(),
-    user_id: z89.string().nullable(),
-    sandbox_id: z89.string().nullable(),
-    created_at: z89.string(),
-    updated_at: z89.string()
+import { z as z88 } from "zod";
+var snapshotSchema2 = z88.object({
+  snapshot: z88.object({
+    id: z88.string(),
+    kind: z88.string(),
+    source_snapshot_id: z88.string().nullable(),
+    parent_id: z88.string().nullable(),
+    status: z88.string(),
+    creator_type: z88.string(),
+    user_id: z88.string().nullable(),
+    sandbox_id: z88.string().nullable(),
+    created_at: z88.string(),
+    updated_at: z88.string()
   })
 });
 function registerClarityGetTransformationProposal(clarity) {
@@ -18187,39 +18304,267 @@ function registerClarityPostprocess(clarity) {
 }
 __name(registerClarityPostprocess, "registerClarityPostprocess");
 
-// src/commands/clarity/promote-current-process.ts
-import { z as z90 } from "zod";
-var snapshotSchema3 = z90.object({
-  snapshot: z90.object({
-    id: z90.string(),
-    status: z90.string(),
-    creator_type: z90.string(),
-    created_at: z90.string(),
-    updated_at: z90.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);
+// src/commands/clarity/process-links.ts
+import { z as z89 } from "zod";
+var MIN_LIMIT6 = 1;
+var MAX_LIMIT6 = 500;
+var DEFAULT_LIMIT6 = 100;
+var PROCESS_LINKS_RESOURCE_PATH = "/clarity/hierarchy/process-links";
+var processLinkTypeSchema = z89.enum([
+  "hands_off_to",
+  "shares_step_with",
+  "variant_of"
+]);
+var processLinkStateSchema = z89.enum(["suggested", "confirmed"]);
+var processLinkSchema = z89.object({
+  id: z89.string(),
+  source_node_id: z89.string(),
+  target_node_id: z89.string(),
+  type: processLinkTypeSchema,
+  state: processLinkStateSchema,
+  confidence: z89.number().nullable(),
+  created_at: z89.string(),
+  updated_at: z89.string()
+});
+var listProcessLinksResponseSchema = z89.object({
+  process_links: z89.array(processLinkSchema),
+  total: z89.number(),
+  limit: z89.number(),
+  offset: z89.number()
+});
+var processLinkMutationResponseSchema = z89.object({
+  process_link: processLinkSchema,
+  created: z89.boolean().optional()
+});
+var deleteProcessLinkResponseSchema = z89.object({
+  deleted: z89.boolean()
+});
+var PROCESS_LINK_COLUMNS = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell"), maxWidth: 36 },
+  {
+    header: "SOURCE",
+    cell: /* @__PURE__ */ __name((row) => row.source_node_id, "cell"),
+    maxWidth: 36
+  },
+  {
+    header: "TARGET",
+    cell: /* @__PURE__ */ __name((row) => row.target_node_id, "cell"),
+    maxWidth: 36
+  },
+  { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
+  { header: "STATE", cell: /* @__PURE__ */ __name((row) => row.state, "cell") },
+  {
+    header: "CONF",
+    cell: /* @__PURE__ */ __name((row) => row.confidence === null ? "-" : row.confidence.toFixed(2), "cell")
+  }
+];
+function registerClarityProcessLinks(clarity) {
+  const processLinks = clarity.command("process-links").description("Manage Clarity process links");
+  processLinks.command("list", { isDefault: true }).description("List process links in the current team").option("--node <node-id>", "only show links touching this process node").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of links to skip").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function listAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const path = await resolveProcessLinksPath(this, config);
+    const response = await listProcessLinks(config, path, options);
+    if (options.json) {
+      printJson(response);
+      return;
+    }
+    renderProcessLinks(response);
+  }, "listAction"));
+  processLinks.command("create").description("Create a process link").requiredOption("--source-node <node-id>", "source process node id").requiredOption("--target-node <node-id>", "target process node id").requiredOption(
+    "--type <type>",
+    "hands_off_to, shares_step_with, or variant_of"
+  ).option("--state <state>", "suggested or confirmed").option("--confidence <number>", "confidence score from 0 to 1").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function createAction(options) {
+    const config = await requireAuthenticatedConfig(this);
+    const path = await resolveProcessLinksPath(this, config);
+    const body = buildCreateBody(options);
     const raw = await httpRequest({
       method: "POST",
-      path: `/v2/clarity-v2/processes/${encodeURIComponent(processId)}/snapshots/current_process/${encodeURIComponent(snapshotId)}/promote`,
-      apiKey,
-      apiBaseUrl
+      path,
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl,
+      body
     });
+    const response = parseMutationResponse(raw);
     if (options.json) {
-      printJson(raw);
+      printJson(response);
       return;
     }
-    const parsed = snapshotSchema3.safeParse(raw);
-    if (!parsed.success) {
-      throw new CliError(
-        `Unexpected response from the API: ${parsed.error.message}`
-      );
+    const action = response.created === false ? "Found" : "Created";
+    console.log(`${action} process link: ${response.process_link.id}`);
+  }, "createAction"));
+  processLinks.command("update <link-id>").description("Update a process link").option("--source-node <node-id>", "replacement source process node id").option("--target-node <node-id>", "replacement target process node id").option("--type <type>", "hands_off_to, shares_step_with, or variant_of").option("--state <state>", "suggested or confirmed").option("--confidence <number>", "confidence score from 0 to 1").option("--clear-confidence", "clear the confidence score").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function updateAction(linkId, options) {
+    const config = await requireAuthenticatedConfig(this);
+    const path = await resolveProcessLinksPath(this, config);
+    const body = buildUpdateBody(options);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `${path}/${encodeURIComponent(linkId)}`,
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl,
+      body
+    });
+    const response = parseMutationResponse(raw);
+    if (options.json) {
+      printJson(response);
+      return;
     }
-    const { snapshot } = parsed.data;
-    console.log(
-      renderKeyValue([
+    console.log(`Updated process link: ${response.process_link.id}`);
+  }, "updateAction"));
+  processLinks.command("delete <link-id>").description("Delete a process link").option("--json", "output JSON").action(/* @__PURE__ */ __name(async function deleteAction(linkId, options) {
+    const config = await requireAuthenticatedConfig(this);
+    const path = await resolveProcessLinksPath(this, config);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `${path}/${encodeURIComponent(linkId)}`,
+      apiKey: config.apiKey,
+      apiBaseUrl: config.apiBaseUrl
+    });
+    const response = deleteProcessLinkResponseSchema.parse(raw);
+    if (options.json) {
+      printJson(response);
+      return;
+    }
+    console.log(`Deleted process link: ${linkId}`);
+  }, "deleteAction"));
+}
+__name(registerClarityProcessLinks, "registerClarityProcessLinks");
+async function listProcessLinks(config, path, options) {
+  const limit = parseLimit(options.limit, {
+    defaultValue: DEFAULT_LIMIT6,
+    min: MIN_LIMIT6,
+    max: MAX_LIMIT6
+  });
+  const offset = parseOffset(options.offset);
+  const searchParams = new URLSearchParams({
+    limit: String(limit),
+    offset: String(offset)
+  });
+  if (options.node) {
+    searchParams.set("node_id", options.node);
+  }
+  const raw = await httpRequest({
+    method: "GET",
+    path,
+    apiKey: config.apiKey,
+    apiBaseUrl: config.apiBaseUrl,
+    searchParams
+  });
+  return listProcessLinksResponseSchema.parse(raw);
+}
+__name(listProcessLinks, "listProcessLinks");
+async function resolveProcessLinksPath(command, config) {
+  const teamId = await resolveRequiredTeamId(config, {
+    override: getTeamFlag(command)
+  });
+  return buildTeamPath(teamId, PROCESS_LINKS_RESOURCE_PATH);
+}
+__name(resolveProcessLinksPath, "resolveProcessLinksPath");
+function buildCreateBody(options) {
+  return {
+    source_node_id: options.sourceNode,
+    target_node_id: options.targetNode,
+    type: parseProcessLinkType(options.type),
+    ...options.state !== void 0 ? { state: parseProcessLinkState(options.state) } : {},
+    ...options.confidence !== void 0 ? { confidence: parseConfidence(options.confidence) } : {}
+  };
+}
+__name(buildCreateBody, "buildCreateBody");
+function buildUpdateBody(options) {
+  if (options.confidence !== void 0 && options.clearConfidence) {
+    throw new CliError(
+      "Use either --confidence or --clear-confidence, not both."
+    );
+  }
+  const body = {
+    ...options.sourceNode !== void 0 ? { source_node_id: options.sourceNode } : {},
+    ...options.targetNode !== void 0 ? { target_node_id: options.targetNode } : {},
+    ...options.type !== void 0 ? { type: parseProcessLinkType(options.type) } : {},
+    ...options.state !== void 0 ? { state: parseProcessLinkState(options.state) } : {},
+    ...options.clearConfidence ? { confidence: null } : {},
+    ...options.confidence !== void 0 ? { confidence: parseConfidence(options.confidence) } : {}
+  };
+  if (Object.keys(body).length === 0) {
+    throw new CliError("Pass at least one field to update.");
+  }
+  return body;
+}
+__name(buildUpdateBody, "buildUpdateBody");
+function parseProcessLinkType(value) {
+  const parsed = processLinkTypeSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError(
+      "Link type must be one of: hands_off_to, shares_step_with, variant_of."
+    );
+  }
+  return parsed.data;
+}
+__name(parseProcessLinkType, "parseProcessLinkType");
+function parseProcessLinkState(value) {
+  const parsed = processLinkStateSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new CliError("Link state must be suggested or confirmed.");
+  }
+  return parsed.data;
+}
+__name(parseProcessLinkState, "parseProcessLinkState");
+function parseConfidence(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+    throw new CliError("Confidence must be a number from 0 to 1.");
+  }
+  return parsed;
+}
+__name(parseConfidence, "parseConfidence");
+function parseMutationResponse(raw) {
+  return processLinkMutationResponseSchema.parse(raw);
+}
+__name(parseMutationResponse, "parseMutationResponse");
+function renderProcessLinks(response) {
+  if (response.process_links.length === 0) {
+    console.log("No process links found.");
+    return;
+  }
+  console.log(renderTable(PROCESS_LINK_COLUMNS, response.process_links));
+  console.log("");
+  console.log(
+    `Showing ${response.process_links.length} of ${response.total} \xB7 offset ${response.offset}`
+  );
+}
+__name(renderProcessLinks, "renderProcessLinks");
+
+// src/commands/clarity/promote-current-process.ts
+import { z as z90 } from "zod";
+var snapshotSchema3 = z90.object({
+  snapshot: z90.object({
+    id: z90.string(),
+    status: z90.string(),
+    creator_type: z90.string(),
+    created_at: z90.string(),
+    updated_at: z90.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)}/snapshots/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 },
@@ -18316,9 +18661,14 @@ __name(registerClarityRevertTransformationProposal, "registerClarityRevertTransf
 // src/commands/clarity/save-snapshot.ts
 import { readFile as readFile6 } from "node:fs/promises";
 import { z as z92 } from "zod";
-var stepsFileSchema = z92.union([
+var snapshotFileSchema = z92.union([
   saveClarityProcessSnapshotBodySchema.shape.steps,
-  z92.object({ steps: saveClarityProcessSnapshotBodySchema.shape.steps })
+  saveClarityProcessSnapshotBodySchema.pick({
+    steps: true,
+    summary: true,
+    swot: true,
+    projectedImpact: true
+  })
 ]);
 function registerClaritySaveCurrentProcess(clarity) {
   clarity.command("save-current-process <process-id>").description("Save edited current-process steps as the live snapshot").requiredOption(
@@ -18326,15 +18676,16 @@ function registerClaritySaveCurrentProcess(clarity) {
     "current-process snapshot the edits are based on"
   ).requiredOption(
     "--steps-file <path>",
-    "JSON file containing an array of edited steps or an object with a steps array"
+    "JSON file containing an array of edited steps or an object with steps and narrative roots"
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const snapshotFile = await readSnapshotFile(options.stepsFile);
     await saveSnapshot({
       command: this,
       processId,
       kind: "current_process",
       body: {
         baselineSnapshotId: options.baselineSnapshotId,
-        steps: await readStepsFile(options.stepsFile)
+        ...snapshotFile
       },
       json: options.json === true
     });
@@ -18349,11 +18700,12 @@ function registerClaritySaveTransformationProposal(clarity) {
     "transformation-proposal snapshot the edits are based on"
   ).requiredOption(
     "--steps-file <path>",
-    "JSON file containing an array of edited steps or an object with a steps array"
+    "JSON file containing an array of edited steps or an object with steps and narrative roots"
   ).option(
     "--current-process-id <id>",
     "current-process snapshot anchor expected by the edited proposal"
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const snapshotFile = await readSnapshotFile(options.stepsFile);
     await saveSnapshot({
       command: this,
       processId,
@@ -18361,7 +18713,7 @@ function registerClaritySaveTransformationProposal(clarity) {
       body: {
         baselineSnapshotId: options.baselineSnapshotId,
         clarityCurrentProcessId: options.currentProcessId,
-        steps: await readStepsFile(options.stepsFile)
+        ...snapshotFile
       },
       json: options.json === true
     });
@@ -18404,7 +18756,7 @@ async function saveSnapshot(args) {
   );
 }
 __name(saveSnapshot, "saveSnapshot");
-async function readStepsFile(path) {
+async function readSnapshotFile(path) {
   let raw;
   try {
     raw = await readFile6(path, "utf8");
@@ -18419,15 +18771,15 @@ async function readStepsFile(path) {
     const message = error instanceof Error ? error.message : String(error);
     throw new CliError(`Invalid JSON in "${path}": ${message}`);
   }
-  const parsed = stepsFileSchema.safeParse(json);
+  const parsed = snapshotFileSchema.safeParse(json);
   if (!parsed.success) {
     throw new CliError(
-      `Invalid steps file "${path}": expected a step array or an object with a steps array. ${parsed.error.message}`
+      `Invalid steps file "${path}": expected a step array or an object with a steps array and optional narrative roots. ${parsed.error.message}`
     );
   }
-  return Array.isArray(parsed.data) ? parsed.data : parsed.data.steps;
+  return Array.isArray(parsed.data) ? { steps: parsed.data } : parsed.data;
 }
-__name(readStepsFile, "readStepsFile");
+__name(readSnapshotFile, "readSnapshotFile");
 
 // src/commands/clarity/stop-current-process.ts
 function registerClarityStopCurrentProcess(clarity) {
@@ -18468,9 +18820,9 @@ function registerClarityStopTransformationProposal(clarity) {
 __name(registerClarityStopTransformationProposal, "registerClarityStopTransformationProposal");
 
 // src/commands/clarity/index.ts
-var DEFAULT_LIMIT6 = 50;
-var MIN_LIMIT6 = 1;
-var MAX_LIMIT6 = 100;
+var DEFAULT_LIMIT7 = 50;
+var MIN_LIMIT7 = 1;
+var MAX_LIMIT7 = 100;
 var CLARITY_V2_REQUIRED_MESSAGE = "This command requires Clarity v2. Use `duvo clarity overview <process-id>` to read legacy v1 context.";
 function registerClarity(program) {
   const clarity = program.command("clarity").description("Manage and read Clarity processes in the Duvo public API");
@@ -18509,6 +18861,7 @@ function registerClarity(program) {
   registerClarityRevertTransformationProposal(clarity);
   registerClarityAssignExtraCaptureRequest(clarity);
   registerClarityPostprocess(clarity);
+  registerClarityProcessLinks(clarity);
   registerClarityBuildAutomation(clarity);
   registerClarityStopCurrentProcess(clarity);
   registerClarityStopTransformationProposal(clarity);
@@ -18517,7 +18870,7 @@ function registerClarity(program) {
 }
 __name(registerClarity, "registerClarity");
 function registerList(clarity) {
-  clarity.command("list", { isDefault: true }).description("List Clarity processes for the current team").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of processes to skip").option("--search <query>", "case-insensitive search across process names").option("--status <status>", "filter by lifecycle status").option(
+  clarity.command("list", { isDefault: true }).description("List Clarity processes for the current team").option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of processes to skip").option("--search <query>", "case-insensitive search across process names").option("--status <status>", "filter by lifecycle status").option(
     "--process-version <1|2>",
     "filter by Clarity process schema version"
   ).option("--json", "output JSON").option("--csv", "output CSV").action(/* @__PURE__ */ __name(async function listAction(options) {
@@ -18527,7 +18880,7 @@ function registerList(clarity) {
 }
 __name(registerList, "registerList");
 function registerSearch(clarity) {
-  clarity.command("search <query>").description("Search Clarity processes by name").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of processes to skip").option("--status <status>", "filter by lifecycle status").option(
+  clarity.command("search <query>").description("Search Clarity processes by name").option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of processes to skip").option("--status <status>", "filter by lifecycle status").option(
     "--process-version <1|2>",
     "filter by Clarity process schema version"
   ).option("--json", "output JSON").option("--csv", "output CSV").action(/* @__PURE__ */ __name(async function searchAction(query, options) {
@@ -18872,9 +19225,9 @@ function registerExport(clarity) {
 __name(registerExport, "registerExport");
 async function loadProcessList(command, options) {
   const limit = parseLimit(options.limit, {
-    defaultValue: DEFAULT_LIMIT6,
-    min: MIN_LIMIT6,
-    max: MAX_LIMIT6
+    defaultValue: DEFAULT_LIMIT7,
+    min: MIN_LIMIT7,
+    max: MAX_LIMIT7
   });
   const offset = parseOffset(options.offset);
   const version2 = parseProcessVersion(options.processVersion);
@@ -21833,8 +22186,255 @@ function registerProfiles(program) {
 }
 __name(registerProfiles, "registerProfiles");
 
-// src/commands/queue-labels/index.ts
+// src/commands/pulse/create.ts
+function registerPulseCreate(pulse) {
+  pulse.command("create").description(
+    "Create a Pulse dashboard from a prompt (e.g. 'open cases by queue this week'). Generation runs asynchronously \u2014 poll `duvo pulse get <id>` until status is completed."
+  ).requiredOption(
+    "--message <text>",
+    "what you want the dashboard to show (max 10000 chars)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
+    const message = options.message?.trim();
+    if (!message) {
+      throw new CliError("--message is required.");
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: "/v1/artifacts",
+      apiKey,
+      apiBaseUrl,
+      body: { message }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = createArtifactResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { artifact_id: artifactId } = parsed.data;
+    console.log(green("Pulse dashboard created. The agent is building it\u2026"));
+    console.log();
+    console.log(renderKeyValue([{ label: "ID", value: artifactId }]));
+    console.log();
+    console.log(`Track progress with: duvo pulse get ${artifactId}`);
+  }, "createAction"));
+}
+__name(registerPulseCreate, "registerPulseCreate");
+
+// src/commands/pulse/delete.ts
+function registerPulseDelete(pulse) {
+  pulse.command("delete <id>").description("Delete a Pulse dashboard (creator only)").option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    await confirmDestructive({
+      message: `Delete Pulse dashboard "${pulseId}"?`,
+      skip: options.yes ?? false
+    });
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v1/artifacts/${encodeURIComponent(pulseId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = deleteArtifactResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green(`Pulse dashboard "${pulseId}" deleted.`));
+  }, "deleteAction"));
+}
+__name(registerPulseDelete, "registerPulseDelete");
+
+// src/commands/pulse/get.ts
+function registerPulseGet(pulse) {
+  pulse.command("get <id>").description("Get a Pulse dashboard's metadata and generation status").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/artifacts/${encodeURIComponent(pulseId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactDetailResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { artifact: dashboard } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: dashboard.id },
+        { label: "Title", value: dashboard.title ?? "" },
+        { label: "Status", value: dashboard.status },
+        {
+          label: "Rendered",
+          value: dashboard.html_code_present ? "yes" : "no"
+        },
+        { label: "Created", value: dashboard.created_at },
+        { label: "Updated", value: dashboard.updated_at }
+      ])
+    );
+    if (dashboard.html_code_present) {
+      console.log();
+      console.log(
+        `Read the rendered HTML with: duvo pulse html ${dashboard.id}`
+      );
+    }
+  }, "getAction"));
+}
+__name(registerPulseGet, "registerPulseGet");
+
+// src/commands/pulse/html.ts
+function registerPulseHtml(pulse) {
+  pulse.command("html <id>").description(
+    "Print a Pulse dashboard's rendered HTML document to stdout (pipe to a file or browser)"
+  ).action(/* @__PURE__ */ __name(async function htmlAction(id) {
+    const pulseId = trimRequired(id, "<id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/artifacts/${encodeURIComponent(pulseId)}/render`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (typeof raw !== "string") {
+      throw new CliError(
+        "Unexpected response from the API: expected an HTML document."
+      );
+    }
+    console.log(raw);
+  }, "htmlAction"));
+}
+__name(registerPulseHtml, "registerPulseHtml");
+
+// src/commands/pulse/list.ts
+var DEFAULT_LIMIT8 = 20;
+var MIN_LIMIT8 = 1;
+var MAX_LIMIT8 = 100;
 var TABLE_COLUMNS27 = [
+  { 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") },
+  { header: "UPDATED", cell: /* @__PURE__ */ __name((row) => row.updated_at, "cell") }
+];
+function registerPulseList(pulse) {
+  pulse.command("list", { isDefault: true }).description("List your Pulse dashboards").option(
+    "--shared",
+    "list dashboards shared with you (created by teammates) instead of your own"
+  ).option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of dashboards to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT8,
+      min: MIN_LIMIT8,
+      max: MAX_LIMIT8
+    });
+    const offset = parseOffset(options.offset);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("scope", options.shared ? "shared" : "created");
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await httpRequest({
+      method: "GET",
+      path: "/v1/artifacts",
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = artifactListResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (response.artifacts.length === 0) {
+      console.log("No Pulse dashboards found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS27, response.artifacts));
+    console.log(
+      `Showing ${response.artifacts.length} of ${response.total} \xB7 offset ${response.offset}`
+    );
+  }, "listAction"));
+}
+__name(registerPulseList, "registerPulseList");
+
+// src/commands/pulse/send-message.ts
+function registerPulseSendMessage(pulse) {
+  pulse.command("send-message <id>").description(
+    "Send an instruction to iterate on a dashboard (e.g. 'make it a bar chart'). Only the creator can iterate; the agent regenerates asynchronously."
+  ).requiredOption("--message <text>", "the instruction (max 10000 chars)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function sendMessageAction(id, options) {
+    const pulseId = trimRequired(id, "<id>");
+    const message = options.message?.trim();
+    if (!message) {
+      throw new CliError("--message is required.");
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/artifacts/${encodeURIComponent(pulseId)}/messages`,
+      apiKey,
+      apiBaseUrl,
+      body: { message }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = sendArtifactMessageResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(
+      green("Instruction sent. The agent is updating the dashboard\u2026")
+    );
+    console.log();
+    console.log(`Track progress with: duvo pulse get ${pulseId}`);
+  }, "sendMessageAction"));
+}
+__name(registerPulseSendMessage, "registerPulseSendMessage");
+
+// src/commands/pulse/index.ts
+function registerPulse(program) {
+  const pulse = program.command("pulse").description("Manage Duvo Pulse dashboards in the public API");
+  registerPulseList(pulse);
+  registerPulseCreate(pulse);
+  registerPulseGet(pulse);
+  registerPulseHtml(pulse);
+  registerPulseSendMessage(pulse);
+  registerPulseDelete(pulse);
+}
+__name(registerPulse, "registerPulse");
+
+// src/commands/queue-labels/index.ts
+var TABLE_COLUMNS28 = [
   { 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") },
@@ -21888,7 +22488,7 @@ function registerList3(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS27, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS28, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
@@ -22639,10 +23239,10 @@ function registerQueuesLinkAgent(queues) {
 __name(registerQueuesLinkAgent, "registerQueuesLinkAgent");
 
 // src/commands/queues/list.ts
-var DEFAULT_LIMIT7 = 20;
-var MIN_LIMIT7 = 1;
-var MAX_LIMIT7 = 100;
-var TABLE_COLUMNS28 = [
+var DEFAULT_LIMIT9 = 20;
+var MIN_LIMIT9 = 1;
+var MAX_LIMIT9 = 100;
+var TABLE_COLUMNS29 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -22653,11 +23253,11 @@ var TABLE_COLUMNS28 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerQueuesList(queues) {
-  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+  queues.command("list", { isDefault: true }).description("List queues for your team").option("--limit <n>", `page size (${MIN_LIMIT9}-${MAX_LIMIT9})`).option("--offset <n>", "number of queues to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT7,
-      min: MIN_LIMIT7,
-      max: MAX_LIMIT7
+      defaultValue: DEFAULT_LIMIT9,
+      min: MIN_LIMIT9,
+      max: MAX_LIMIT9
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -22690,7 +23290,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, response.queues));
+    console.log(renderTable(TABLE_COLUMNS29, 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}`;
@@ -22948,7 +23548,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS29 = [
+var TABLE_COLUMNS30 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -22984,7 +23584,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No browser logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, rows));
+    console.log(renderTable(TABLE_COLUMNS30, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -23057,7 +23657,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS30 = [
+var TABLE_COLUMNS31 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -23095,7 +23695,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS30, rows));
+    console.log(renderTable(TABLE_COLUMNS31, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -23340,13 +23940,13 @@ function registerRunsGet(runs) {
 __name(registerRunsGet, "registerRunsGet");
 
 // src/commands/runs/list.ts
-var DEFAULT_LIMIT8 = 20;
-var MIN_LIMIT8 = 1;
-var MAX_LIMIT8 = 100;
+var DEFAULT_LIMIT10 = 20;
+var MIN_LIMIT10 = 1;
+var MAX_LIMIT10 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS31 = [
+var TABLE_COLUMNS32 = [
   { 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") },
@@ -23370,7 +23970,7 @@ function isHasIssuesValue(value) {
 }
 __name(isHasIssuesValue, "isHasIssuesValue");
 function registerRunsList(runs) {
-  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT8}-${MAX_LIMIT8})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
+  runs.command("list").description("List agent runs for your team").option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of runs to skip").option("--sort-order <order>", `sort direction (${SORT_ORDERS2.join("|")})`).option(
     "--status <status>",
     "filter by status (e.g. running, completed, failed, waiting, interrupted, stopped, needs_attention)"
   ).option("--agent <id>", "filter by agent ID").option("--user <id>", "filter by user ID").option("--case-queue <id>", "filter by queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
@@ -23378,9 +23978,9 @@ function registerRunsList(runs) {
     `show only runs with (or without) issues (${HAS_ISSUES_VALUES.join("|")})`
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT8,
-      min: MIN_LIMIT8,
-      max: MAX_LIMIT8
+      defaultValue: DEFAULT_LIMIT10,
+      min: MIN_LIMIT10,
+      max: MAX_LIMIT10
     });
     const offset = parseOffset(options.offset);
     if (options.sortOrder !== void 0 && !isSortOrder(options.sortOrder)) {
@@ -23447,7 +24047,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS31, response.data));
+    console.log(renderTable(TABLE_COLUMNS32, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -23553,11 +24153,11 @@ function getContent(msg) {
 __name(getContent, "getContent");
 
 // src/commands/runs/messages.ts
-var DEFAULT_LIMIT9 = 20;
-var MIN_LIMIT9 = 1;
-var MAX_LIMIT9 = 50;
+var DEFAULT_LIMIT11 = 20;
+var MIN_LIMIT11 = 1;
+var MAX_LIMIT11 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS32 = [
+var TABLE_COLUMNS33 = [
   { 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") },
@@ -23582,7 +24182,7 @@ function previewCell(row) {
 }
 __name(previewCell, "previewCell");
 function registerRunsMessages(runs) {
-  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT9}-${MAX_LIMIT9})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
+  runs.command("messages <id>").description("List messages for an agent run").option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of messages to skip").option("--follow", "poll for new messages until the job completes").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     if (options.follow) {
@@ -23593,9 +24193,9 @@ function registerRunsMessages(runs) {
       return;
     }
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT9,
-      min: MIN_LIMIT9,
-      max: MAX_LIMIT9
+      defaultValue: DEFAULT_LIMIT11,
+      min: MIN_LIMIT11,
+      max: MAX_LIMIT11
     });
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
@@ -23622,7 +24222,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS32, response.messages));
+    console.log(renderTable(TABLE_COLUMNS33, 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);
@@ -23948,7 +24548,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS33 = [
+var TABLE_COLUMNS34 = [
   { 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") },
@@ -23986,7 +24586,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS33, files));
+    console.log(renderTable(TABLE_COLUMNS34, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -24331,7 +24931,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS34 = [
+var TABLE_COLUMNS35 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -24375,7 +24975,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS34, rows));
+    console.log(renderTable(TABLE_COLUMNS35, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -24486,7 +25086,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS35 = [
+var TABLE_COLUMNS36 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -24514,7 +25114,7 @@ function registerSkillsAssignments(skills) {
       console.log("No agents use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS35, assignments));
+    console.log(renderTable(TABLE_COLUMNS36, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -24796,7 +25396,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS36 = [
+var TABLE_COLUMNS37 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -24835,7 +25435,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS36, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS37, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -25213,12 +25813,12 @@ function registerSuggestionsConsume(suggestions) {
 __name(registerSuggestionsConsume, "registerSuggestionsConsume");
 
 // src/commands/suggestions/list.ts
-var DEFAULT_LIMIT10 = 100;
-var MIN_LIMIT10 = 1;
-var MAX_LIMIT10 = 250;
+var DEFAULT_LIMIT12 = 100;
+var MIN_LIMIT12 = 1;
+var MAX_LIMIT12 = 250;
 var STATUS_FILTERS = ["pending", "history"];
 var TITLE_PREVIEW_WIDTH2 = 50;
-var TABLE_COLUMNS37 = [
+var TABLE_COLUMNS38 = [
   { 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") },
@@ -25239,11 +25839,11 @@ function registerSuggestionsList(suggestions) {
   ).option(
     "--status <filter>",
     `which inbox to show (${STATUS_FILTERS.join("|")}, default: pending)`
-  ).option("--limit <n>", `page size (${MIN_LIMIT10}-${MAX_LIMIT10})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT12}-${MAX_LIMIT12})`).option("--offset <n>", "number of suggestions to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT10,
-      min: MIN_LIMIT10,
-      max: MAX_LIMIT10
+      defaultValue: DEFAULT_LIMIT12,
+      min: MIN_LIMIT12,
+      max: MAX_LIMIT12
     });
     const offset = parseOffset(options.offset);
     if (options.status !== void 0 && !isStatusFilter(options.status)) {
@@ -25281,7 +25881,7 @@ function registerSuggestionsList(suggestions) {
       console.log(`Pending total: ${pendingCount}`);
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS37, data));
+    console.log(renderTable(TABLE_COLUMNS38, data));
     console.log(
       `Showing ${data.length} \xB7 offset ${offset} \xB7 pending total ${pendingCount}`
     );
@@ -25405,10 +26005,10 @@ function registerTeamGet(team) {
 __name(registerTeamGet, "registerTeamGet");
 
 // src/commands/team/members.ts
-var DEFAULT_LIMIT11 = 50;
-var MIN_LIMIT11 = 1;
-var MAX_LIMIT11 = 100;
-var TABLE_COLUMNS38 = [
+var DEFAULT_LIMIT13 = 50;
+var MIN_LIMIT13 = 1;
+var MAX_LIMIT13 = 100;
+var TABLE_COLUMNS39 = [
   { 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") },
@@ -25422,11 +26022,11 @@ function registerTeamMembers(team) {
   team.command("members").description("List members of a team").option(
     "--team <id>",
     "team ID (defaults to the team scoped to your credentials)"
-  ).option("--limit <n>", `page size (${MIN_LIMIT11}-${MAX_LIMIT11})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
+  ).option("--limit <n>", `page size (${MIN_LIMIT13}-${MAX_LIMIT13})`).option("--offset <n>", "number of members to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function membersAction(options) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT11,
-      min: MIN_LIMIT11,
-      max: MAX_LIMIT11
+      defaultValue: DEFAULT_LIMIT13,
+      min: MIN_LIMIT13,
+      max: MAX_LIMIT13
     });
     const offset = parseOffset(options.offset);
     const config = await requireAuthenticatedConfig(this);
@@ -25459,7 +26059,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS38, response.members));
+    console.log(renderTable(TABLE_COLUMNS39, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -25657,7 +26257,7 @@ __name(resolveActiveTeamId, "resolveActiveTeamId");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "1.7.1";
+    return "1.8.0";
   }
   const packageJsonPath = join3(
     dirname3(fileURLToPath2(import.meta.url)),
@@ -25717,6 +26317,7 @@ function createProgram() {
   registerRevisionSecrets(program);
   registerRevisionLogins(program);
   registerClarity(program);
+  registerPulse(program);
   return program;
 }
 __name(createProgram, "createProgram");
@@ -25740,7 +26341,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "1.7.1" };
+    return { name: "@duvoai/cli", version: "1.8.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");