@duvoai/cli 0.6.0 → 0.7.0

package/dist/bin/duvo.js

@@ -3341,6 +3341,9 @@ var clarityCurrentProcessSnapshotApiSchema = z16.object({
 });
 var clarityTransformationProposalSnapshotApiSchema = z16.object({
   id: z16.guid().describe("Proposal id"),
+  clarity_current_process_id: z16.guid().describe(
+    "The current-process snapshot this proposal was generated against. Use it to detect proposal/current-version anchor mismatches."
+  ),
   parent_transformation_proposal_id: z16.guid().nullable().describe("Parent transformation-proposal snapshot this draft forked from"),
   data: postprocessClarityTransformationProposalDataSchema.describe(
     "Opaque BPMN payload for the proposed transformed process. Field names inside `data` are camelCase by design."
@@ -4788,7 +4791,7 @@ var FREQUENCIES_REQUIRING_TIME = [
   "weekly",
   "monthly"
 ];
-var scheduleUpsertRequestSchema = z30.object({
+var scheduleUpsertObjectSchema = z30.object({
   agent_id: z30.string(),
   enabled: z30.boolean(),
   frequency: scheduleFrequencySchema,
@@ -4798,7 +4801,8 @@ var scheduleUpsertRequestSchema = z30.object({
   day_of_month: z30.int().min(1).max(31).nullable().optional(),
   cron: z30.string().nullable().optional(),
   recurring: z30.boolean().nullable().optional()
-}).superRefine((data, ctx) => {
+});
+function refineScheduleFields(data, ctx) {
   if (!data.enabled) {
     return;
   }
@@ -4832,7 +4836,11 @@ var scheduleUpsertRequestSchema = z30.object({
       path: ["time"]
     });
   }
-});
+}
+__name(refineScheduleFields, "refineScheduleFields");
+__name2(refineScheduleFields, "refineScheduleFields");
+var scheduleUpsertRequestSchema = scheduleUpsertObjectSchema.superRefine(refineScheduleFields);
+var scheduleCreateRequestSchema = scheduleUpsertObjectSchema.omit({ agent_id: true }).superRefine(refineScheduleFields);
 var buildApiSchema = z30.strictObject({
   id: z30.guid(),
   copilot_id: z30.guid(),
@@ -5589,7 +5597,19 @@ var queueAgentConsumerSchema = z41.object({
   agent_name: z41.string(),
   case_trigger_enabled: z41.boolean(),
   is_handover_target: z41.boolean(),
-  problems: z41.array(caseQueueAgentProblemSchema)
+  problems: z41.array(caseQueueAgentProblemSchema),
+  /**
+   * Max concurrent Jobs this consumer's enabled trigger allows, after the
+   * platform cap is applied. Populated only by the single-queue agents
+   * endpoint; omitted when the consumer has no enabled trigger.
+   */
+  concurrency_limit: z41.int().nonnegative().optional(),
+  /**
+   * True when this consumer's active Jobs have reached `concurrency_limit`, so
+   * the dispatcher pauses and new cases stay pending until a Job finishes.
+   * Populated only by the single-queue agents endpoint.
+   */
+  at_concurrency_limit: z41.boolean().optional()
 });
 var queueAgentsResponseSchema = z41.object({
   queue_name: z41.string(),
@@ -6265,7 +6285,8 @@ var INTEGRATION_SLUGS = [
   "github",
   "linear-native",
   "notion-native",
-  "granola"
+  "granola",
+  "bamboohr"
 ];
 var IntegrationSlugSchema = z48.enum(INTEGRATION_SLUGS);
 function isIntegrationSlug(value) {
@@ -9975,8 +9996,185 @@ var publicScheduleSchema = z65.object({
 var listSchedulesResponseSchema = z65.object({
   schedules: z65.array(publicScheduleSchema)
 });
+var deleteScheduleResponseSchema = z65.object({
+  success: z65.literal(true)
+});
+
+// src/commands/agents/schedules/render-schedule.ts
+function renderScheduleDetails(schedule) {
+  return renderKeyValue([
+    { label: "ID", value: schedule.id },
+    { label: "Agent", value: schedule.agent_id },
+    { label: "Build", value: schedule.build_id },
+    { label: "Enabled", value: schedule.enabled ? "yes" : "no" },
+    { label: "Frequency", value: schedule.frequency },
+    { label: "Time", value: schedule.time ?? "\u2014" },
+    { label: "Timezone", value: schedule.timezone },
+    { label: "Day", value: schedule.day ?? "\u2014" },
+    {
+      label: "Day of month",
+      value: schedule.day_of_month === null || schedule.day_of_month === void 0 ? "\u2014" : String(schedule.day_of_month)
+    },
+    { label: "Cron", value: schedule.cron ?? "\u2014" },
+    {
+      label: "Recurring",
+      value: schedule.recurring === false ? "no" : "yes"
+    },
+    { label: "Created", value: schedule.created_at },
+    { label: "Updated", value: schedule.updated_at }
+  ]);
+}
+__name(renderScheduleDetails, "renderScheduleDetails");
+
+// src/commands/agents/schedules/schedule-fields.ts
+var FREQUENCY_HINT = scheduleFrequencySchema.options.join(", ");
+var DAY_HINT = scheduleDaySchema.options.join(", ");
+var TIME_PATTERN = /^([01]?\d|2[0-3]):[0-5]\d$/;
+var INTEGER_PATTERN = /^\d+$/;
+var MIN_DAY_OF_MONTH = 1;
+var MAX_DAY_OF_MONTH = 31;
+function parseFrequency(raw) {
+  const result = scheduleFrequencySchema.safeParse(raw.trim());
+  if (!result.success) {
+    throw new CliError(`--frequency must be one of: ${FREQUENCY_HINT}`);
+  }
+  return result.data;
+}
+__name(parseFrequency, "parseFrequency");
+function parseDay(raw) {
+  const result = scheduleDaySchema.safeParse(raw.trim().toLowerCase());
+  if (!result.success) {
+    throw new CliError(`--day must be one of: ${DAY_HINT}`);
+  }
+  return result.data;
+}
+__name(parseDay, "parseDay");
+function parseTime(raw) {
+  const trimmed = raw.trim();
+  if (!TIME_PATTERN.test(trimmed)) {
+    throw new CliError("--time must be in HH:MM 24-hour format (e.g. 09:30)");
+  }
+  return trimmed;
+}
+__name(parseTime, "parseTime");
+function parseDayOfMonth(raw) {
+  const trimmed = raw.trim();
+  const value = Number(trimmed);
+  if (!INTEGER_PATTERN.test(trimmed) || value < MIN_DAY_OF_MONTH || value > MAX_DAY_OF_MONTH) {
+    throw new CliError(
+      `--day-of-month must be an integer between ${MIN_DAY_OF_MONTH} and ${MAX_DAY_OF_MONTH}`
+    );
+  }
+  return value;
+}
+__name(parseDayOfMonth, "parseDayOfMonth");
+
+// src/commands/agents/schedules/create.ts
+function registerAgentsSchedulesCreate(schedules) {
+  schedules.command("create <agent-id>").description(
+    "Create a schedule for an agent. The schedule fires against the agent's live build."
+  ).requiredOption(
+    "--frequency <frequency>",
+    `how often the schedule fires (one of: ${FREQUENCY_HINT})`
+  ).requiredOption(
+    "--timezone <tz>",
+    "IANA timezone the schedule runs in (e.g. America/New_York)"
+  ).option(
+    "--time <HH:MM>",
+    "time of day, 24-hour (required for daily, workday, weekly, monthly)"
+  ).option(
+    "--day <day>",
+    `day of week for weekly schedules (one of: ${DAY_HINT})`
+  ).option("--day-of-month <n>", "day of month (1-31) for monthly schedules").option("--cron <expr>", "cron expression (required for custom schedules)").option(
+    "--disabled",
+    "create the schedule disabled (default: enabled and running)"
+  ).option(
+    "--no-recurring",
+    "retire the schedule after its first run (default: recurring)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(agentId, options) {
+    const trimmedAgentId = trimRequired(agentId, "<agent-id>");
+    const body = {
+      enabled: options.disabled !== true,
+      frequency: parseFrequency(options.frequency),
+      timezone: trimRequired(options.timezone, "--timezone"),
+      recurring: options.recurring !== false
+    };
+    if (options.time !== void 0) {
+      body.time = parseTime(options.time);
+    }
+    if (options.day !== void 0) {
+      body.day = parseDay(options.day);
+    }
+    if (options.dayOfMonth !== void 0) {
+      body.day_of_month = parseDayOfMonth(options.dayOfMonth);
+    }
+    if (options.cron !== void 0) {
+      body.cron = trimRequired(options.cron, "--cron");
+    }
+    const validation = scheduleCreateRequestSchema.safeParse(body);
+    if (!validation.success) {
+      throw new CliError(
+        validation.error.issues[0]?.message ?? "Invalid schedule"
+      );
+    }
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/agents/${encodeURIComponent(trimmedAgentId)}/schedules`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = publicScheduleSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Schedule created!"));
+    console.log(renderScheduleDetails(parsed.data));
+  }, "createAction"));
+}
+__name(registerAgentsSchedulesCreate, "registerAgentsSchedulesCreate");
+
+// src/commands/agents/schedules/delete.ts
+function registerAgentsSchedulesDelete(schedules) {
+  schedules.command("delete <agent-id> <schedule-id>").description("Delete a schedule").option("-y, --yes", "skip the confirmation prompt").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function deleteAction(agentId, scheduleId, options) {
+    const trimmedAgentId = trimRequired(agentId, "<agent-id>");
+    const trimmedScheduleId = trimRequired(scheduleId, "<schedule-id>");
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    await confirmDestructive({
+      message: `Delete schedule "${trimmedScheduleId}"?`,
+      skip: options.yes === true
+    });
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v1/agents/${encodeURIComponent(trimmedAgentId)}/schedules/${encodeURIComponent(
+        trimmedScheduleId
+      )}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = deleteScheduleResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Schedule deleted!"));
+  }, "deleteAction"));
+}
+__name(registerAgentsSchedulesDelete, "registerAgentsSchedulesDelete");
 
-// src/commands/agents/schedules.ts
+// src/commands/agents/schedules/list.ts
 var TASK_PREVIEW_WIDTH = 40;
 var TABLE_COLUMNS5 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
@@ -10010,12 +10208,15 @@ function whenCell(row) {
   return row.time ?? "";
 }
 __name(whenCell, "whenCell");
-function registerAgentsSchedules(agents) {
-  agents.command("schedules <agent-id>").description("List schedules you own for an agent").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function schedulesAction(agentId, options) {
+function registerAgentsSchedulesList(schedules) {
+  schedules.command("list <agent-id>", { isDefault: true }).description(
+    "List schedules you own for an agent (use to find the schedule ID for update / delete)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(agentId, options) {
+    const id = trimRequired(agentId, "<agent-id>");
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "GET",
-      path: `/v1/agents/${encodeURIComponent(agentId)}/schedules`,
+      path: `/v1/agents/${encodeURIComponent(id)}/schedules`,
       apiKey,
       apiBaseUrl
     });
@@ -10029,14 +10230,127 @@ function registerAgentsSchedules(agents) {
         `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    const { schedules } = parsed.data;
-    if (schedules.length === 0) {
+    const { schedules: rows } = parsed.data;
+    if (rows.length === 0) {
       console.log("No schedules found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS5, schedules));
-    console.log(`Showing ${schedules.length}`);
-  }, "schedulesAction"));
+    console.log(renderTable(TABLE_COLUMNS5, rows));
+    console.log(`Showing ${rows.length}`);
+  }, "listAction"));
+}
+__name(registerAgentsSchedulesList, "registerAgentsSchedulesList");
+
+// src/commands/agents/schedules/update.ts
+function buildBody3(options) {
+  const body = {};
+  if (options.enable === true && options.disable === true) {
+    throw new CliError("Pass either --enable or --disable, not both.");
+  }
+  if (options.enable === true) {
+    body.enabled = true;
+  } else if (options.disable === true) {
+    body.enabled = false;
+  }
+  if (options.recurring === true && options.oneShot === true) {
+    throw new CliError("Pass either --recurring or --one-shot, not both.");
+  }
+  if (options.recurring === true) {
+    body.recurring = true;
+  } else if (options.oneShot === true) {
+    body.recurring = false;
+  }
+  if (options.frequency !== void 0) {
+    body.frequency = parseFrequency(options.frequency);
+  }
+  if (options.timezone !== void 0) {
+    body.timezone = trimRequired(options.timezone, "--timezone");
+  }
+  if (options.time !== void 0 && options.clearTime === true) {
+    throw new CliError("Pass either --time or --clear-time, not both.");
+  }
+  if (options.time !== void 0) {
+    body.time = parseTime(options.time);
+  } else if (options.clearTime === true) {
+    body.time = null;
+  }
+  if (options.day !== void 0 && options.clearDay === true) {
+    throw new CliError("Pass either --day or --clear-day, not both.");
+  }
+  if (options.day !== void 0) {
+    body.day = parseDay(options.day);
+  } else if (options.clearDay === true) {
+    body.day = null;
+  }
+  if (options.dayOfMonth !== void 0 && options.clearDayOfMonth === true) {
+    throw new CliError(
+      "Pass either --day-of-month or --clear-day-of-month, not both."
+    );
+  }
+  if (options.dayOfMonth !== void 0) {
+    body.day_of_month = parseDayOfMonth(options.dayOfMonth);
+  } else if (options.clearDayOfMonth === true) {
+    body.day_of_month = null;
+  }
+  if (options.cron !== void 0 && options.clearCron === true) {
+    throw new CliError("Pass either --cron or --clear-cron, not both.");
+  }
+  if (options.cron !== void 0) {
+    body.cron = trimRequired(options.cron, "--cron");
+  } else if (options.clearCron === true) {
+    body.cron = null;
+  }
+  if (Object.keys(body).length === 0) {
+    throw new CliError(
+      "Provide at least one field to update (e.g. --frequency, --time, --enable, --disable, --recurring, --one-shot)."
+    );
+  }
+  return body;
+}
+__name(buildBody3, "buildBody");
+function registerAgentsSchedulesUpdate(schedules) {
+  schedules.command("update <agent-id> <schedule-id>").description(
+    "Update fields on a schedule. Only supplied fields change; omitted fields keep their current values."
+  ).option(
+    "--frequency <frequency>",
+    `new frequency (one of: ${FREQUENCY_HINT})`
+  ).option("--timezone <tz>", "new IANA timezone").option("--time <HH:MM>", "new time of day, 24-hour").option("--clear-time", "clear the time of day").option("--day <day>", `new day of week (one of: ${DAY_HINT})`).option("--clear-day", "clear the day of week").option("--day-of-month <n>", "new day of month (1-31)").option("--clear-day-of-month", "clear the day of month").option("--cron <expr>", "new cron expression").option("--clear-cron", "clear the cron expression").option("--enable", "enable the schedule").option("--disable", "disable the schedule").option("--recurring", "make the schedule recurring").option("--one-shot", "retire the schedule after its next run").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function updateAction(agentId, scheduleId, options) {
+    const trimmedAgentId = trimRequired(agentId, "<agent-id>");
+    const trimmedScheduleId = trimRequired(scheduleId, "<schedule-id>");
+    const body = buildBody3(options);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v1/agents/${encodeURIComponent(trimmedAgentId)}/schedules/${encodeURIComponent(
+        trimmedScheduleId
+      )}`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = publicScheduleSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    console.log(green("Schedule updated!"));
+    console.log(renderScheduleDetails(parsed.data));
+  }, "updateAction"));
+}
+__name(registerAgentsSchedulesUpdate, "registerAgentsSchedulesUpdate");
+
+// src/commands/agents/schedules/index.ts
+function registerAgentsSchedules(agents) {
+  const schedules = agents.command("schedules").description("Manage schedules for agents");
+  registerAgentsSchedulesList(schedules);
+  registerAgentsSchedulesCreate(schedules);
+  registerAgentsSchedulesUpdate(schedules);
+  registerAgentsSchedulesDelete(schedules);
 }
 __name(registerAgentsSchedules, "registerAgentsSchedules");
 
@@ -10056,7 +10370,7 @@ function parseBoolPair(enable, disable, enableFlag, disableFlag) {
   return void 0;
 }
 __name(parseBoolPair, "parseBoolPair");
-function buildBody3(options) {
+function buildBody4(options) {
   const body = {};
   if (options.name !== void 0) {
     body.name = trimRequired(options.name, "--name");
@@ -10104,14 +10418,14 @@ function buildBody3(options) {
   }
   return body;
 }
-__name(buildBody3, "buildBody");
+__name(buildBody4, "buildBody");
 function registerAgentsUpdate(agents) {
   agents.command("update <id>").description("Update an agent's display name or delivery settings").option("--name <name>", "new display name").option("--enable-slack", "enable Slack delivery").option("--disable-slack", "disable Slack delivery").option("--enable-microsoft-teams", "enable Microsoft Teams delivery").option("--disable-microsoft-teams", "disable Microsoft Teams delivery").option("--enable-agentic-memory", "enable agentic memory").option("--disable-agentic-memory", "disable agentic memory").option("--thread-id <id>", "associate the agent with a thread").option(
     "--clear-thread",
     "clear the agent's associated thread (sets thread_id to null)"
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function updateAction(id, options) {
     const agentId = trimRequired(id, "<id>");
-    const body = buildBody3(options);
+    const body = buildBody4(options);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const raw = await httpRequest({
       method: "PATCH",
@@ -12089,75 +12403,706 @@ function registerCases(program) {
 }
 __name(registerCases, "registerCases");
 
-// src/commands/connections/auth-methods.ts
-var AUTH_METHODS = createIntegrationRequestSchema.shape.auth_method.options;
-
-// src/commands/connections/parse-header-pairs.ts
-function parseHeaderPairs(flag, pairs) {
-  const out = {};
-  for (const pair of pairs) {
-    const eq = pair.indexOf("=");
-    if (eq < 1) {
+// src/commands/clarity/assign-extra-capture-request.ts
+import { z as z71 } from "zod";
+var responseSchema2 = z71.object({
+  request: clarityProposalExtraCaptureRequestSchema
+});
+function renderRequest(request) {
+  console.log(
+    renderKeyValue([
+      { label: "ID", value: request.id },
+      { label: "Step ID", value: request.step_id },
+      { label: "Status", value: request.status },
+      { label: "Priority", value: request.priority },
+      { label: "Assigned to", value: request.requested_user_id ?? "" },
+      { label: "Gap", value: request.gap },
+      { label: "Updated", value: request.updated_at }
+    ])
+  );
+}
+__name(renderRequest, "renderRequest");
+function registerClarityAssignExtraCaptureRequest(clarity) {
+  clarity.command(
+    "assign-extra-capture-request <process-id> <proposal-id> <request-id>"
+  ).description(
+    "Assign (or unassign) a team member to an extra-capture request"
+  ).option("--user-id <id>", "team member to assign (omit to unassign)").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, requestId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "PATCH",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests/${encodeURIComponent(requestId)}/assign`,
+      apiKey,
+      apiBaseUrl,
+      body: { user_id: options.userId ?? null }
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema2.safeParse(raw);
+    if (!parsed.success) {
       throw new CliError(
-        `${flag} must be KEY=VALUE (got "${pair}"); each occurrence sets one header.`
+        `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    const key = pair.slice(0, eq).trim();
-    const value = pair.slice(eq + 1);
-    if (key.length === 0) {
-      throw new CliError(`${flag} key must not be empty (got "${pair}").`);
-    }
-    out[key] = value;
-  }
-  return out;
+    renderRequest(parsed.data.request);
+  }, "action"));
 }
-__name(parseHeaderPairs, "parseHeaderPairs");
+__name(registerClarityAssignExtraCaptureRequest, "registerClarityAssignExtraCaptureRequest");
 
-// src/commands/connections/create.ts
-function registerConnectionsCreate(connections) {
-  connections.command("create").description(
-    "Create a user-provided connection (custom MCP server). OAuth-based integrations (Gmail, Slack, etc.) must be started via the dedicated `duvo oauth` commands."
-  ).requiredOption("--name <name>", "connection name").requiredOption(
-    "--auth-method <method>",
-    `authorization method (${AUTH_METHODS.join(", ")})`
-  ).option(
-    "--server-url <url>",
-    "MCP server URL (required unless --custom-integration-id resolves a server URL)"
-  ).option(
-    "--type <type>",
-    "integration type slug (defaults to custom_mcp on the backend)"
-  ).option(
-    "--custom-integration-id <uuid>",
-    "bind this connection to a team-defined custom integration"
-  ).option(
-    "--header <KEY=VALUE>",
-    "plaintext header (repeatable)",
-    (value, previous) => [
-      ...previous ?? [],
-      value
-    ]
-  ).option(
-    "--secret-header <KEY=VALUE>",
-    "secret header \u2014 encrypted at rest (repeatable)",
-    (value, previous) => [
-      ...previous ?? [],
-      value
-    ]
-  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
-    if (options.name === void 0 || options.name.trim().length === 0) {
-      throw new CliError("--name must not be empty");
-    }
-    if (options.authMethod === void 0) {
-      throw new CliError("--auth-method is required");
+// src/commands/clarity/build-automation.ts
+import { z as z72 } from "zod";
+var responseSchema3 = z72.object({
+  automation_run: z72.object({
+    id: z72.string(),
+    status: z72.string()
+  })
+});
+function registerClarityBuildAutomation(clarity) {
+  clarity.command("build-automation <process-id>").description(
+    "Hand the latest transformation proposal off to the workflow-builder pipeline (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/automation`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
     }
-    if (!AUTH_METHODS.includes(options.authMethod)) {
+    const parsed = responseSchema3.safeParse(raw);
+    if (!parsed.success) {
       throw new CliError(
-        `--auth-method must be one of: ${AUTH_METHODS.join(", ")}`
+        `Unexpected response from the API: ${parsed.error.message}`
       );
     }
-    const body = {
-      name: options.name.trim(),
-      provider: "user",
+    const { automation_run: run } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "Run ID", value: run.id },
+        { label: "Status", value: run.status }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityBuildAutomation, "registerClarityBuildAutomation");
+
+// src/commands/clarity/generate-current-process.ts
+function registerClarityGenerateCurrentProcess(clarity) {
+  clarity.command("generate-current-process <process-id>").description(
+    "Trigger current-process generation for a Clarity v2 process (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/current-process`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Generation started.");
+  }, "action"));
+}
+__name(registerClarityGenerateCurrentProcess, "registerClarityGenerateCurrentProcess");
+
+// src/commands/clarity/generate-transformation-proposal.ts
+function registerClarityGenerateTransformationProposal(clarity) {
+  clarity.command("generate-transformation-proposal <process-id>").description(
+    "Trigger transformation-proposal generation for a Clarity v2 process (async)"
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Generation started.");
+  }, "action"));
+}
+__name(registerClarityGenerateTransformationProposal, "registerClarityGenerateTransformationProposal");
+
+// src/commands/clarity/get-current-process.ts
+import { z as z73 } from "zod";
+var snapshotSchema = z73.object({
+  snapshot: z73.object({
+    id: z73.string(),
+    status: z73.string(),
+    creator_type: z73.string(),
+    user_id: z73.string().nullable(),
+    sandbox_id: z73.string().nullable(),
+    created_at: z73.string(),
+    updated_at: z73.string()
+  })
+});
+function registerClarityGetCurrentProcess(clarity) {
+  clarity.command("get-current-process <process-id> <snapshot-id>").description("Get a specific current-process snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "User ID", value: snapshot.user_id ?? "" },
+        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityGetCurrentProcess, "registerClarityGetCurrentProcess");
+
+// src/commands/clarity/get-transformation-proposal.ts
+import { z as z74 } from "zod";
+var snapshotSchema2 = z74.object({
+  snapshot: z74.object({
+    id: z74.string(),
+    status: z74.string(),
+    creator_type: z74.string(),
+    user_id: z74.string().nullable(),
+    sandbox_id: z74.string().nullable(),
+    created_at: z74.string(),
+    updated_at: z74.string()
+  })
+});
+function registerClarityGetTransformationProposal(clarity) {
+  clarity.command("get-transformation-proposal <process-id> <proposal-id>").description("Get a specific transformation-proposal snapshot by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema2.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "User ID", value: snapshot.user_id ?? "" },
+        { label: "Sandbox ID", value: snapshot.sandbox_id ?? "" },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityGetTransformationProposal, "registerClarityGetTransformationProposal");
+
+// src/commands/clarity/get.ts
+function registerClarityGet(clarity) {
+  clarity.command("get <process-id>").description("Get a Clarity process read model by ID").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function getAction(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = clarityV2ProcessReadModelSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { process: process2 } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: process2.id },
+        { label: "Name", value: process2.name },
+        { label: "Status", value: process2.status },
+        { label: "Version", value: String(process2.version) },
+        { label: "Created", value: process2.created_at },
+        { label: "Updated", value: process2.updated_at },
+        {
+          label: "Error",
+          value: process2.generation_error ?? ""
+        },
+        {
+          label: "Custom prompt",
+          value: process2.custom_prompt ?? ""
+        }
+      ])
+    );
+    const {
+      current_process_versions: cpVersions,
+      transformation_proposal_versions: tpVersions
+    } = parsed.data;
+    if (cpVersions.length > 0) {
+      console.log(`
+Current process versions (${cpVersions.length}):`);
+      for (const v of cpVersions) {
+        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
+      }
+    }
+    if (tpVersions.length > 0) {
+      console.log(
+        `
+Transformation proposal versions (${tpVersions.length}):`
+      );
+      for (const v of tpVersions) {
+        console.log(`  - ${v.id}  ${v.status}  ${v.created_at}`);
+      }
+    }
+  }, "getAction"));
+}
+__name(registerClarityGet, "registerClarityGet");
+
+// src/commands/clarity/list-extra-capture-requests.ts
+var DEFAULT_LIMIT5 = 20;
+var MIN_LIMIT5 = 1;
+var MAX_LIMIT5 = 100;
+var TABLE_COLUMNS12 = [
+  {
+    header: "ID",
+    cell: /* @__PURE__ */ __name((row) => row.id, "cell")
+  },
+  {
+    header: "STEP ID",
+    cell: /* @__PURE__ */ __name((row) => row.step_id, "cell")
+  },
+  {
+    header: "STATUS",
+    cell: /* @__PURE__ */ __name((row) => row.status, "cell")
+  },
+  {
+    header: "PRIORITY",
+    cell: /* @__PURE__ */ __name((row) => row.priority, "cell")
+  },
+  {
+    header: "ASSIGNED TO",
+    cell: /* @__PURE__ */ __name((row) => row.requested_user_id ?? "", "cell")
+  },
+  {
+    header: "GAP",
+    cell: /* @__PURE__ */ __name((row) => row.gap, "cell"),
+    maxWidth: 50
+  }
+];
+function registerClarityListExtraCaptureRequests(clarity) {
+  clarity.command("list-extra-capture-requests <process-id> <proposal-id>").description("List extra-capture requests for a transformation proposal").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).option("--offset <n>", "number of requests to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT5,
+      min: MIN_LIMIT5,
+      max: MAX_LIMIT5
+    });
+    const offset = parseOffset(options.offset);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await httpRequest({
+      method: "GET",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposals/${encodeURIComponent(proposalId)}/extra-capture-requests`,
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = clarityProposalExtraCaptureRequestListResponseSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (response.requests.length === 0) {
+      console.log("No extra-capture requests found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS12, response.requests));
+    console.log(
+      `Showing ${response.requests.length} of ${response.total} \xB7 offset ${response.offset}`
+    );
+  }, "action"));
+}
+__name(registerClarityListExtraCaptureRequests, "registerClarityListExtraCaptureRequests");
+
+// src/commands/clarity/list.ts
+import { z as z75 } from "zod";
+var DEFAULT_LIMIT6 = 50;
+var MIN_LIMIT6 = 1;
+var MAX_LIMIT6 = 100;
+var processListItemSchema = z75.object({
+  id: z75.string(),
+  name: z75.string(),
+  status: z75.string(),
+  version: z75.number(),
+  capture_count: z75.number(),
+  created_at: z75.string(),
+  created_by_name: z75.string().nullable()
+});
+var responseSchema4 = z75.object({
+  processes: z75.array(processListItemSchema),
+  total: z75.number(),
+  limit: z75.number(),
+  offset: z75.number()
+});
+var TABLE_COLUMNS13 = [
+  { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
+  { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
+  { header: "STATUS", cell: /* @__PURE__ */ __name((row) => row.status, "cell") },
+  { header: "VERSION", cell: /* @__PURE__ */ __name((row) => String(row.version), "cell") },
+  {
+    header: "CAPTURES",
+    cell: /* @__PURE__ */ __name((row) => String(row.capture_count), "cell")
+  },
+  { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at, "cell") }
+];
+function registerClarityList(clarity) {
+  clarity.command("list", { isDefault: true }).description("List Clarity processes for your team").option("--limit <n>", `page size (${MIN_LIMIT6}-${MAX_LIMIT6})`).option("--offset <n>", "number of processes to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function listAction(options) {
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT6,
+      min: MIN_LIMIT6,
+      max: MAX_LIMIT6
+    });
+    const offset = parseOffset(options.offset);
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const searchParams = new URLSearchParams();
+    searchParams.append("limit", String(limit));
+    searchParams.append("offset", String(offset));
+    const raw = await httpRequest({
+      method: "GET",
+      path: "/v1/clarity-v2/processes",
+      apiKey,
+      apiBaseUrl,
+      searchParams
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = responseSchema4.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const response = parsed.data;
+    if (response.processes.length === 0) {
+      console.log("No Clarity processes found.");
+      return;
+    }
+    console.log(renderTable(TABLE_COLUMNS13, response.processes));
+    console.log(
+      `Showing ${response.processes.length} of ${response.total} \xB7 offset ${response.offset}`
+    );
+  }, "listAction"));
+}
+__name(registerClarityList, "registerClarityList");
+
+// src/commands/clarity/postprocess.ts
+var SNAPSHOT_TYPES = ["current_process", "transformation_proposal"];
+function registerClarityPostprocess(clarity) {
+  clarity.command("postprocess <process-id> <snapshot-type> <snapshot-id>").description(
+    `Re-run postprocessing agents on an existing snapshot. snapshot-type must be one of: ${SNAPSHOT_TYPES.join(", ")}`
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotType, snapshotId, options) {
+    if (!SNAPSHOT_TYPES.includes(snapshotType)) {
+      throw new CliError(
+        `snapshot-type must be one of: ${SNAPSHOT_TYPES.join(", ")}`
+      );
+    }
+    const type = snapshotType;
+    const body = type === "current_process" ? { type, current_process_id: snapshotId } : { type, transformation_proposal_id: snapshotId };
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/postprocess`,
+      apiKey,
+      apiBaseUrl,
+      body
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Postprocessing started.");
+  }, "action"));
+}
+__name(registerClarityPostprocess, "registerClarityPostprocess");
+
+// src/commands/clarity/promote-current-process.ts
+import { z as z76 } from "zod";
+var snapshotSchema3 = z76.object({
+  snapshot: z76.object({
+    id: z76.string(),
+    status: z76.string(),
+    creator_type: z76.string(),
+    created_at: z76.string(),
+    updated_at: z76.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: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}/promote`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema3.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityPromoteCurrentProcess, "registerClarityPromoteCurrentProcess");
+
+// src/commands/clarity/promote-transformation-proposal.ts
+import { z as z77 } from "zod";
+var snapshotSchema4 = z77.object({
+  snapshot: z77.object({
+    id: z77.string(),
+    status: z77.string(),
+    creator_type: z77.string(),
+    created_at: z77.string(),
+    updated_at: z77.string()
+  })
+});
+function registerClarityPromoteTransformationProposal(clarity) {
+  clarity.command("promote-transformation-proposal <process-id> <proposal-id>").description("Promote a transformation-proposal snapshot to live").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}/promote`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    const parsed = snapshotSchema4.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${parsed.error.message}`
+      );
+    }
+    const { snapshot } = parsed.data;
+    console.log(
+      renderKeyValue([
+        { label: "ID", value: snapshot.id },
+        { label: "Status", value: snapshot.status },
+        { label: "Creator type", value: snapshot.creator_type },
+        { label: "Created", value: snapshot.created_at },
+        { label: "Updated", value: snapshot.updated_at }
+      ])
+    );
+  }, "action"));
+}
+__name(registerClarityPromoteTransformationProposal, "registerClarityPromoteTransformationProposal");
+
+// src/commands/clarity/revert-current-process.ts
+function registerClarityRevertCurrentProcess(clarity) {
+  clarity.command("revert-current-process <process-id> <snapshot-id>").description("Delete (revert) a current-process snapshot").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, snapshotId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/current-process/${encodeURIComponent(snapshotId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Snapshot reverted.");
+  }, "action"));
+}
+__name(registerClarityRevertCurrentProcess, "registerClarityRevertCurrentProcess");
+
+// src/commands/clarity/revert-transformation-proposal.ts
+function registerClarityRevertTransformationProposal(clarity) {
+  clarity.command("revert-transformation-proposal <process-id> <proposal-id>").description("Delete (revert) a transformation-proposal snapshot").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, proposalId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "DELETE",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/${encodeURIComponent(proposalId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Snapshot reverted.");
+  }, "action"));
+}
+__name(registerClarityRevertTransformationProposal, "registerClarityRevertTransformationProposal");
+
+// src/commands/clarity/stop-transformation-proposal.ts
+function registerClarityStopTransformationProposal(clarity) {
+  clarity.command("stop-transformation-proposal <process-id>").description("Stop an in-flight transformation-proposal generation").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function action(processId, options) {
+    const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    const raw = await httpRequest({
+      method: "POST",
+      path: `/v1/clarity-v2/processes/${encodeURIComponent(processId)}/transformation-proposal/stop`,
+      apiKey,
+      apiBaseUrl
+    });
+    if (options.json) {
+      printJson(raw);
+      return;
+    }
+    console.log("Generation stopped.");
+  }, "action"));
+}
+__name(registerClarityStopTransformationProposal, "registerClarityStopTransformationProposal");
+
+// src/commands/clarity/index.ts
+function registerClarity(program) {
+  const clarity = program.command("clarity").description("Manage Clarity v2 processes in the Duvo public API");
+  registerClarityList(clarity);
+  registerClarityGet(clarity);
+  registerClarityGenerateCurrentProcess(clarity);
+  registerClarityGetCurrentProcess(clarity);
+  registerClarityPromoteCurrentProcess(clarity);
+  registerClarityRevertCurrentProcess(clarity);
+  registerClarityGenerateTransformationProposal(clarity);
+  registerClarityGetTransformationProposal(clarity);
+  registerClarityPromoteTransformationProposal(clarity);
+  registerClarityRevertTransformationProposal(clarity);
+  registerClarityStopTransformationProposal(clarity);
+  registerClarityListExtraCaptureRequests(clarity);
+  registerClarityAssignExtraCaptureRequest(clarity);
+  registerClarityBuildAutomation(clarity);
+  registerClarityPostprocess(clarity);
+}
+__name(registerClarity, "registerClarity");
+
+// src/commands/connections/auth-methods.ts
+var AUTH_METHODS = createIntegrationRequestSchema.shape.auth_method.options;
+
+// src/commands/connections/parse-header-pairs.ts
+function parseHeaderPairs(flag, pairs) {
+  const out = {};
+  for (const pair of pairs) {
+    const eq = pair.indexOf("=");
+    if (eq < 1) {
+      throw new CliError(
+        `${flag} must be KEY=VALUE (got "${pair}"); each occurrence sets one header.`
+      );
+    }
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1);
+    if (key.length === 0) {
+      throw new CliError(`${flag} key must not be empty (got "${pair}").`);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+__name(parseHeaderPairs, "parseHeaderPairs");
+
+// src/commands/connections/create.ts
+function registerConnectionsCreate(connections) {
+  connections.command("create").description(
+    "Create a user-provided connection (custom MCP server). OAuth-based integrations (Gmail, Slack, etc.) must be started via the dedicated `duvo oauth` commands."
+  ).requiredOption("--name <name>", "connection name").requiredOption(
+    "--auth-method <method>",
+    `authorization method (${AUTH_METHODS.join(", ")})`
+  ).option(
+    "--server-url <url>",
+    "MCP server URL (required unless --custom-integration-id resolves a server URL)"
+  ).option(
+    "--type <type>",
+    "integration type slug (defaults to custom_mcp on the backend)"
+  ).option(
+    "--custom-integration-id <uuid>",
+    "bind this connection to a team-defined custom integration"
+  ).option(
+    "--header <KEY=VALUE>",
+    "plaintext header (repeatable)",
+    (value, previous) => [
+      ...previous ?? [],
+      value
+    ]
+  ).option(
+    "--secret-header <KEY=VALUE>",
+    "secret header \u2014 encrypted at rest (repeatable)",
+    (value, previous) => [
+      ...previous ?? [],
+      value
+    ]
+  ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function createAction(options) {
+    if (options.name === void 0 || options.name.trim().length === 0) {
+      throw new CliError("--name must not be empty");
+    }
+    if (options.authMethod === void 0) {
+      throw new CliError("--auth-method is required");
+    }
+    if (!AUTH_METHODS.includes(options.authMethod)) {
+      throw new CliError(
+        `--auth-method must be one of: ${AUTH_METHODS.join(", ")}`
+      );
+    }
+    const body = {
+      name: options.name.trim(),
+      provider: "user",
       auth_method: options.authMethod
     };
     if (options.type !== void 0) {
@@ -12345,7 +13290,7 @@ function registerConnectionsGet(connections) {
 __name(registerConnectionsGet, "registerConnectionsGet");
 
 // src/commands/connections/list.ts
-var TABLE_COLUMNS12 = [
+var TABLE_COLUMNS14 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -12381,26 +13326,26 @@ function registerConnectionsList(connections) {
       console.log("No connections found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS12, rows));
+    console.log(renderTable(TABLE_COLUMNS14, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
 __name(registerConnectionsList, "registerConnectionsList");
 
 // src/commands/connections/probe.ts
-import { z as z71 } from "zod";
-var toolSchema = z71.object({
-  name: z71.string(),
-  description: z71.string().optional(),
-  input_schema: z71.record(z71.string(), z71.unknown()).optional()
+import { z as z78 } from "zod";
+var toolSchema = z78.object({
+  name: z78.string(),
+  description: z78.string().optional(),
+  input_schema: z78.record(z78.string(), z78.unknown()).optional()
 });
-var probeResponseSchema = z71.object({
-  success: z71.boolean(),
-  tools: z71.array(toolSchema).optional(),
-  error: z71.string().optional()
+var probeResponseSchema = z78.object({
+  success: z78.boolean(),
+  tools: z78.array(toolSchema).optional(),
+  error: z78.string().optional()
 });
 var DESCRIPTION_MAX_WIDTH = 80;
-var TABLE_COLUMNS13 = [
+var TABLE_COLUMNS15 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
     header: "DESCRIPTION",
@@ -12456,7 +13401,7 @@ function registerConnectionsProbe(connections) {
       console.log("No tools found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS13, tools));
+    console.log(renderTable(TABLE_COLUMNS15, tools));
     console.log(
       `Showing ${tools.length} tool${tools.length === 1 ? "" : "s"}`
     );
@@ -12612,48 +13557,48 @@ function registerConnections(program) {
 __name(registerConnections, "registerConnections");
 
 // src/api/credential-schemas.ts
-import { z as z72 } from "zod";
-var dateLike = z72.string();
-var secretSchema = z72.object({
-  id: z72.string(),
-  team_id: z72.string(),
-  user_id: z72.string().nullable(),
-  name: z72.string(),
-  service_slug: z72.string().nullable(),
-  env_var_keys: z72.array(z72.string()),
-  created_by: z72.string(),
+import { z as z79 } from "zod";
+var dateLike = z79.string();
+var secretSchema = z79.object({
+  id: z79.string(),
+  team_id: z79.string(),
+  user_id: z79.string().nullable(),
+  name: z79.string(),
+  service_slug: z79.string().nullable(),
+  env_var_keys: z79.array(z79.string()),
+  created_by: z79.string(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var secretsListResponseSchema = z72.array(secretSchema);
+var secretsListResponseSchema = z79.array(secretSchema);
 var secretResponseSchema = secretSchema;
-var browserLoginSchema = z72.object({
-  id: z72.string(),
-  user_id: z72.string().nullable(),
-  team_id: z72.string(),
-  domain: z72.string(),
-  username: z72.string().nullable(),
+var browserLoginSchema = z79.object({
+  id: z79.string(),
+  user_id: z79.string().nullable(),
+  team_id: z79.string(),
+  domain: z79.string(),
+  username: z79.string().nullable(),
   password: encryptedDataSchema.nullable(),
   otp_secret: encryptedDataSchema.nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var browserLoginsListResponseSchema = z72.array(credentialPreviewSchema);
-var revisionLoginSummarySchema = z72.object({
-  id: z72.string(),
-  user_id: z72.string().nullable(),
-  team_id: z72.string().nullable(),
-  domain: z72.string(),
-  username: z72.string().nullable(),
+var browserLoginsListResponseSchema = z79.array(credentialPreviewSchema);
+var revisionLoginSummarySchema = z79.object({
+  id: z79.string(),
+  user_id: z79.string().nullable(),
+  team_id: z79.string().nullable(),
+  domain: z79.string(),
+  username: z79.string().nullable(),
   created_at: dateLike,
   updated_at: dateLike
 });
-var revisionLoginsListResponseSchema = z72.array(
+var revisionLoginsListResponseSchema = z79.array(
   revisionLoginSummarySchema
 );
-var revisionSecretsListResponseSchema = z72.array(secretSchema);
-var successResponseSchema2 = z72.object({
-  success: z72.boolean()
+var revisionSecretsListResponseSchema = z79.array(secretSchema);
+var successResponseSchema2 = z79.object({
+  success: z79.boolean()
 });
 var attachSuccessResponseSchema = successResponseSchema2;
 var deleteSecretResponseSchema = successResponseSchema2;
@@ -12841,7 +13786,7 @@ function registerCredentialsGet(credentials) {
 __name(registerCredentialsGet, "registerCredentialsGet");
 
 // src/commands/credentials/list.ts
-var TABLE_COLUMNS14 = [
+var TABLE_COLUMNS16 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -12896,7 +13841,7 @@ function registerCredentialsList(credentials) {
       console.log("No credentials found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS14, rows));
+    console.log(renderTable(TABLE_COLUMNS16, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -13156,7 +14101,7 @@ function registerFilesDownloadUrl(files) {
 __name(registerFilesDownloadUrl, "registerFilesDownloadUrl");
 
 // src/commands/files/list.ts
-var TABLE_COLUMNS15 = [
+var TABLE_COLUMNS17 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -13195,7 +14140,7 @@ function registerFilesList(files) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS15, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS17, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "listAction"));
 }
@@ -13445,7 +14390,7 @@ function registerIntegrationsCustom(integrations) {
 __name(registerIntegrationsCustom, "registerIntegrationsCustom");
 
 // src/commands/integrations/list.ts
-var TABLE_COLUMNS16 = [
+var TABLE_COLUMNS18 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
@@ -13479,7 +14424,7 @@ function registerIntegrationsList(integrations) {
       console.log("No integrations found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS16, rows));
+    console.log(renderTable(TABLE_COLUMNS18, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -14306,7 +15251,7 @@ function parseHeaders(raw) {
   return result;
 }
 __name(parseHeaders, "parseHeaders");
-var TABLE_COLUMNS17 = [
+var TABLE_COLUMNS19 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "DESCRIPTION", cell: /* @__PURE__ */ __name((row) => row.description, "cell") }
 ];
@@ -14360,7 +15305,7 @@ function registerOauthMcpProbe(mcp) {
       console.log("No tools advertised by this MCP server.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS17, rows));
+    console.log(renderTable(TABLE_COLUMNS19, rows));
     console.log(`Showing ${rows.length}`);
   }, "probeMcpAction"));
 }
@@ -14435,7 +15380,7 @@ function registerOauth(program) {
 __name(registerOauth, "registerOauth");
 
 // src/commands/plugins/list.ts
-var TABLE_COLUMNS18 = [
+var TABLE_COLUMNS20 = [
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   { header: "TYPE", cell: /* @__PURE__ */ __name((row) => row.type, "cell") },
   {
@@ -14469,7 +15414,7 @@ function registerPluginsList(plugins) {
       console.log("No plugins found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS18, parsed.data.plugins));
+    console.log(renderTable(TABLE_COLUMNS20, parsed.data.plugins));
     console.log(`Showing ${parsed.data.plugins.length}`);
   }, "listAction"));
 }
@@ -14667,7 +15612,7 @@ function registerProfiles(program) {
 __name(registerProfiles, "registerProfiles");
 
 // src/commands/queue-labels/index.ts
-var TABLE_COLUMNS19 = [
+var TABLE_COLUMNS21 = [
   { 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") },
@@ -14721,7 +15666,7 @@ function registerList2(labels) {
       console.log("No labels defined on this queue.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS19, parsed.data.labels));
+    console.log(renderTable(TABLE_COLUMNS21, parsed.data.labels));
     console.log(`Showing ${parsed.data.labels.length}`);
   }, "listAction"));
 }
@@ -15079,10 +16024,10 @@ function registerQueuesGet(queues) {
 __name(registerQueuesGet, "registerQueuesGet");
 
 // src/commands/queues/list.ts
-var DEFAULT_LIMIT5 = 20;
-var MIN_LIMIT5 = 1;
-var MAX_LIMIT5 = 100;
-var TABLE_COLUMNS20 = [
+var DEFAULT_LIMIT7 = 20;
+var MIN_LIMIT7 = 1;
+var MAX_LIMIT7 = 100;
+var TABLE_COLUMNS22 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -15093,11 +16038,11 @@ var TABLE_COLUMNS20 = [
   { header: "CREATED", cell: /* @__PURE__ */ __name((row) => row.created_at ?? "", "cell") }
 ];
 function registerQueuesList(queues) {
-  queues.command("list", { isDefault: true }).description("List case queues for your team").option("--limit <n>", `page size (${MIN_LIMIT5}-${MAX_LIMIT5})`).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 case 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) {
     const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT5,
-      min: MIN_LIMIT5,
-      max: MAX_LIMIT5
+      defaultValue: DEFAULT_LIMIT7,
+      min: MIN_LIMIT7,
+      max: MAX_LIMIT7
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -15126,7 +16071,7 @@ function registerQueuesList(queues) {
       console.log("No queues found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS20, response.queues));
+    console.log(renderTable(TABLE_COLUMNS22, 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}`;
@@ -15288,7 +16233,7 @@ function registerRevisionLoginsDetach(revisionLogins) {
 __name(registerRevisionLoginsDetach, "registerRevisionLoginsDetach");
 
 // src/commands/revision-logins/list.ts
-var TABLE_COLUMNS21 = [
+var TABLE_COLUMNS23 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "DOMAIN", cell: /* @__PURE__ */ __name((row) => row.domain, "cell") },
   {
@@ -15324,7 +16269,7 @@ function registerRevisionLoginsList(revisionLogins) {
       console.log("No browser logins attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS21, rows));
+    console.log(renderTable(TABLE_COLUMNS23, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -15397,7 +16342,7 @@ function registerRevisionSecretsDetach(revisionSecrets) {
 __name(registerRevisionSecretsDetach, "registerRevisionSecretsDetach");
 
 // src/commands/revision-secrets/list.ts
-var TABLE_COLUMNS22 = [
+var TABLE_COLUMNS24 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -15435,7 +16380,7 @@ function registerRevisionSecretsList(revisionSecrets) {
       console.log("No secrets attached to this revision.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS22, rows));
+    console.log(renderTable(TABLE_COLUMNS24, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -15451,91 +16396,91 @@ function registerRevisionSecrets(program) {
 __name(registerRevisionSecrets, "registerRevisionSecrets");
 
 // src/api/run-schemas.ts
-import { z as z73 } from "zod";
-var publicRunSchema = z73.object({
-  id: z73.string(),
-  agent_id: z73.string(),
-  build_id: z73.string(),
-  status: z73.string(),
-  source: z73.string().nullish(),
-  sandbox_id: z73.string().nullish(),
-  started_at: z73.string().nullish(),
-  completed_at: z73.string().nullish(),
-  created_at: z73.string(),
-  updated_at: z73.string().nullish(),
-  human_in_the_loop_enabled: z73.boolean().nullish()
-});
-var startRunResponseSchema = z73.object({
+import { z as z80 } from "zod";
+var publicRunSchema = z80.object({
+  id: z80.string(),
+  agent_id: z80.string(),
+  build_id: z80.string(),
+  status: z80.string(),
+  source: z80.string().nullish(),
+  sandbox_id: z80.string().nullish(),
+  started_at: z80.string().nullish(),
+  completed_at: z80.string().nullish(),
+  created_at: z80.string(),
+  updated_at: z80.string().nullish(),
+  human_in_the_loop_enabled: z80.boolean().nullish()
+});
+var startRunResponseSchema = z80.object({
   run: publicRunSchema
 });
-var questionOptionSchema = z73.object({
-  label: z73.string(),
-  description: z73.string().nullish()
-});
-var questionSchema = z73.object({
-  question: z73.string(),
-  header: z73.string().nullish(),
-  options: z73.array(questionOptionSchema).nullish(),
-  multi_select: z73.boolean().nullish()
-});
-var pendingHumanRequestSchema = z73.object({
-  id: z73.string(),
-  title: z73.string(),
-  description: z73.string().nullish(),
-  created_at: z73.string(),
-  type: z73.string(),
-  questions: z73.array(questionSchema).nullish()
-});
-var getRunResponseSchema = z73.object({
+var questionOptionSchema = z80.object({
+  label: z80.string(),
+  description: z80.string().nullish()
+});
+var questionSchema = z80.object({
+  question: z80.string(),
+  header: z80.string().nullish(),
+  options: z80.array(questionOptionSchema).nullish(),
+  multi_select: z80.boolean().nullish()
+});
+var pendingHumanRequestSchema = z80.object({
+  id: z80.string(),
+  title: z80.string(),
+  description: z80.string().nullish(),
+  created_at: z80.string(),
+  type: z80.string(),
+  questions: z80.array(questionSchema).nullish()
+});
+var getRunResponseSchema = z80.object({
   run: publicRunSchema.nullable(),
   pending_human_request: pendingHumanRequestSchema.nullish()
 });
-var stopRunResponseSchema = z73.object({
-  success: z73.boolean(),
-  message: z73.string().nullish()
-});
-var runMessageSchema = z73.object({
-  id: z73.string(),
-  type: z73.string(),
-  role: z73.string(),
-  timestamp: z73.string(),
-  text_content: z73.string().nullish(),
-  tool_call: z73.object({
-    id: z73.string(),
-    name: z73.string(),
-    arguments: z73.record(z73.string(), z73.unknown()).nullish()
+var stopRunResponseSchema = z80.object({
+  success: z80.boolean(),
+  message: z80.string().nullish()
+});
+var runMessageSchema = z80.object({
+  id: z80.string(),
+  type: z80.string(),
+  role: z80.string(),
+  timestamp: z80.string(),
+  text_content: z80.string().nullish(),
+  tool_call: z80.object({
+    id: z80.string(),
+    name: z80.string(),
+    arguments: z80.record(z80.string(), z80.unknown()).nullish()
   }).nullish(),
-  tool_result: z73.object({
-    tool_call_id: z73.string(),
-    result: z73.unknown().nullish(),
-    error: z73.string().nullish()
+  tool_result: z80.object({
+    tool_call_id: z80.string(),
+    result: z80.unknown().nullish(),
+    error: z80.string().nullish()
   }).nullish()
 });
-var listRunMessagesResponseSchema = z73.object({
-  messages: z73.array(runMessageSchema),
-  total: z73.number().nullish(),
-  limit: z73.number().nullish(),
-  offset: z73.number().nullish()
+var listRunMessagesResponseSchema = z80.object({
+  messages: z80.array(runMessageSchema),
+  total: z80.number().nullish(),
+  limit: z80.number().nullish(),
+  offset: z80.number().nullish()
 });
-var postedMessageSchema = z73.object({
-  id: z73.string(),
-  type: z73.string(),
-  role: z73.string(),
-  timestamp: z73.string(),
-  text_content: z73.string()
+var postedMessageSchema = z80.object({
+  id: z80.string(),
+  type: z80.string(),
+  role: z80.string(),
+  timestamp: z80.string(),
+  text_content: z80.string()
 });
-var postRunMessageResponseSchema = z73.object({
+var postRunMessageResponseSchema = z80.object({
   message: postedMessageSchema
 });
-var respondHumanRequestResponseSchema = z73.object({
-  human_request: z73.object({
-    id: z73.string(),
-    run_id: z73.string(),
-    title: z73.string(),
-    description: z73.string().nullish(),
-    response: z73.string().nullish(),
-    responded_at: z73.string().nullish(),
-    created_at: z73.string()
+var respondHumanRequestResponseSchema = z80.object({
+  human_request: z80.object({
+    id: z80.string(),
+    run_id: z80.string(),
+    title: z80.string(),
+    description: z80.string().nullish(),
+    response: z80.string().nullish(),
+    responded_at: z80.string().nullish(),
+    created_at: z80.string()
   })
 });
 
@@ -15598,13 +16543,13 @@ function registerRunsGet(runs) {
 __name(registerRunsGet, "registerRunsGet");
 
 // src/commands/runs/list.ts
-var DEFAULT_LIMIT6 = 20;
-var MIN_LIMIT6 = 1;
-var MAX_LIMIT6 = 100;
+var DEFAULT_LIMIT8 = 20;
+var MIN_LIMIT8 = 1;
+var MAX_LIMIT8 = 100;
 var SORT_ORDERS2 = ["asc", "desc"];
 var HAS_ISSUES_VALUES = ["true", "false"];
 var TITLE_PREVIEW_WIDTH = 50;
-var TABLE_COLUMNS23 = [
+var TABLE_COLUMNS25 = [
   { 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") },
@@ -15628,7 +16573,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_LIMIT6}-${MAX_LIMIT6})`).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_LIMIT8}-${MAX_LIMIT8})`).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 case queue ID").option("--source <source>", "filter by source").option("--search <query>", "free-text search across runs").option(
@@ -15636,9 +16581,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_LIMIT6,
-      min: MIN_LIMIT6,
-      max: MAX_LIMIT6
+      defaultValue: DEFAULT_LIMIT8,
+      min: MIN_LIMIT8,
+      max: MAX_LIMIT8
     });
     const offset = parseOffset(options.offset);
     if (options.sortOrder !== void 0 && !isSortOrder(options.sortOrder)) {
@@ -15701,7 +16646,7 @@ function registerRunsList(runs) {
       console.log("No runs found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS23, response.data));
+    console.log(renderTable(TABLE_COLUMNS25, response.data));
     console.log(
       `Showing ${response.data.length} of ${response.total} \xB7 offset ${offset}`
     );
@@ -15709,12 +16654,109 @@ function registerRunsList(runs) {
 }
 __name(registerRunsList, "registerRunsList");
 
+// src/commands/runs/follow.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "stopped", "error"]);
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var FOLLOW_PAGE_SIZE = 50;
+function resolvePollIntervalMs() {
+  const envValue = process.env.FOLLOW_POLL_INTERVAL_MS;
+  if (envValue !== void 0) {
+    const parsed = Number(envValue);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new CliError(
+        "FOLLOW_POLL_INTERVAL_MS must be a non-negative number"
+      );
+    }
+    return parsed;
+  }
+  return DEFAULT_POLL_INTERVAL_MS;
+}
+__name(resolvePollIntervalMs, "resolvePollIntervalMs");
+async function followRunMessages(runId, apiKey, apiBaseUrl, options = {}) {
+  const { startOffset = 0, json = false } = options;
+  const pollIntervalMs = resolvePollIntervalMs();
+  let seenCount = startOffset;
+  while (true) {
+    let batchSize = 1;
+    while (batchSize > 0) {
+      const searchParams = new URLSearchParams();
+      searchParams.append("limit", String(FOLLOW_PAGE_SIZE));
+      searchParams.append("offset", String(seenCount));
+      const raw = await httpRequest({
+        method: "GET",
+        path: `/v1/runs/${encodeURIComponent(runId)}/messages`,
+        apiKey,
+        apiBaseUrl,
+        searchParams
+      });
+      const parsed = listRunMessagesResponseSchema.safeParse(raw);
+      if (!parsed.success) {
+        throw new CliError(
+          `Unexpected response from the API: ${parsed.error.message}`
+        );
+      }
+      const { messages } = parsed.data;
+      batchSize = messages.length;
+      for (const msg of messages) {
+        if (json) {
+          console.log(JSON.stringify(msg));
+        } else {
+          console.log(formatMessage(msg));
+        }
+      }
+      seenCount += batchSize;
+    }
+    const runRaw = await httpRequest({
+      method: "GET",
+      path: `/v1/runs/${encodeURIComponent(runId)}`,
+      apiKey,
+      apiBaseUrl
+    });
+    const runParsed = getRunResponseSchema.safeParse(runRaw);
+    if (!runParsed.success) {
+      throw new CliError(
+        `Unexpected response from the API: ${runParsed.error.message}`
+      );
+    }
+    const { run } = runParsed.data;
+    if (!run || TERMINAL_STATUSES.has(run.status)) {
+      if (!json) {
+        const status = run?.status ?? "ended";
+        console.log(`
+Job ${status}.`);
+      }
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+}
+__name(followRunMessages, "followRunMessages");
+var ROLE_COLUMN_WIDTH = 9;
+function formatMessage(msg) {
+  const role = msg.role.padEnd(ROLE_COLUMN_WIDTH);
+  return `${msg.timestamp}  ${role}  ${getContent(msg)}`;
+}
+__name(formatMessage, "formatMessage");
+function getContent(msg) {
+  if (msg.text_content) {
+    return msg.text_content.replace(/\s+/g, " ").trim();
+  }
+  if (msg.tool_call) {
+    return `tool_call ${msg.tool_call.name}`;
+  }
+  if (msg.tool_result) {
+    return `tool_result ${msg.tool_result.tool_call_id}`;
+  }
+  return "";
+}
+__name(getContent, "getContent");
+
 // src/commands/runs/messages.ts
-var DEFAULT_LIMIT7 = 20;
-var MIN_LIMIT7 = 1;
-var MAX_LIMIT7 = 50;
+var DEFAULT_LIMIT9 = 20;
+var MIN_LIMIT9 = 1;
+var MAX_LIMIT9 = 50;
 var TEXT_PREVIEW_WIDTH2 = 60;
-var TABLE_COLUMNS24 = [
+var TABLE_COLUMNS26 = [
   { 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") },
@@ -15739,14 +16781,21 @@ 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_LIMIT7}-${MAX_LIMIT7})`).option("--offset <n>", "number of messages to skip").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function messagesAction(id, options) {
-    const limit = parseLimit(options.limit, {
-      defaultValue: DEFAULT_LIMIT7,
-      min: MIN_LIMIT7,
-      max: MAX_LIMIT7
-    });
+  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) {
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
+    if (options.follow) {
+      await followRunMessages(id, apiKey, apiBaseUrl, {
+        startOffset: offset,
+        json: options.json
+      });
+      return;
+    }
+    const limit = parseLimit(options.limit, {
+      defaultValue: DEFAULT_LIMIT9,
+      min: MIN_LIMIT9,
+      max: MAX_LIMIT9
+    });
     const searchParams = new URLSearchParams();
     searchParams.append("limit", String(limit));
     searchParams.append("offset", String(offset));
@@ -15772,7 +16821,7 @@ function registerRunsMessages(runs) {
       console.log("No messages found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS24, response.messages));
+    console.log(renderTable(TABLE_COLUMNS26, 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);
@@ -15806,7 +16855,7 @@ function parseAnswers(raw) {
   return answers;
 }
 __name(parseAnswers, "parseAnswers");
-function buildBody4(options) {
+function buildBody5(options) {
   const approveSet = options.approve === true;
   const denySet = options.deny === true;
   const answers = options.answer ?? [];
@@ -15831,7 +16880,7 @@ function buildBody4(options) {
     "Provide --approve, --deny, or at least one --answer question=answer."
   );
 }
-__name(buildBody4, "buildBody");
+__name(buildBody5, "buildBody");
 async function resolvePendingRequestId(runId, apiKey, apiBaseUrl) {
   const raw = await httpRequest({
     method: "GET",
@@ -15863,7 +16912,7 @@ function registerRunsRespond(runs) {
     collectAnswer,
     []
   ).option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function respondAction(runId, requestIdArg, options) {
-    const body = buildBody4(options);
+    const body = buildBody5(options);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const requestId = requestIdArg ?? await resolvePendingRequestId(runId, apiKey, apiBaseUrl);
     const raw = await httpRequest({
@@ -15941,7 +16990,7 @@ function registerRunsStart(runs) {
   runs.command("start").description("Start a new agent run").requiredOption("--agent <id>", "ID of the agent to run").option(
     "--message <text>",
     "optional initial message to start the run with"
-  ).option("--sandbox-id <id>", "optional sandbox ID with pre-uploaded files").option("--webhook-url <url>", "optional webhook URL to POST run events to").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function startAction(options) {
+  ).option("--sandbox-id <id>", "optional sandbox ID with pre-uploaded files").option("--webhook-url <url>", "optional webhook URL to POST run events to").option("--follow", "stream messages after starting the job").option("--json", "output raw JSON from the API").action(/* @__PURE__ */ __name(async function startAction(options) {
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
     const body = {
       agent_id: options.agent,
@@ -15977,6 +17026,12 @@ function registerRunsStart(runs) {
         { label: "Created", value: run.created_at }
       ])
     );
+    if (options.follow) {
+      console.log("");
+      await followRunMessages(run.id, apiKey, apiBaseUrl, {
+        json: options.json
+      });
+    }
   }, "startAction"));
 }
 __name(registerRunsStart, "registerRunsStart");
@@ -16029,28 +17084,28 @@ function registerRuns(program) {
 __name(registerRuns, "registerRuns");
 
 // src/api/sandbox-schemas.ts
-import { z as z74 } from "zod";
-var createSandboxResponseSchema = z74.object({
-  sandbox_id: z74.string(),
-  expires_at: z74.string()
+import { z as z81 } from "zod";
+var createSandboxResponseSchema = z81.object({
+  sandbox_id: z81.string(),
+  expires_at: z81.string()
 });
-var createSandboxUploadUrlResponseSchema = z74.object({
-  upload_url: z74.string(),
-  path: z74.string(),
-  expires_in_seconds: z74.number()
+var createSandboxUploadUrlResponseSchema = z81.object({
+  upload_url: z81.string(),
+  path: z81.string(),
+  expires_in_seconds: z81.number()
 });
-var sandboxFileSchema = z74.object({
-  name: z74.string(),
-  path: z74.string(),
-  type: z74.enum(["file", "dir"]),
-  size_bytes: z74.number()
+var sandboxFileSchema = z81.object({
+  name: z81.string(),
+  path: z81.string(),
+  type: z81.enum(["file", "dir"]),
+  size_bytes: z81.number()
 });
-var listSandboxFilesResponseSchema = z74.object({
-  files: z74.array(sandboxFileSchema)
+var listSandboxFilesResponseSchema = z81.object({
+  files: z81.array(sandboxFileSchema)
 });
-var uploadSandboxFileResponseSchema = z74.object({
-  path: z74.string(),
-  size_bytes: z74.number()
+var uploadSandboxFileResponseSchema = z81.object({
+  path: z81.string(),
+  size_bytes: z81.number()
 });
 var DEFAULT_SANDBOX_FILES_PATH = "/workspace";
 
@@ -16087,7 +17142,7 @@ function registerSandboxesCreate(sandboxes) {
 __name(registerSandboxesCreate, "registerSandboxesCreate");
 
 // src/commands/sandboxes/files.ts
-var TABLE_COLUMNS25 = [
+var TABLE_COLUMNS27 = [
   { 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") },
@@ -16125,7 +17180,7 @@ function registerSandboxesFiles(sandboxes) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS25, files));
+    console.log(renderTable(TABLE_COLUMNS27, files));
     console.log(`Showing ${files.length}`);
   }, "filesAction"));
 }
@@ -16466,7 +17521,7 @@ function registerSecretsGet(secrets) {
 __name(registerSecretsGet, "registerSecretsGet");
 
 // src/commands/secrets/list.ts
-var TABLE_COLUMNS26 = [
+var TABLE_COLUMNS28 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -16506,7 +17561,7 @@ function registerSecretsList(secrets) {
       console.log("No secrets found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS26, rows));
+    console.log(renderTable(TABLE_COLUMNS28, rows));
     console.log(`Showing ${rows.length}`);
   }, "listAction"));
 }
@@ -16617,7 +17672,7 @@ function registerSecrets(program) {
 __name(registerSecrets, "registerSecrets");
 
 // src/commands/skills/assignments.ts
-var TABLE_COLUMNS27 = [
+var TABLE_COLUMNS29 = [
   { header: "ID", cell: /* @__PURE__ */ __name((row) => row.id, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") }
 ];
@@ -16645,7 +17700,7 @@ function registerSkillsAssignments(skills) {
       console.log("No assignments use this skill.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS27, assignments));
+    console.log(renderTable(TABLE_COLUMNS29, assignments));
     console.log(`Showing ${assignments.length} of ${total}`);
   }, "assignmentsAction"));
 }
@@ -16653,13 +17708,13 @@ __name(registerSkillsAssignments, "registerSkillsAssignments");
 
 // src/commands/skills/create.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { z as z75 } from "zod";
-var createSkillResponseSchema = z75.object({
-  skill: z75.object({
-    id: z75.string(),
-    name: z75.string(),
-    description: z75.string(),
-    team_id: z75.string()
+import { z as z82 } from "zod";
+var createSkillResponseSchema = z82.object({
+  skill: z82.object({
+    id: z82.string(),
+    name: z82.string(),
+    description: z82.string(),
+    team_id: z82.string()
   })
 });
 function registerSkillsCreate(skills) {
@@ -16923,7 +17978,7 @@ function readContent2(options) {
 __name(readContent2, "readContent");
 
 // src/commands/skills/files.ts
-var TABLE_COLUMNS28 = [
+var TABLE_COLUMNS30 = [
   { header: "PATH", cell: /* @__PURE__ */ __name((row) => row.path, "cell") },
   { header: "NAME", cell: /* @__PURE__ */ __name((row) => row.name, "cell") },
   {
@@ -16962,7 +18017,7 @@ function registerSkillsFiles(skills) {
       console.log("No files found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS28, parsed.data.files));
+    console.log(renderTable(TABLE_COLUMNS30, parsed.data.files));
     console.log(`Showing ${parsed.data.files.length}`);
   }, "filesAction"));
 }
@@ -17019,13 +18074,13 @@ function readExistingContent(source) {
 __name(readExistingContent, "readExistingContent");
 
 // src/commands/skills/install.ts
-import { z as z76 } from "zod";
-var installSkillResponseSchema = z76.object({
-  skill: z76.object({
-    id: z76.string(),
-    name: z76.string(),
-    description: z76.string(),
-    team_id: z76.string()
+import { z as z83 } from "zod";
+var installSkillResponseSchema = z83.object({
+  skill: z83.object({
+    id: z83.string(),
+    name: z83.string(),
+    description: z83.string(),
+    team_id: z83.string()
   })
 });
 function registerSkillsInstall(skills) {
@@ -17207,13 +18262,13 @@ __name(registerSkillsSystem, "registerSkillsSystem");
 // src/commands/skills/upload.ts
 import { readFile as readFile6, stat as stat2 } from "node:fs/promises";
 import { basename as basename2 } from "node:path";
-import { z as z77 } from "zod";
-var uploadSkillResponseSchema = z77.object({
-  skill: z77.object({
-    id: z77.string(),
-    name: z77.string(),
-    description: z77.string(),
-    team_id: z77.string()
+import { z as z84 } from "zod";
+var uploadSkillResponseSchema = z84.object({
+  skill: z84.object({
+    id: z84.string(),
+    name: z84.string(),
+    description: z84.string(),
+    team_id: z84.string()
   })
 });
 function registerSkillsUpload(skills) {
@@ -17284,8 +18339,8 @@ function registerSkills(program) {
 __name(registerSkills, "registerSkills");
 
 // src/commands/team/render-team.ts
-import { z as z78 } from "zod";
-var teamResponseSchema = z78.object({
+import { z as z85 } from "zod";
+var teamResponseSchema = z85.object({
   team: teamApiSchema
 });
 function renderTeam(team) {
@@ -17382,10 +18437,10 @@ function registerTeamGet(team) {
 __name(registerTeamGet, "registerTeamGet");
 
 // src/commands/team/members.ts
-var DEFAULT_LIMIT8 = 50;
-var MIN_LIMIT8 = 1;
-var MAX_LIMIT8 = 100;
-var TABLE_COLUMNS29 = [
+var DEFAULT_LIMIT10 = 50;
+var MIN_LIMIT10 = 1;
+var MAX_LIMIT10 = 100;
+var TABLE_COLUMNS31 = [
   { 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") },
@@ -17399,11 +18454,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_LIMIT8}-${MAX_LIMIT8})`).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_LIMIT10}-${MAX_LIMIT10})`).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_LIMIT8,
-      min: MIN_LIMIT8,
-      max: MAX_LIMIT8
+      defaultValue: DEFAULT_LIMIT10,
+      min: MIN_LIMIT10,
+      max: MAX_LIMIT10
     });
     const offset = parseOffset(options.offset);
     const { apiKey, apiBaseUrl } = await requireAuthenticatedConfig(this);
@@ -17433,7 +18488,7 @@ function registerTeamMembers(team) {
       console.log("No members found.");
       return;
     }
-    console.log(renderTable(TABLE_COLUMNS29, response.members));
+    console.log(renderTable(TABLE_COLUMNS31, response.members));
     console.log(
       `Showing ${response.members.length} of ${response.total} \xB7 offset ${response.offset}`
     );
@@ -17500,7 +18555,7 @@ __name(fetchProfileSummary, "fetchProfileSummary");
 var version = resolveVersion();
 function resolveVersion() {
   if (true) {
-    return "0.6.0";
+    return "0.7.0";
   }
   const packageJsonPath = join2(
     dirname2(fileURLToPath(import.meta.url)),
@@ -17541,6 +18596,7 @@ function createProgram() {
   registerCredentials(program);
   registerRevisionSecrets(program);
   registerRevisionLogins(program);
+  registerClarity(program);
   return program;
 }
 __name(createProgram, "createProgram");
@@ -17564,7 +18620,7 @@ function checkForUpdate() {
 __name(checkForUpdate, "checkForUpdate");
 function loadPackageMeta() {
   if (true) {
-    return { name: "@duvoai/cli", version: "0.6.0" };
+    return { name: "@duvoai/cli", version: "0.7.0" };
   }
   const require2 = createRequire(import.meta.url);
   const raw = require2("../package.json");