omnara 1.0.24 → 1.0.26

package/dist/bin.js

@@ -89,7 +89,7 @@ var zAgentId = z.string().regex(/^agt_[a-z2-7]{26}$/);
 var zAgentConfigId = z.string().regex(/^acfg_[a-z2-7]{26}$/);
 var zAgentProfileId = z.string().regex(/^aprf_[a-z2-7]{26}$/);
 var zCronTriggerId = z.string().regex(/^cron_[a-z2-7]{26}$/);
-var zIntegrationInstallId = z.string().regex(/^iin_[a-z2-7]{26}$/);
+var zIntegrationTargetId = z.string().regex(/^itgt_[a-z2-7]{26}$/);
 var zAgentEventId = z.string().regex(/^evt_[a-z2-7]{26}$/);
 var zModelCallContextId = z.string().regex(/^mcc_[a-z2-7]{26}$/);
 var zAgentInputId = z.string().regex(/^ain_[a-z2-7]{26}$/);
@@ -506,40 +506,40 @@ var zMcpoAuthStartResponse = z.object({
   expires_at: zTimestamp
 });
 var zCreateIntegrationOAuthSetupRequest = z.object({
-  provider: z.string().optional().default("slack"),
   client_id: z.string().min(1),
   client_secret: z.string().min(1),
   signing_secret: z.string().min(1),
   return_to: z.string().optional()
 });
-var zIntegrationInstall = z.object({
-  id: zIntegrationInstallId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  agent_profile_id: zAgentProfileId.optional(),
-  agent_id: zAgentId.optional(),
-  provider: z.string(),
-  integration_kind: z.string(),
-  connection_mode: z.string(),
-  state: z.enum(["active", "disabled"]),
-  provider_tenant_id: z.string(),
-  provider_account_ref: z.string(),
-  provider_agent_display_name: z.string(),
-  created_at: zTimestamp,
-  updated_at: zTimestamp
+var zIntegrationKind = z.enum([
+  "slack_thread",
+  "discord_thread",
+  "github_pr"
+]);
+var zIntegrationProviderDisplayName = z.string().max(512);
+var zIntegrationProviderConfig = z.record(z.string(), z.unknown());
+var zCreateGitHubSetupRequest = z.object({
+  expected_setup_revision: z.int().gte(1),
+  app_name: z.string().min(1).max(34).optional(),
+  organization: z.string().min(1).max(39).regex(/^[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/).optional()
+});
+var zInspectGitHubInstallationsRequest = z.object({
+  credential_secret_id: zSecretId,
+  page: z.int().gte(1).lte(1e3).optional().default(1)
 });
-var zListIntegrationInstallsResponse = z.object({
-  data: z.array(zIntegrationInstall),
-  next_cursor: z.string().nullable()
+var zGitHubSetupInstallation = z.object({
+  id: z.string().regex(/^[1-9][0-9]*$/),
+  account: z.string(),
+  account_type: z.string().optional(),
+  settings_url: z.url()
 });
-var zIntegrationOAuthSetup = z.object({
-  provider: z.string(),
-  flow_id: zIntegrationOAuthFlowId,
-  oauth_url: z.url(),
-  redirect_uri: z.url(),
-  events_url: z.url(),
-  actions_url: z.url(),
-  expires_at: zTimestamp
+var zGitHubInstallations = z.object({
+  provider_app_id: z.string().regex(/^[1-9][0-9]*$/),
+  name: z.string(),
+  slug: z.string(),
+  install_url: z.url(),
+  installations: z.array(zGitHubSetupInstallation),
+  next_page: z.int().gte(1).lte(1e3).optional()
 });
 var zSlackSetupIcon = z.object({
   filename: z.string().optional(),
@@ -551,16 +551,6 @@ var zCreateSlackSetupRequest = z.object({
   icon: zSlackSetupIcon.optional(),
   return_to: z.string().optional()
 });
-var zSlackSetup = z.object({
-  provider: z.string(),
-  flow_id: zIntegrationOAuthFlowId,
-  slack_app_id: z.string(),
-  oauth_url: z.url(),
-  redirect_uri: z.url(),
-  events_url: z.url(),
-  actions_url: z.url(),
-  expires_at: zTimestamp
-});
 var zResolveAgentConfigToolsRequest = z.object({
   source: z.string().min(1),
   source_format: z.enum(["yaml", "json"])
@@ -758,14 +748,6 @@ var zCompiledMachineSource = z.object({
   machine_provider_options_overlay: z.record(z.string(), z.unknown()).optional(),
   description: z.string().optional()
 });
-var zCompiledTool = z.object({
-  enabled: z.boolean(),
-  type: z.enum(["built_in", "custom"]).optional(),
-  permission: zToolPermissionSelection,
-  deferred: z.boolean().optional(),
-  description: z.string().optional(),
-  input_schema: z.record(z.string(), z.unknown()).optional()
-});
 var zCompiledMcpAuthBearer = z.object({
   type: z.enum(["bearer"]),
   secret_id: zSecretId
@@ -833,20 +815,6 @@ var zCompiledSubagent = z.discriminatedUnion("type", [
   zCompiledSelfSubagent.extend({ type: z.literal("self") }),
   zCompiledProfileSubagent.extend({ type: z.literal("profile") })
 ]);
-var zCompiledAgentConfig = z.object({
-  version: z.string().optional(),
-  instruction: z.string(),
-  model: zCompiledAgentModel,
-  machine_sources: z.array(zCompiledMachineSource).optional(),
-  tools: z.record(z.string(), zCompiledTool).optional(),
-  mcp: z.record(z.string(), zCompiledMcpServer).optional(),
-  event_webhook: zCompiledEventWebhook.optional(),
-  skills: z.array(zCompiledSkill).optional(),
-  memory_stores: z.array(zCompiledMemoryStore).optional(),
-  subagents: z.record(z.string(), zCompiledSubagent).optional(),
-  max_subagents: z.int().optional(),
-  max_depth: z.int().optional()
-});
 var zAgentConfigSummary = z.object({
   id: zAgentConfigId,
   org_id: zOrganizationId,
@@ -858,18 +826,6 @@ var zAgentConfigSummary = z.object({
   instruction_hash: z.string().optional(),
   created_at: zTimestamp
 });
-var zAgentConfig = z.object({
-  id: zAgentConfigId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  source: z.string().optional(),
-  source_format: z.enum(["yaml", "json"]).optional(),
-  effective_definition_hash: z.string(),
-  model: zAgentConfigModel,
-  instruction_hash: z.string().optional(),
-  created_at: zTimestamp,
-  compiled_definition: zCompiledAgentConfig
-});
 var zCreateAgentProfileRequest = z.object({
   name: zResourceName,
   config: zAgentConfigId
@@ -881,32 +837,6 @@ var zUpdateAgentProfileRequest = z.object({
 var zRenameAgentProfileRequest = z.object({
   name: zResourceName
 });
-var zAgentProfileSummary = z.object({
-  id: zAgentProfileId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  name: zResourceName,
-  current_config_id: zAgentConfigId,
-  current_generation: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  created_at: zTimestamp,
-  updated_at: zTimestamp,
-  current_config: zAgentConfigSummary
-});
-var zAgentProfile = z.object({
-  id: zAgentProfileId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  name: zResourceName,
-  current_config_id: zAgentConfigId,
-  current_generation: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  created_at: zTimestamp,
-  updated_at: zTimestamp,
-  current_config: zAgentConfig
-});
-var zListAgentProfilesResponse = z.object({
-  data: z.array(zAgentProfileSummary),
-  next_cursor: z.string().nullable()
-});
 var zAgentProfileCronTriggerTarget = z.object({
   type: z.enum(["profile"]),
   agent_profile_id: zAgentProfileId
@@ -920,56 +850,22 @@ var zAgentCronTriggerTarget = z.object({
   agent_id: zAgentId,
   delivery_mode: zCronTriggerDeliveryMode.optional()
 });
-var zCronTriggerTarget = z.discriminatedUnion("type", [
-  zAgentCronTriggerTarget.extend({ type: z.literal("agent") }),
-  zAgentProfileCronTriggerTarget.extend({ type: z.literal("profile") })
-]);
 var zCronTriggerFailureReport = z.object({
   message: z.string(),
   will_retry: z.boolean(),
   failed_at: zTimestamp
 });
-var zCreateCronTriggerRequest = z.object({
-  name: zResourceName,
-  target: zCronTriggerTarget,
-  cron: zCronExpression,
-  timezone: zCronTimezone.optional(),
-  message_template: zCronMessageTemplate,
-  enabled: z.boolean().optional().default(true)
-});
-var zUpdateCronTriggerRequest = z.object({
-  target: zCronTriggerTarget.optional(),
-  name: zResourceName.optional(),
-  cron: zCronExpression.optional(),
-  timezone: zCronTimezone.optional(),
-  message_template: zCronMessageTemplate.optional(),
-  enabled: z.boolean().optional()
-});
-var zCronTrigger = z.object({
-  id: zCronTriggerId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  name: zResourceName,
-  target: zCronTriggerTarget,
-  cron: zCronExpression,
-  timezone: zCronTimezone,
-  message_template: zCronMessageTemplate,
-  enabled: z.boolean(),
-  last_fired_at: zTimestamp.nullable(),
-  next_fire_at: zTimestamp.nullable(),
-  failure_report: zCronTriggerFailureReport.nullable(),
+var zCronTriggerLastRunState = z.enum([
+  "queued",
+  "processing",
+  "completed",
+  "failed"
+]);
+var zCronTriggerLastRun = z.object({
+  state: zCronTriggerLastRunState,
   created_at: zTimestamp,
-  updated_at: zTimestamp
-});
-var zListCronTriggersResponse = z.object({
-  data: z.array(zCronTrigger),
-  next_cursor: z.string().nullable()
-});
-var zCreateAgentRequest = z.object({
-  profile: zAgentProfileId.optional(),
-  config: zAgentConfigId,
-  name: zAgentName.optional(),
-  message: z.string().optional()
+  updated_at: zTimestamp,
+  failure_message: z.string().nullable()
 });
 var zAgentActivity = z.object({
   state: z.enum([
@@ -984,30 +880,6 @@ var zAgentModel = z.object({
   provider_config: zResourceName,
   name: zResourceName
 });
-var zIntegrationTarget = z.object({
-  provider: z.string(),
-  provider_ref: z.string(),
-  provider_ref_kind: z.string(),
-  display_name: z.string(),
-  provider_uri: z.url().optional()
-});
-var zAgent = z.object({
-  id: zAgentId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  agent_profile_id: zAgentProfileId.optional(),
-  state: z.enum(["active", "archived"]),
-  name: zAgentName,
-  integration_target: zIntegrationTarget.optional(),
-  current_config_id: zAgentConfigId.optional(),
-  model: zAgentModel.optional(),
-  parent_agent_id: zAgentId.optional(),
-  subagent_key: z.string().optional(),
-  activity: zAgentActivity.optional(),
-  created_at: zTimestamp,
-  updated_at: zTimestamp,
-  archived_at: zTimestamp.optional()
-});
 var zAgentMcpConnection = z.object({
   server_key: z.string(),
   endpoint_url: z.string(),
@@ -1022,18 +894,6 @@ var zAgentMcpConnection = z.object({
   created_at: zTimestamp,
   updated_at: zTimestamp
 });
-var zCurrentAgentResponse = z.object({
-  agent: zAgent
-});
-var zGetAgentResponse = z.object({
-  agent: zAgent,
-  machine_ids: z.array(zMachineId),
-  mcp_connections: z.array(zAgentMcpConnection)
-});
-var zListAgentsResponse = z.object({
-  data: z.array(zAgent),
-  next_cursor: z.string().nullable()
-});
 var zAgentInputKind = z.enum([
   "content",
   "control",
@@ -1188,17 +1048,6 @@ var zAgentInput = z.object({
   content_blocks: z.array(zAgentInputContentBlock).optional(),
   queued_at: zTimestamp
 });
-var zLaunchAgentResponse = z.object({
-  agent: zAgent,
-  agent_config: zAgentConfig,
-  machine_bindings: z.array(zAgentMachineBinding),
-  agent_input: zAgentInput.optional()
-});
-var zUpdateAgentConfigResponse = z.object({
-  agent_config: zAgentConfig,
-  agent_input: zAgentInput,
-  event_id: zAgentEventId
-});
 var zMachineMetadata = z.record(z.string(), z.string().max(512));
 var zAgentInputEnvelope = z.object({
   agent_input: zAgentInput
@@ -1250,11 +1099,6 @@ var zToolCall = z.object({
   completed_at: zTimestamp.optional(),
   created_at: zTimestamp
 });
-var zToolCallUpdate = z.object({
-  tool_call_id: zToolCallId,
-  agent_id: zAgentId.optional(),
-  state: zToolCallState
-});
 var zListToolCallsResponse = z.object({
   data: z.array(zToolCall),
   next_cursor: z.string().nullable()
@@ -1337,10 +1181,6 @@ var zEventWebhookContextCheckpointEvent = z.object({
   event: z.enum(["context_checkpoint"]),
   data: zContextCheckpointEvent
 });
-var zEventWebhookToolCallUpdate = z.object({
-  event: z.enum(["tool_call_update"]),
-  data: zToolCallUpdate
-});
 var zModelOutputTextStreamBlock = z.object({
   kind: z.enum(["text"])
 });
@@ -1410,13 +1250,6 @@ var zEventWebhookModelOutputEvent = z.object({
   event: z.enum(["model_output"]),
   data: zModelOutputEvent
 });
-var zEventWebhookPayload = z.discriminatedUnion("event", [
-  zEventWebhookAgentInputEvent.extend({ event: z.literal("agent_input") }),
-  zEventWebhookModelOutputEvent.extend({ event: z.literal("model_output") }),
-  zEventWebhookToolResultEvent.extend({ event: z.literal("tool_result") }),
-  zEventWebhookContextCheckpointEvent.extend({ event: z.literal("context_checkpoint") }),
-  zEventWebhookToolCallUpdate.extend({ event: z.literal("tool_call_update") })
-]);
 var zAgentEvent = z.discriminatedUnion("event_kind", [
   zAgentInputEvent.extend({ event_kind: z.literal("agent_input") }),
   zModelOutputEvent.extend({ event_kind: z.literal("model_output") }),
@@ -1454,12 +1287,6 @@ var zModelOutputDelta = z.object({
   coalesced_count: zAgentCount,
   event: zModelOutputStreamDelta
 });
-var zAgentEventStreamData = z.union([
-  zAgentEvent,
-  zToolCallUpdate,
-  zModelOutputDelta,
-  zError
-]);
 var zListAgentEventsResponse = z.object({
   data: z.array(zAgentEvent),
   next_after_sequence: zAgentSequenceCursor,
@@ -1541,26 +1368,38 @@ var zAgentInteractionState = z.enum([
   "resolved",
   "canceled"
 ]);
-var zAgentInteraction = z.object({
+var zAgentInteractionUpdate = z.object({
   id: zAgentInteractionId,
-  org_id: zOrganizationId,
-  project_id: zProjectId,
-  agent_id: zAgentId,
-  tool_call_id: zToolCallId,
-  tool_name: z.string().optional(),
-  agent_name: zAgentName.optional(),
-  subagent_key: z.string().optional(),
   interaction_kind: zAgentInteractionKind,
-  state: zAgentInteractionState,
-  request: zInteractionForm,
-  resolution: zInteractionResolution.optional(),
-  resolved_by_input_id: zAgentInputId.optional(),
-  created_at: zTimestamp,
-  resolved_at: zTimestamp.optional()
+  state: zAgentInteractionState
+});
+var zToolCallUpdate = z.object({
+  tool_call_id: zToolCallId,
+  agent_id: zAgentId.optional(),
+  state: zToolCallState,
+  interaction_update: zAgentInteractionUpdate.optional()
+});
+var zEventWebhookToolCallUpdate = z.object({
+  event: z.enum(["tool_call_update"]),
+  data: zToolCallUpdate
 });
+var zEventWebhookPayload = z.discriminatedUnion("event", [
+  zEventWebhookAgentInputEvent.extend({ event: z.literal("agent_input") }),
+  zEventWebhookModelOutputEvent.extend({ event: z.literal("model_output") }),
+  zEventWebhookToolResultEvent.extend({ event: z.literal("tool_result") }),
+  zEventWebhookContextCheckpointEvent.extend({ event: z.literal("context_checkpoint") }),
+  zEventWebhookToolCallUpdate.extend({ event: z.literal("tool_call_update") })
+]);
+var zAgentEventStreamData = z.union([
+  zAgentEvent,
+  zToolCallUpdate,
+  zModelOutputDelta,
+  zError
+]);
+var zInteractionPresentationReceipt = z.record(z.string(), z.unknown());
 var zActorProvider = z.enum([
   "omnara",
-  "slack",
+  "integration",
   "external"
 ]);
 var zActor = z.object({
@@ -1581,6 +1420,10 @@ var zExternalActorParams = z.object({
   display_name: z.string().max(256).optional(),
   metadata: zMetadata.optional()
 });
+var zAgentLaunchInitialInput = z.object({
+  content_blocks: z.array(zTextContentBlock).min(1),
+  actor: zExternalActorParams.optional()
+});
 var zCreateAgentInputRequest = z.object({
   content_blocks: z.array(zCreateAgentInputContentBlock),
   delivery_mode: zCreateAgentInputDeliveryMode.optional(),
@@ -1598,10 +1441,6 @@ var zListActorsResponse = z.object({
   data: z.array(zActor),
   next_cursor: z.string().nullable()
 });
-var zListAgentInteractionsResponse = z.object({
-  data: z.array(zAgentInteraction),
-  next_cursor: z.string().nullable()
-});
 var zOrgSecretOwnerInput = z.object({
   kind: z.enum(["org"])
 });
@@ -1672,10 +1511,17 @@ var zAwsCredentialsSecretMaterial = z.object({
   role_arn: z.string().min(1).optional(),
   external_id: z.string().min(1).optional()
 });
+var zGitHubAppCredentialsSecretMaterial = z.object({
+  kind: z.enum(["github_app_credentials"]),
+  app_id: z.string().regex(/^[1-9][0-9]*$/),
+  private_key: z.string().min(1),
+  webhook_secret: z.string().min(1)
+});
 var zSecretMaterial = z.discriminatedUnion("kind", [
   zGenericSecretMaterial.extend({ kind: z.literal("generic") }),
   zOAuthTokenSetSecretMaterial.extend({ kind: z.literal("oauth_token_set") }),
-  zAwsCredentialsSecretMaterial.extend({ kind: z.literal("aws_credentials") })
+  zAwsCredentialsSecretMaterial.extend({ kind: z.literal("aws_credentials") }),
+  zGitHubAppCredentialsSecretMaterial.extend({ kind: z.literal("github_app_credentials") })
 ]);
 var zCreateSecretRequest = z.object({
   owner: zSecretOwnerInput,
@@ -1697,7 +1543,8 @@ var zSecretKind = z.enum([
   "generic",
   "oauth_token_set",
   "slack_app_credentials",
-  "aws_credentials"
+  "aws_credentials",
+  "github_app_credentials"
 ]);
 var zSecret = z.object({
   id: zSecretId,
@@ -1871,7 +1718,11 @@ var zCreateMachinePoolRequest = zCreateMachinePoolRequestBase.and(z.union([
     max_machine_memory_mb: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
   }),
   z.object({
-    provider: z.enum(["daytona"]),
+    provider: z.enum([
+      "daytona",
+      "boxd",
+      "createos"
+    ]),
     max_total_cpu: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
     max_total_memory_mb: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
     max_machine_cpu: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -2320,22 +2171,43 @@ var zListProjectsResponse = z.object({
   data: z.array(zVisibleProject),
   next_cursor: z.string().nullable()
 });
+var zOrgOverviewProjectActivity = z.object({
+  project_id: zProjectId,
+  last_active_at: zTimestamp
+});
 var zOrgOverviewAgentProfileReference = z.object({
   id: zAgentProfileId,
   name: zResourceName,
   agent_count: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" })
 });
-var zOrgOverviewToday = z.object({
-  agents_created: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }),
-  messages_sent: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" })
-});
-var zOrgOverviewUsageDayModel = z.object({
-  id: zConfiguredModelId,
-  tokens: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" })
-});
-var zOrgOverviewUsageDayProfile = z.object({
-  id: zAgentProfileId.optional(),
-  tokens: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" })
+var zUsageTimeseriesInterval = z.enum([
+  "hour",
+  "day",
+  "week",
+  "month"
+]);
+var zUsageTimeseriesMetric = z.enum([
+  "sum_tokens",
+  "sum_input_tokens",
+  "sum_output_tokens",
+  "sum_cost",
+  "count_model_calls"
+]);
+var zUsageTimeseriesGroupBy = z.enum(["model", "profile"]);
+var zUsageTimeseriesSeries = z.object({
+  kind: z.enum([
+    "all",
+    "model",
+    "profile",
+    "no_profile",
+    "other"
+  ]),
+  id: z.string().optional(),
+  name: zResourceName.optional(),
+  model_provider_config_name: zResourceName.optional(),
+  project_name: zResourceName.optional(),
+  total: z.number().gte(0),
+  values: z.array(z.number().gte(0))
 });
 var zUsageTokenTotals = z.object({
   input_tokens_total: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }),
@@ -2354,36 +2226,36 @@ var zUsageTotals = z.object({
   tokens: zUsageTokenTotals,
   cost: zUsageCostTotals
 });
-var zOrgOverviewUsageModel = z.object({
-  id: zConfiguredModelId,
-  name: zResourceName,
-  totals: zUsageTotals
-});
-var zOrgOverviewUsageProfile = z.object({
-  id: zAgentProfileId.optional(),
-  name: zResourceName.optional(),
-  totals: zUsageTotals
+var zAgentProfileStats = z.object({
+  agent_count: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }),
+  usage: zUsageTotals
 });
-var zOrgOverviewUsageDay = z.object({
-  start: zTimestamp,
-  totals: zUsageTotals,
-  models: z.array(zOrgOverviewUsageDayModel),
-  profiles: z.array(zOrgOverviewUsageDayProfile)
+var zAgentProfileSummary = z.object({
+  id: zAgentProfileId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  name: zResourceName,
+  current_config_id: zAgentConfigId,
+  current_generation: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  created_at: zTimestamp,
+  updated_at: zTimestamp,
+  current_config: zAgentConfigSummary,
+  stats: zAgentProfileStats.optional()
 });
-var zOrgOverviewUsage = z.object({
+var zListAgentProfilesResponse = z.object({
+  data: z.array(zAgentProfileSummary),
+  next_cursor: z.string().nullable()
+});
+var zUsageTimeseries = z.object({
+  metric: zUsageTimeseriesMetric,
+  interval: zUsageTimeseriesInterval,
+  group_by: zUsageTimeseriesGroupBy.optional(),
+  timezone: z.string(),
+  bucket_starts: z.array(zTimestamp),
+  until: zTimestamp,
   totals: zUsageTotals,
   active_agents: z.coerce.bigint().gte(BigInt(0)).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" }),
-  models: z.array(zOrgOverviewUsageModel),
-  profiles: z.array(zOrgOverviewUsageProfile),
-  days: z.array(zOrgOverviewUsageDay)
-});
-var zOrgOverviewResponse = z.object({
-  projects: z.array(zVisibleProject),
-  recent_agents: z.array(zAgent),
-  recent_agent_profiles: z.array(zAgentProfileSummary),
-  referenced_agent_profiles: z.array(zOrgOverviewAgentProfileReference),
-  today: zOrgOverviewToday,
-  usage: zOrgOverviewUsage
+  series: z.array(zUsageTimeseriesSeries)
 });
 var zUsageModel = z.object({
   configured_model_id: zConfiguredModelId,
@@ -2450,6 +2322,346 @@ var zProjectMembershipGrant = z.object({
 var zListProjectMembershipGrantsResponse = z.object({
   data: z.array(zProjectMembershipGrant)
 });
+var zIntegrationId = z.string().regex(/^itg_[a-z2-7]{26}$/);
+var zIntegrationOAuthSetup = z.object({
+  integration_id: zIntegrationId,
+  setup_revision: z.int().gte(1),
+  provider: z.string(),
+  flow_id: zIntegrationOAuthFlowId,
+  oauth_url: z.url(),
+  redirect_uri: z.url(),
+  events_url: z.url(),
+  actions_url: z.url(),
+  expires_at: zTimestamp
+});
+var zGitHubSetup = z.object({
+  integration_id: zIntegrationId,
+  setup_revision: z.int().gte(1),
+  registration_url: z.url(),
+  manifest: z.record(z.string(), z.unknown()),
+  expires_at: zTimestamp
+});
+var zSlackSetup = z.object({
+  integration_id: zIntegrationId,
+  setup_revision: z.int().gte(1),
+  provider: z.string(),
+  flow_id: zIntegrationOAuthFlowId,
+  slack_app_id: z.string(),
+  oauth_url: z.url(),
+  redirect_uri: z.url(),
+  events_url: z.url(),
+  actions_url: z.url(),
+  expires_at: zTimestamp
+});
+var zCompiledTool = z.object({
+  integration_id: zIntegrationId.optional(),
+  enabled: z.boolean(),
+  type: z.enum(["built_in", "custom"]).optional(),
+  permission: zToolPermissionSelection,
+  deferred: z.boolean().optional(),
+  description: z.string().optional(),
+  input_schema: z.record(z.string(), z.unknown()).optional()
+});
+var zCompiledIntegrationCapability = z.object({
+  integration_id: zIntegrationId
+});
+var zIntegrationCronTriggerTarget = z.object({
+  type: z.enum(["integration"]),
+  integration_id: zIntegrationId,
+  settings: z.record(z.string(), z.unknown())
+});
+var zCronTriggerTarget = z.discriminatedUnion("type", [
+  zAgentCronTriggerTarget.extend({ type: z.literal("agent") }),
+  zAgentProfileCronTriggerTarget.extend({ type: z.literal("profile") }),
+  zIntegrationCronTriggerTarget.extend({ type: z.literal("integration") })
+]);
+var zCreateCronTriggerRequest = z.object({
+  name: zResourceName,
+  target: zCronTriggerTarget,
+  cron: zCronExpression,
+  timezone: zCronTimezone.optional(),
+  message_template: zCronMessageTemplate.optional(),
+  enabled: z.boolean().optional().default(true)
+});
+var zUpdateCronTriggerRequest = z.object({
+  target: zCronTriggerTarget.optional(),
+  name: zResourceName.optional(),
+  cron: zCronExpression.optional(),
+  timezone: zCronTimezone.optional(),
+  message_template: zCronMessageTemplate.optional(),
+  enabled: z.boolean().optional()
+});
+var zCronTrigger = z.object({
+  id: zCronTriggerId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  name: zResourceName,
+  target: zCronTriggerTarget,
+  cron: zCronExpression,
+  timezone: zCronTimezone,
+  message_template: zCronMessageTemplate.optional(),
+  enabled: z.boolean(),
+  last_fired_at: zTimestamp.nullable(),
+  next_fire_at: zTimestamp.nullable(),
+  failure_report: zCronTriggerFailureReport.nullable(),
+  last_run: zCronTriggerLastRun.nullable(),
+  created_at: zTimestamp,
+  updated_at: zTimestamp
+});
+var zListCronTriggersResponse = z.object({
+  data: z.array(zCronTrigger),
+  next_cursor: z.string().nullable()
+});
+var zIntegrationSettings = z.record(z.string(), z.unknown());
+var zUpdateIntegrationRequest = z.object({
+  settings: zIntegrationSettings
+});
+var zIntegrationRuntimeFailure = z.object({
+  message: z.string(),
+  retry_at: zTimestamp
+});
+var zConfigAgentToolInputSchema = z.object({
+  properties: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+  required: z.array(z.string().min(1)).optional(),
+  type: z.literal("object")
+});
+var zConfigIntegrationCapabilitySource = z.record(z.string(), z.never());
+var zConfigToolPermissionSelection = z.object({
+  mode: z.string().min(1).regex(/\S/),
+  parameters: z.record(z.string(), z.unknown()).optional()
+});
+var zConfigToolSource = z.object({
+  deferred: z.boolean().optional(),
+  description: z.string().min(1).optional(),
+  enabled: z.boolean().nullish(),
+  input_schema: zConfigAgentToolInputSchema.optional(),
+  permission: zConfigToolPermissionSelection.optional(),
+  type: z.enum(["built_in", "custom"]).optional()
+});
+var zIntegrationName = z.string().regex(/^[a-zA-Z][a-zA-Z0-9-]{0,31}$/);
+var zCompiledGitCredentials = z.object({
+  integration: zIntegrationName,
+  integration_id: zIntegrationId
+});
+var zCompiledAgentConfig = z.object({
+  version: z.string().optional(),
+  instruction: z.string(),
+  model: zCompiledAgentModel,
+  machine_sources: z.array(zCompiledMachineSource).optional(),
+  tools: z.record(z.string(), zCompiledTool).optional(),
+  mcp: z.record(z.string(), zCompiledMcpServer).optional(),
+  event_webhook: zCompiledEventWebhook.optional(),
+  interaction_handlers: z.record(z.string(), zCompiledIntegrationCapability).optional(),
+  git_credentials: zCompiledGitCredentials.optional(),
+  skills: z.array(zCompiledSkill).optional(),
+  memory_stores: z.array(zCompiledMemoryStore).optional(),
+  subagents: z.record(z.string(), zCompiledSubagent).optional(),
+  max_subagents: z.int().optional(),
+  max_depth: z.int().optional()
+});
+var zAgentConfig = z.object({
+  id: zAgentConfigId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  source: z.string().optional(),
+  source_format: z.enum(["yaml", "json"]).optional(),
+  effective_definition_hash: z.string(),
+  model: zAgentConfigModel,
+  instruction_hash: z.string().optional(),
+  created_at: zTimestamp,
+  compiled_definition: zCompiledAgentConfig
+});
+var zAgentProfile = z.object({
+  id: zAgentProfileId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  name: zResourceName,
+  current_config_id: zAgentConfigId,
+  current_generation: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  created_at: zTimestamp,
+  updated_at: zTimestamp,
+  current_config: zAgentConfig
+});
+var zUpdateAgentConfigResponse = z.object({
+  agent_config: zAgentConfig,
+  agent_input: zAgentInput,
+  event_id: zAgentEventId
+});
+var zCreateIntegrationRequest = z.object({
+  name: zIntegrationName,
+  integration_kind: zIntegrationKind,
+  settings: zIntegrationSettings
+});
+var zIntegrationState = z.enum(["active", "disconnected"]);
+var zConfigureIntegrationRequest = z.object({
+  expected_setup_revision: z.int().gte(1),
+  provider_tenant_id: z.string().min(1).max(512),
+  provider_account_ref: z.string().min(1).max(512).optional(),
+  provider_agent_display_name: zIntegrationProviderDisplayName.optional(),
+  credential_secret_id: zSecretId,
+  provider_config: zIntegrationProviderConfig.optional()
+});
+var zIntegrationCapabilityDefinition = z.object({
+  description: z.string().optional(),
+  input_schema: z.record(z.string(), z.unknown())
+});
+var zIntegrationSubscriptionId = z.string().regex(/^isub_[a-z2-7]{26}$/);
+var zIntegrationConversation = z.record(z.string(), z.unknown());
+var zIntegrationTarget = z.object({
+  provider: z.string(),
+  conversation: zIntegrationConversation,
+  display_name: z.string(),
+  provider_uri: z.url().optional()
+});
+var zAgent = z.object({
+  id: zAgentId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  agent_profile_id: zAgentProfileId.optional(),
+  state: z.enum(["active", "archived"]),
+  name: zAgentName,
+  integration_target: zIntegrationTarget.optional(),
+  current_config_id: zAgentConfigId.optional(),
+  model: zAgentModel.optional(),
+  parent_agent_id: zAgentId.optional(),
+  subagent_key: z.string().optional(),
+  activity: zAgentActivity.optional(),
+  usage: zUsageTotals.optional(),
+  created_at: zTimestamp,
+  updated_at: zTimestamp,
+  archived_at: zTimestamp.optional()
+});
+var zCurrentAgentResponse = z.object({
+  agent: zAgent
+});
+var zGetAgentResponse = z.object({
+  agent: zAgent,
+  machine_ids: z.array(zMachineId),
+  mcp_connections: z.array(zAgentMcpConnection)
+});
+var zListAgentsResponse = z.object({
+  data: z.array(zAgent),
+  next_cursor: z.string().nullable()
+});
+var zLaunchAgentResponse = z.object({
+  agent: zAgent,
+  agent_config: zAgentConfig,
+  machine_bindings: z.array(zAgentMachineBinding),
+  agent_input: zAgentInput.optional()
+});
+var zAgentInteractionDestination = z.object({
+  integration_kind: zIntegrationKind,
+  handler_key: z.string(),
+  integration_id: zIntegrationId,
+  integration_target_id: zIntegrationTargetId,
+  conversation: zIntegrationConversation
+});
+var zAgentInteraction = z.object({
+  id: zAgentInteractionId,
+  org_id: zOrganizationId,
+  project_id: zProjectId,
+  agent_id: zAgentId,
+  tool_call_id: zToolCallId,
+  tool_name: z.string().optional(),
+  agent_name: zAgentName.optional(),
+  subagent_key: z.string().optional(),
+  interaction_kind: zAgentInteractionKind,
+  state: zAgentInteractionState,
+  request: zInteractionForm,
+  resolution: zInteractionResolution.optional(),
+  destination: zAgentInteractionDestination.optional(),
+  presentation_receipt: zInteractionPresentationReceipt.optional(),
+  resolved_by_input_id: zAgentInputId.optional(),
+  created_at: zTimestamp,
+  resolved_at: zTimestamp.optional()
+});
+var zListAgentInteractionsResponse = z.object({
+  data: z.array(zAgentInteraction),
+  next_cursor: z.string().nullable()
+});
+var zOrgOverviewResponse = z.object({
+  projects: z.array(zVisibleProject),
+  project_activity: z.array(zOrgOverviewProjectActivity),
+  recent_agents: z.array(zAgent),
+  recent_agent_profiles: z.array(zAgentProfileSummary),
+  referenced_agent_profiles: z.array(zOrgOverviewAgentProfileReference)
+});
+var zIntegrationSubscriptionAttachment = z.object({
+  integration_id: zIntegrationId,
+  conversation: zIntegrationConversation
+});
+var zCreateAgentRequest = z.object({
+  profile: zAgentProfileId.optional(),
+  config: zAgentConfigId,
+  name: zAgentName.optional(),
+  message: z.string().optional(),
+  tools: z.record(z.string(), zConfigToolSource).optional(),
+  subscriptions: z.array(zIntegrationSubscriptionAttachment).max(100).optional(),
+  interaction_handlers: z.record(z.string(), zConfigIntegrationCapabilitySource).optional(),
+  initial_input: zAgentLaunchInitialInput.optional()
+});
+var zCreateIntegrationSubscriptionRequest = z.object({
+  agent_id: zAgentId,
+  conversation: zIntegrationConversation
+});
+var zIntegrationSubscription = z.object({
+  id: zIntegrationSubscriptionId,
+  project_id: zProjectId,
+  integration_id: zIntegrationId,
+  agent_id: zAgentId,
+  agent_name: zAgentName,
+  conversation: zIntegrationConversation,
+  conversation_name: z.string().optional(),
+  created_at: zTimestamp
+});
+var zListIntegrationSubscriptionsResponse = z.object({
+  data: z.array(zIntegrationSubscription),
+  next_cursor: z.string().nullable()
+});
+var zIntegrationSubscriptionDefinition = z.object({
+  conversation_schema: z.record(z.string(), z.unknown())
+});
+var zIntegrationCapabilities = z.object({
+  settings: zIntegrationCapabilityDefinition.optional(),
+  tools: z.record(z.string(), zIntegrationCapabilityDefinition),
+  subscription: zIntegrationSubscriptionDefinition.optional(),
+  interaction_handler: zIntegrationCapabilityDefinition.optional(),
+  schedule: zIntegrationCapabilityDefinition.optional()
+});
+var zIntegration = z.object({
+  id: zIntegrationId,
+  project_id: zProjectId,
+  name: zIntegrationName,
+  integration_kind: zIntegrationKind,
+  state: zIntegrationState,
+  setup_revision: z.int().gte(1),
+  last_oauth_flow_id: zIntegrationOAuthFlowId.optional(),
+  runtime_failure: zIntegrationRuntimeFailure.optional(),
+  settings: zIntegrationSettings,
+  provider_tenant_id: z.string().optional(),
+  provider_account_ref: z.string().optional(),
+  provider_agent_display_name: zIntegrationProviderDisplayName,
+  bot_mention: z.string().optional(),
+  credential_secret_id: zSecretId.optional(),
+  provider_config: zIntegrationProviderConfig,
+  capabilities: zIntegrationCapabilities,
+  created_at: zTimestamp,
+  updated_at: zTimestamp
+});
+var zListIntegrationsResponse = z.object({
+  data: z.array(zIntegration),
+  next_cursor: z.string().nullable()
+});
+var zIntegrationDefinition = z.object({
+  integration_kind: zIntegrationKind,
+  capabilities: zIntegrationCapabilities
+});
+var zListIntegrationDefinitionsResponse = z.object({
+  data: z.array(zIntegrationDefinition)
+});
+var zAgentIncludeUsage = z.boolean();
+var zAgentProfileIncludeStats = z.boolean();
+var zAgentProfileStatsSince = z.iso.datetime({ offset: true });
 var zUsageSince = z.iso.datetime({ offset: true });
 var zUsageUntil = z.iso.datetime({ offset: true });
 var zUsageIncludeProjectIds = z.array(zProjectId).min(1).max(100);
@@ -2527,9 +2739,6 @@ var zDeclineInvitationResponse = zOrgInvitation;
 var zGetOrgOverviewPath = z.object({
   orgID: zOrganizationId
 });
-var zGetOrgOverviewQuery = z.object({
-  timezone: z.string().max(64).optional().default("UTC")
-});
 var zGetOrgOverviewResponse = zOrgOverviewResponse;
 var zGetOrgUsagePath = z.object({
   orgID: zOrganizationId
@@ -2541,6 +2750,49 @@ var zGetOrgUsageQuery = z.object({
   exclude_project_ids: z.array(zProjectId).min(1).max(100).optional()
 });
 var zGetOrgUsageResponse = zUsageReport;
+var zGetOrgUsageTimeseriesPath = z.object({
+  orgID: zOrganizationId
+});
+var zGetOrgUsageTimeseriesQuery = z.object({
+  since: z.iso.datetime({ offset: true }).optional(),
+  until: z.iso.datetime({ offset: true }).optional(),
+  timezone: z.string().max(64).optional().default("UTC"),
+  interval: zUsageTimeseriesInterval.optional(),
+  metric: zUsageTimeseriesMetric.optional(),
+  group_by: zUsageTimeseriesGroupBy.optional(),
+  group_limit: z.int().gte(1).lte(20).optional().default(8),
+  project_ids: z.array(zProjectId).min(1).max(100).optional(),
+  agent_profile_ids: z.array(zAgentProfileId).min(1).max(100).optional(),
+  include_subagents: z.boolean().optional().default(false)
+});
+var zGetOrgUsageTimeseriesResponse = zUsageTimeseries;
+var zListOrgAgentsPath = z.object({
+  orgID: zOrganizationId
+});
+var zListOrgAgentsQuery = z.object({
+  name: z.string().min(1).max(200).optional(),
+  agent_profile_id: zAgentProfileId.optional(),
+  parent_agent_id: zAgentId.optional(),
+  include_subagents: z.boolean().optional(),
+  include_archived: z.boolean().optional(),
+  include_usage: z.boolean().optional(),
+  sort: zResourceListSort.optional(),
+  limit: z.int().gte(1).lte(100).optional().default(50),
+  cursor: z.string().max(1024).optional()
+});
+var zListOrgAgentsResponse = zListAgentsResponse;
+var zListOrgAgentProfilesPath = z.object({
+  orgID: zOrganizationId
+});
+var zListOrgAgentProfilesQuery = z.object({
+  name: z.string().min(1).max(200).optional(),
+  include_stats: z.boolean().optional(),
+  stats_since: z.iso.datetime({ offset: true }).optional(),
+  sort: zResourceListSort.optional(),
+  limit: z.int().gte(1).lte(100).optional().default(50),
+  cursor: z.string().max(1024).optional()
+});
+var zListOrgAgentProfilesResponse = zListAgentProfilesResponse;
 var zListVisibleProjectsPath = z.object({
   orgID: z.string().regex(/^org_[a-z2-7]{26}$/)
 });
@@ -2894,25 +3146,6 @@ var zDeleteSecretGrantPath = z.object({
   grantID: z.string().regex(/^sgr_[a-z2-7]{26}$/)
 });
 var zDeleteSecretGrantResponse = z.void();
-var zListIntegrationInstallsPath = z.object({
-  orgID: z.string().regex(/^org_[a-z2-7]{26}$/),
-  projectID: z.string().regex(/^proj_[a-z2-7]{26}$/)
-});
-var zListIntegrationInstallsQuery = z.object({
-  name: z.string().min(1).max(200).optional(),
-  agent_profile_id: zAgentProfileId.optional(),
-  oauth_flow_id: zIntegrationOAuthFlowId.optional(),
-  sort: zResourceListSort.optional(),
-  limit: z.int().gte(1).lte(100).optional().default(50),
-  cursor: z.string().max(1024).optional()
-});
-var zListIntegrationInstallsResponse2 = zListIntegrationInstallsResponse;
-var zDeleteIntegrationInstallPath = z.object({
-  orgID: z.string().regex(/^org_[a-z2-7]{26}$/),
-  projectID: z.string().regex(/^proj_[a-z2-7]{26}$/),
-  integrationInstallID: z.string().regex(/^iin_[a-z2-7]{26}$/)
-});
-var zDeleteIntegrationInstallResponse = z.void();
 var zResolveAgentConfigToolsPath = z.object({
   orgID: zOrganizationId,
   projectID: zProjectId
@@ -2948,6 +3181,8 @@ var zListAgentProfilesPath = z.object({
 });
 var zListAgentProfilesQuery = z.object({
   name: z.string().min(1).max(200).optional(),
+  include_stats: z.boolean().optional(),
+  stats_since: z.iso.datetime({ offset: true }).optional(),
   sort: zResourceListSort.optional(),
   limit: z.int().gte(1).lte(100).optional().default(50),
   cursor: z.string().max(1024).optional()
@@ -3001,17 +3236,29 @@ var zUpdateAgentProfilePath = z.object({
 });
 var zUpdateAgentProfileResponse = zAgentProfile;
 var zCreateIntegrationOAuthSetupPath = z.object({
-  orgID: z.string().regex(/^org_[a-z2-7]{26}$/),
-  projectID: z.string().regex(/^proj_[a-z2-7]{26}$/),
-  agentProfileID: z.string().regex(/^aprf_[a-z2-7]{26}$/)
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
 });
 var zCreateIntegrationOAuthSetupResponse = zIntegrationOAuthSetup;
-var zCreateSlackSetupPath = z.object({
-  orgID: z.string().regex(/^org_[a-z2-7]{26}$/),
-  projectID: z.string().regex(/^proj_[a-z2-7]{26}$/),
-  agentProfileID: z.string().regex(/^aprf_[a-z2-7]{26}$/)
+var zCreateIntegrationSlackSetupPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zCreateIntegrationSlackSetupResponse = zSlackSetup;
+var zCreateIntegrationGitHubSetupPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
 });
-var zCreateSlackSetupResponse = zSlackSetup;
+var zCreateIntegrationGitHubSetupResponse = zGitHubSetup;
+var zInspectIntegrationGitHubInstallationsPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zInspectIntegrationGitHubInstallationsResponse = zGitHubInstallations;
 var zListCronTriggersPath = z.object({
   orgID: z.string().regex(/^org_[a-z2-7]{26}$/),
   projectID: z.string().regex(/^proj_[a-z2-7]{26}$/)
@@ -3020,6 +3267,7 @@ var zListCronTriggersQuery = z.object({
   name: z.string().min(1).max(200).optional(),
   agent_id: zAgentId.optional(),
   agent_profile_id: zAgentProfileId.optional(),
+  integration_id: zIntegrationId.optional(),
   sort: zResourceListSort.optional(),
   limit: z.int().gte(1).lte(100).optional().default(50),
   cursor: z.string().max(1024).optional()
@@ -3063,6 +3311,7 @@ var zListAgentsQuery = z.object({
   parent_agent_id: zAgentId.optional(),
   include_subagents: z.boolean().optional(),
   include_archived: z.boolean().optional(),
+  include_usage: z.boolean().optional(),
   sort: zResourceListSort.optional(),
   limit: z.int().gte(1).lte(100).optional().default(50),
   cursor: z.string().max(1024).optional()
@@ -3586,6 +3835,13 @@ var zSleepMachineDaemonRuntimePath = z.object({
   runtimeID: z.string().regex(/^drt_[a-z2-7]{26}$/)
 });
 var zSleepMachineDaemonRuntimeResponse = zDaemonRuntime;
+var zGetDaemonGitCredentialsPath = z.object({
+  processID: zProcessId
+});
+var zGetDaemonGitCredentialsResponse = z.object({
+  token: z.string(),
+  expires_at: zTimestamp
+});
 var zGetDaemonSkillArchivePath = z.object({
   skillID: z.string().regex(/^skl_[a-z2-7]{26}$/)
 });
@@ -3603,10 +3859,85 @@ var zUploadDaemonFileBody = z.instanceof(Blob);
 var zUploadDaemonFilePath = z.object({
   processID: zProcessId
 });
-var zUploadDaemonFileQuery = z.object({
-  filename: z.string().optional()
+var zUploadDaemonFileQuery = z.object({
+  filename: z.string().optional()
+});
+var zUploadDaemonFileResponse = zUploadFileResponse;
+var zListIntegrationsPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId
+});
+var zListIntegrationsQuery = z.object({
+  limit: z.int().gte(1).lte(100).optional().default(50),
+  cursor: z.string().max(1024).optional()
+});
+var zListIntegrationsResponse2 = zListIntegrationsResponse;
+var zCreateIntegrationBody = zCreateIntegrationRequest;
+var zCreateIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId
+});
+var zCreateIntegrationResponse = zIntegration;
+var zDeleteIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zDeleteIntegrationResponse = z.void();
+var zGetIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zGetIntegrationResponse = zIntegration;
+var zUpdateIntegrationBody = zUpdateIntegrationRequest;
+var zUpdateIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zUpdateIntegrationResponse = zIntegration;
+var zListIntegrationSubscriptionsPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zListIntegrationSubscriptionsQuery = z.object({
+  limit: z.int().gte(1).lte(100).optional().default(50),
+  cursor: z.string().max(1024).optional()
+});
+var zListIntegrationSubscriptionsResponse2 = zListIntegrationSubscriptionsResponse;
+var zCreateIntegrationSubscriptionPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zCreateIntegrationSubscriptionResponse = zIntegrationSubscription;
+var zDeleteIntegrationSubscriptionPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId,
+  subscriptionID: zIntegrationSubscriptionId
+});
+var zDeleteIntegrationSubscriptionResponse = z.void();
+var zConfigureIntegrationBody = zConfigureIntegrationRequest;
+var zConfigureIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zConfigureIntegrationResponse = zIntegration;
+var zDisconnectIntegrationPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId,
+  integrationID: zIntegrationId
+});
+var zDisconnectIntegrationResponse = zIntegration;
+var zListIntegrationDefinitionsPath = z.object({
+  orgID: zOrganizationId,
+  projectID: zProjectId
 });
-var zUploadDaemonFileResponse = zUploadFileResponse;
+var zListIntegrationDefinitionsResponse2 = zListIntegrationDefinitionsResponse;
 
 // ../sdk/src/json-body.ts
 import * as z2 from "zod";
@@ -5020,6 +5351,7 @@ __export(sdk_gen_exports, {
   bootstrapDaemon: () => bootstrapDaemon,
   cancelAgent: () => cancelAgent,
   cancelQueuedBacklogInput: () => cancelQueuedBacklogInput,
+  configureIntegration: () => configureIntegration,
   connectByoMachine: () => connectByoMachine,
   createAgent: () => createAgent,
   createAgentConfig: () => createAgentConfig,
@@ -5028,7 +5360,11 @@ __export(sdk_gen_exports, {
   createByoMachineDaemonToken: () => createByoMachineDaemonToken,
   createConfiguredModel: () => createConfiguredModel,
   createCronTrigger: () => createCronTrigger,
+  createIntegration: () => createIntegration,
+  createIntegrationGitHubSetup: () => createIntegrationGitHubSetup,
   createIntegrationOAuthSetup: () => createIntegrationOAuthSetup,
+  createIntegrationSlackSetup: () => createIntegrationSlackSetup,
+  createIntegrationSubscription: () => createIntegrationSubscription,
   createMachine: () => createMachine,
   createMachinePool: () => createMachinePool,
   createMemoryStore: () => createMemoryStore,
@@ -5046,13 +5382,13 @@ __export(sdk_gen_exports, {
   createSecretVersion: () => createSecretVersion,
   createSkill: () => createSkill,
   createSkillGrant: () => createSkillGrant,
-  createSlackSetup: () => createSlackSetup,
   declineInvitation: () => declineInvitation,
   deleteAgentProfile: () => deleteAgentProfile,
   deleteConfiguredModel: () => deleteConfiguredModel,
   deleteCronTrigger: () => deleteCronTrigger,
   deleteCurrentUser: () => deleteCurrentUser,
-  deleteIntegrationInstall: () => deleteIntegrationInstall,
+  deleteIntegration: () => deleteIntegration,
+  deleteIntegrationSubscription: () => deleteIntegrationSubscription,
   deleteMachine: () => deleteMachine,
   deleteMachinePool: () => deleteMachinePool,
   deleteMemoryFile: () => deleteMemoryFile,
@@ -5069,6 +5405,7 @@ __export(sdk_gen_exports, {
   deleteSkill: () => deleteSkill,
   deleteSkillGrant: () => deleteSkillGrant,
   demoteSteeringInputToQueued: () => demoteSteeringInputToQueued,
+  disconnectIntegration: () => disconnectIntegration,
   downloadDaemonFile: () => downloadDaemonFile,
   downloadMemoryFile: () => downloadMemoryFile,
   endMachineDaemonRuntime: () => endMachineDaemonRuntime,
@@ -5082,7 +5419,9 @@ __export(sdk_gen_exports, {
   getArtifactContent: () => getArtifactContent,
   getCronTrigger: () => getCronTrigger,
   getCurrentUser: () => getCurrentUser,
+  getDaemonGitCredentials: () => getDaemonGitCredentials,
   getDaemonSkillArchive: () => getDaemonSkillArchive,
+  getIntegration: () => getIntegration,
   getMachine: () => getMachine,
   getMachinePool: () => getMachinePool,
   getMemoryStore: () => getMemoryStore,
@@ -5091,12 +5430,14 @@ __export(sdk_gen_exports, {
   getOrgApiKey: () => getOrgApiKey,
   getOrgOverview: () => getOrgOverview,
   getOrgUsage: () => getOrgUsage,
+  getOrgUsageTimeseries: () => getOrgUsageTimeseries,
   getProjectAvailableSecret: () => getProjectAvailableSecret,
   getProjectMachinePoolGrant: () => getProjectMachinePoolGrant,
   getProjectUsage: () => getProjectUsage,
   getSecret: () => getSecret,
   getSkill: () => getSkill,
   getToolCatalog: () => getToolCatalog,
+  inspectIntegrationGitHubInstallations: () => inspectIntegrationGitHubInstallations,
   listActors: () => listActors,
   listAgentInteractions: () => listAgentInteractions,
   listAgentProfiles: () => listAgentProfiles,
@@ -5105,7 +5446,9 @@ __export(sdk_gen_exports, {
   listConfiguredModels: () => listConfiguredModels,
   listCronTriggers: () => listCronTriggers,
   listEvents: () => listEvents,
-  listIntegrationInstalls: () => listIntegrationInstalls,
+  listIntegrationDefinitions: () => listIntegrationDefinitions,
+  listIntegrationSubscriptions: () => listIntegrationSubscriptions,
+  listIntegrations: () => listIntegrations,
   listMachinePools: () => listMachinePools,
   listMcpServerTools: () => listMcpServerTools,
   listMcpServers: () => listMcpServers,
@@ -5113,6 +5456,8 @@ __export(sdk_gen_exports, {
   listMemoryFiles: () => listMemoryFiles,
   listMemoryStores: () => listMemoryStores,
   listModelProviderConfigs: () => listModelProviderConfigs,
+  listOrgAgentProfiles: () => listOrgAgentProfiles,
+  listOrgAgents: () => listOrgAgents,
   listOrgApiKeyProjectAccess: () => listOrgApiKeyProjectAccess,
   listOrgApiKeys: () => listOrgApiKeys,
   listOrgInvitations: () => listOrgInvitations,
@@ -5161,6 +5506,7 @@ __export(sdk_gen_exports, {
   updateAgentProfile: () => updateAgentProfile,
   updateConfiguredModel: () => updateConfiguredModel,
   updateCronTrigger: () => updateCronTrigger,
+  updateIntegration: () => updateIntegration,
   updateMachine: () => updateMachine,
   updateMachinePool: () => updateMachinePool,
   updateMemoryStore: () => updateMemoryStore,
@@ -5409,6 +5755,48 @@ var getOrgUsage = (options) => (options.client ?? client).get({
   url: "/orgs/{orgID}/usage",
   ...options
 });
+var getOrgUsageTimeseries = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zGetOrgUsageTimeseriesResponse),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/usage/timeseries",
+  ...options
+});
+var listOrgAgents = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zListOrgAgentsResponse),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/agents",
+  ...options
+});
+var listOrgAgentProfiles = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zListOrgAgentProfilesResponse),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/agent-profiles",
+  ...options
+});
 var listVisibleProjects = (options) => (options.client ?? client).get({
   responseValidator: relaxedResponseValidator(zListVisibleProjectsResponse),
   security: [{
@@ -6250,38 +6638,6 @@ var deleteSecretGrant = (options) => (options.client ?? client).delete({
   url: "/orgs/{orgID}/secrets/{secretID}/grants/{grantID}",
   ...options
 });
-var listIntegrationInstalls = (options) => (options.client ?? client).get({
-  responseValidator: relaxedResponseValidator(zListIntegrationInstallsResponse2),
-  security: [{
-    key: "bearerAuth",
-    scheme: "bearer",
-    type: "http"
-  }, {
-    in: "cookie",
-    name: "__Host-omnara_session",
-    type: "apiKey"
-  }],
-  url: "/orgs/{orgID}/projects/{projectID}/integration-installs",
-  ...options
-});
-var deleteIntegrationInstall = (options) => (options.client ?? client).delete({
-  responseValidator: relaxedResponseValidator(zDeleteIntegrationInstallResponse),
-  security: [
-    {
-      key: "bearerAuth",
-      scheme: "bearer",
-      type: "http"
-    },
-    {
-      in: "cookie",
-      name: "__Host-omnara_session",
-      type: "apiKey"
-    },
-    { name: "X-Omnara-Csrf", type: "apiKey" }
-  ],
-  url: "/orgs/{orgID}/projects/{projectID}/integration-installs/{integrationInstallID}",
-  ...options
-});
 var resolveAgentConfigTools = (options) => (options.client ?? client).post({
   responseValidator: relaxedResponseValidator(zResolveAgentConfigToolsResponse),
   security: [
@@ -6531,15 +6887,15 @@ var createIntegrationOAuthSetup = (options) => (options.client ?? client).post({
     },
     { name: "X-Omnara-Csrf", type: "apiKey" }
   ],
-  url: "/orgs/{orgID}/projects/{projectID}/agent-profiles/{agentProfileID}/integration-oauth/setup",
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/oauth/setup",
   ...options,
   headers: {
     "Content-Type": "application/json",
     ...options.headers
   }
 });
-var createSlackSetup = (options) => (options.client ?? client).post({
-  responseValidator: relaxedResponseValidator(zCreateSlackSetupResponse),
+var createIntegrationSlackSetup = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zCreateIntegrationSlackSetupResponse),
   security: [
     {
       key: "bearerAuth",
@@ -6553,7 +6909,35 @@ var createSlackSetup = (options) => (options.client ?? client).post({
     },
     { name: "X-Omnara-Csrf", type: "apiKey" }
   ],
-  url: "/orgs/{orgID}/projects/{projectID}/agent-profiles/{agentProfileID}/slack-setup",
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/slack-setup",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var createIntegrationGitHubSetup = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zCreateIntegrationGitHubSetupResponse),
+  security: [{
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }, { name: "X-Omnara-Csrf", type: "apiKey" }],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/github-setup",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var inspectIntegrationGitHubInstallations = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zInspectIntegrationGitHubInstallationsResponse),
+  security: [{
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }, { name: "X-Omnara-Csrf", type: "apiKey" }],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/github-setup/installations",
   ...options,
   headers: {
     "Content-Type": "application/json",
@@ -7839,6 +8223,16 @@ var sleepMachineDaemonRuntime = (options) => (options.client ?? client).post({
   url: "/daemon/runtimes/{runtimeID}/sleep",
   ...options
 });
+var getDaemonGitCredentials = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zGetDaemonGitCredentialsResponse),
+  security: [{
+    key: "machineDaemonAuth",
+    scheme: "bearer",
+    type: "http"
+  }],
+  url: "/daemon/processes/{processID}/git-credentials",
+  ...options
+});
 var getDaemonSkillArchive = (options) => (options.client ?? client).get({
   responseValidator: relaxedResponseValidator(zGetDaemonSkillArchiveResponse),
   security: [{
@@ -7874,24 +8268,245 @@ var uploadDaemonFile = (options) => (options.client ?? client).post({
     ...options.headers
   }
 });
+var listIntegrations = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zListIntegrationsResponse2),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations",
+  ...options
+});
+var createIntegration = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zCreateIntegrationResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var deleteIntegration = (options) => (options.client ?? client).delete({
+  responseValidator: relaxedResponseValidator(zDeleteIntegrationResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}",
+  ...options
+});
+var getIntegration = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zGetIntegrationResponse),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}",
+  ...options
+});
+var updateIntegration = (options) => (options.client ?? client).put({
+  responseValidator: relaxedResponseValidator(zUpdateIntegrationResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var listIntegrationSubscriptions = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zListIntegrationSubscriptionsResponse2),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/subscriptions",
+  ...options
+});
+var createIntegrationSubscription = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zCreateIntegrationSubscriptionResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/subscriptions",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var deleteIntegrationSubscription = (options) => (options.client ?? client).delete({
+  responseValidator: relaxedResponseValidator(zDeleteIntegrationSubscriptionResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/subscriptions/{subscriptionID}",
+  ...options
+});
+var configureIntegration = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zConfigureIntegrationResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/setup",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var disconnectIntegration = (options) => (options.client ?? client).post({
+  responseValidator: relaxedResponseValidator(zDisconnectIntegrationResponse),
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
+  url: "/orgs/{orgID}/projects/{projectID}/integrations/{integrationID}/disconnect",
+  ...options
+});
+var listIntegrationDefinitions = (options) => (options.client ?? client).get({
+  responseValidator: relaxedResponseValidator(zListIntegrationDefinitionsResponse2),
+  security: [{
+    key: "bearerAuth",
+    scheme: "bearer",
+    type: "http"
+  }, {
+    in: "cookie",
+    name: "__Host-omnara_session",
+    type: "apiKey"
+  }],
+  url: "/orgs/{orgID}/projects/{projectID}/integration-definitions",
+  ...options
+});
 
 // ../sdk/src/memory.ts
 var MAX_MEMORY_FILE_BYTES = 10 * 1024 * 1024;
 var FILE_DIGEST_HEADER = "X-Omnara-File-Digest";
 
+// ../sdk/src/profile-integration.ts
+import * as z8 from "zod";
+var discordPublicKeyPattern = "[a-fA-F0-9]{64}";
+var discordPublicKey = z8.string().regex(new RegExp(`^${discordPublicKeyPattern}$`));
+var profilesSchema = z8.array(zAgentProfileId).max(16).refine((ids) => new Set(ids).size === ids.length, "Choose each profile only once.");
+var repositorySchema = z8.string().trim().regex(/^[1-9][0-9]*$/, "Enter a positive repository ID without leading zeros.").refine((id) => BigInt(id) <= 9223372036854775807n, "The repository ID is too large.");
+var triggerSchema = z8.enum(["mention", "pull_request_opened", "both"]);
+var chatLauncherSchema = z8.object({ profiles: profilesSchema.min(1) }).strict();
+var githubLauncherSchema = z8.object({
+  profile: zAgentProfileId,
+  trigger: triggerSchema,
+  repository_id: repositorySchema.optional()
+}).strict();
+function profileIntegrationProfileUpdate(integration, profileIds) {
+  if (!["slack_thread", "discord_thread"].includes(integration.integration_kind))
+    throw new Error("Profile editing requires a Slack or Discord integration.");
+  const profiles = profilesSchema.parse(profileIds);
+  const settings = { ...integration.settings };
+  if (profiles.length === 0) delete settings.launcher;
+  else settings.launcher = { profiles };
+  return { settings };
+}
+
 // src/config-file.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import * as z9 from "zod";
+import * as z10 from "zod";
 
 // src/output.ts
-import * as z8 from "zod";
-var zRenderValue = z8.json();
+import * as z9 from "zod";
+var zRenderValue = z9.json();
 var zOptionalRenderValue = zRenderValue.optional();
-var zListEnvelope = z8.strictObject({
-  data: z8.array(zRenderValue),
-  next_cursor: z8.string().nullable()
+var zListEnvelope = z9.strictObject({
+  data: z9.array(zRenderValue),
+  next_cursor: z9.string().nullable()
 });
 var PREFERRED_LEADING_COLUMNS = ["id", "name"];
 var HIDDEN_TABLE_COLUMNS = /* @__PURE__ */ new Set(["org_id", "project_id"]);
@@ -8063,9 +8678,9 @@ async function runCliAction(action) {
   } catch (error) {
     if (error instanceof CliInputError) {
       console.error(`error: ${error.message}`);
-    } else if (error instanceof z8.ZodError) {
+    } else if (error instanceof z9.ZodError) {
       console.error(`error: unexpected response shape:
-${z8.prettifyError(error)}`);
+${z9.prettifyError(error)}`);
     } else if (error instanceof ApiError) {
       const code = error.code ? ` [${error.code}]` : "";
       console.error(`error: API ${error.status}${code}: ${error.message}`);
@@ -8078,11 +8693,11 @@ ${z8.prettifyError(error)}`);
 }
 
 // src/config-file.ts
-var zConfigFile = z9.looseObject({
-  api_url: z9.url().optional(),
-  issuer_url: z9.url().optional(),
-  base_url: z9.url().optional(),
-  token: z9.string().min(1).optional(),
+var zConfigFile = z10.looseObject({
+  api_url: z10.url().optional(),
+  issuer_url: z10.url().optional(),
+  base_url: z10.url().optional(),
+  token: z10.string().min(1).optional(),
   org_id: zOrganizationId.optional(),
   project_id: zProjectId.optional()
 });
@@ -8099,9 +8714,9 @@ function loadConfigFile() {
   const path = configFilePath();
   if (!existsSync(path)) return { readable: true, file: {} };
   const json8 = zJsonText.safeParse(readFileSync(path, "utf8"));
-  if (!json8.success) return { readable: false, reason: z9.prettifyError(json8.error) };
+  if (!json8.success) return { readable: false, reason: z10.prettifyError(json8.error) };
   const file = zConfigFile.safeParse(json8.data);
-  return file.success ? { readable: true, file: file.data } : { readable: false, reason: z9.prettifyError(file.error) };
+  return file.success ? { readable: true, file: file.data } : { readable: false, reason: z10.prettifyError(file.error) };
 }
 function readConfigFile() {
   const loaded = loadConfigFile();
@@ -8128,7 +8743,7 @@ function updateConfigFile(patch) {
   const result = zConfigFile.safeParse(merged);
   if (!result.success) {
     throw new CliInputError(`refusing to save invalid config:
-${z9.prettifyError(result.error)}`);
+${z10.prettifyError(result.error)}`);
   }
   mkdirSync(dirname(configFilePath()), { recursive: true, mode: 448 });
   writeFileSync(configFilePath(), `${JSON.stringify(result.data, null, 2)}
@@ -8140,7 +8755,7 @@ ${z9.prettifyError(result.error)}`);
 // src/device-login.ts
 import { hostname } from "node:os";
 import { intro, log, note, outro, spinner } from "@clack/prompts";
-import * as z10 from "zod";
+import * as z11 from "zod";
 
 // src/browser.ts
 import { spawn } from "node:child_process";
@@ -8313,7 +8928,7 @@ function loginTokenName(explicit, hostName) {
   if (result.success) return result.data;
   if (explicit === void 0) return cliLoginTokenName();
   throw new CliInputError(`invalid token name:
-${z10.prettifyError(result.error)}`);
+${z11.prettifyError(result.error)}`);
 }
 async function loginWithDevice(options) {
   const { report, store } = options;
@@ -8549,14 +9164,14 @@ function registerConfigCommand(program2, cli) {
 
 // src/factory.ts
 import { InvalidArgumentError } from "commander";
-import * as z12 from "zod";
+import * as z13 from "zod";
 
 // src/flags.ts
-import * as z11 from "zod";
-var zScalarKind = z11.union([
-  z11.string().transform(() => "string"),
-  z11.number().transform(() => "number"),
-  z11.boolean().transform(() => "boolean")
+import * as z12 from "zod";
+var zScalarKind = z12.union([
+  z12.string().transform(() => "string"),
+  z12.number().transform(() => "number"),
+  z12.boolean().transform(() => "boolean")
 ]);
 function isChoice(value) {
   return typeof value === "string" || typeof value === "number";
@@ -8673,7 +9288,7 @@ function finalizeFlag(draft) {
   };
 }
 function deriveFlags(schema) {
-  const jsonSchema = z11.toJSONSchema(schema, { io: "input" });
+  const jsonSchema = z12.toJSONSchema(schema, { io: "input" });
   const drafts = /* @__PURE__ */ new Map();
   collectDrafts(drafts, jsonSchema, [], false);
   return [...drafts.values()].map(finalizeFlag);
@@ -8744,9 +9359,9 @@ function createFlowReporter(title) {
 }
 
 // src/factory.ts
-var zFlagValue = z12.json();
-var zFlagObject = z12.record(z12.string(), zFlagValue);
-var zNoParams = z12.object({});
+var zFlagValue = z13.json();
+var zFlagObject = z13.record(z13.string(), zFlagValue);
+var zNoParams = z13.object({});
 function op(spec) {
   return {
     type: "op",
@@ -8902,7 +9517,7 @@ function parseWithSchema(schema, value, label) {
   const result = schema.safeParse(value);
   if (!result.success) {
     throw new CliInputError(`invalid ${label}:
-${z12.prettifyError(result.error)}`);
+${z13.prettifyError(result.error)}`);
   }
   return result.data;
 }
@@ -8947,7 +9562,7 @@ function registerPathParams(command, plan) {
     command.option(param.option, `defaults from config (${param.describe})`);
   }
 }
-var zExplicitOption = z12.string().optional();
+var zExplicitOption = z13.string().optional();
 async function resolvePathValues(plan, args, options, config2) {
   const path = {};
   plan.positionalParams.forEach((param, index) => {
@@ -9090,10 +9705,10 @@ function registerLoginCommand(program2, cli) {
 }
 
 // src/manifest.ts
-import * as z26 from "zod";
+import * as z28 from "zod";
 
 // src/agent-commands.ts
-import * as z18 from "zod";
+import * as z19 from "zod";
 
 // ../sdk/src/generated/@tanstack/react-query.gen.ts
 import { infiniteQueryOptions, queryOptions } from "@tanstack/react-query";
@@ -9119,6 +9734,7 @@ var createQueryKey = (id, options, infinite, tags) => {
   }
   return [params];
 };
+var listOrgAgentsQueryKey = (options) => createQueryKey("listOrgAgents", options);
 var listAgentsQueryKey = (options) => createQueryKey("listAgents", options);
 var getAgentQueryKey = (options) => createQueryKey("getAgent", options);
 var getAgentOptions = (options) => queryOptions({
@@ -9195,12 +9811,12 @@ function useOmnaraClient() {
 }
 
 // ../react/src/domains/query-keys.ts
-import { z as z13 } from "zod";
-var generatedQueryKeyEntry = z13.object({
-  _id: z13.string(),
-  path: z13.object({
-    orgID: z13.string().optional(),
-    projectID: z13.string().optional()
+import { z as z14 } from "zod";
+var generatedQueryKeyEntry = z14.object({
+  _id: z14.string(),
+  path: z14.object({
+    orgID: z14.string().optional(),
+    projectID: z14.string().optional()
   }).optional()
 });
 function generatedQueryKey(query) {
@@ -9216,6 +9832,21 @@ function projectActorsQueryPredicate(orgID, projectID) {
   };
 }
 
+// ../react/src/domains/agent-activity.ts
+var activeAgentPollIntervalMs = 5e3;
+function isAgentActive(agent) {
+  const state = agent.activity?.state;
+  return state === "running" || state === "waiting_on_interaction";
+}
+function activeAgentsRefetchInterval(getAgents, refetchInterval) {
+  return (query) => {
+    const data = query.state.data;
+    const own = refetchInterval?.(data);
+    if (own) return own;
+    return getAgents(data).some(isAgentActive) ? activeAgentPollIntervalMs : false;
+  };
+}
+
 // ../react/src/domains/agent-chat.ts
 import { useQueryClient as useQueryClient3 } from "@tanstack/react-query";
 import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
@@ -9224,7 +9855,7 @@ import { useCallback, useEffect, useMemo, useSyncExternalStore } from "react";
 import { useInfiniteQuery } from "@tanstack/react-query";
 
 // ../react/src/domains/agent-chat-messages.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function parseStreamData(data) {
   if ("event_kind" in data) return { kind: "event", event: data };
   if ("tool_call_id" in data && "state" in data) return { kind: "tool_call_update" };
@@ -9261,7 +9892,7 @@ function mediaPart(block, id) {
 function isHiddenContentBlock(block) {
   return block.metadata?.omnara_hidden === "true";
 }
-var structuredToolError = z14.object({ error_code: z14.string() });
+var structuredToolError = z15.object({ error_code: z15.string() });
 function structuredToolErrorCode(blocks) {
   for (const block of blocks) {
     if (block.type !== "structured_data") continue;
@@ -9682,7 +10313,7 @@ function historyHasEvent(queryClient, scope, matches) {
 // ../react/src/domains/agent-chat-transport.ts
 var sourceLabels = { web: "web app", cli: "CLI" };
 function sourceHint(source) {
-  return `This message came from the Omnara ${sourceLabels[source]}. Reply with normal assistant text unless explicitly asked to message an integration.`;
+  return `This message came from the Omnara ${sourceLabels[source]}. Reply with normal assistant text unless explicitly asked to send a message through an integration.`;
 }
 var sdkAgentChatTransport = {
   openAgentEventStream,
@@ -9932,12 +10563,17 @@ async function invalidateSubagentList(queryClient, client2, scope, event, hasEve
   if (!spawnsSubagent(event, hasEvent) && !await sentBySubagent(queryClient, client2, scope, event)) {
     return;
   }
-  await queryClient.invalidateQueries({
-    queryKey: listAgentsQueryKey({
-      path: { orgID: scope.orgID, projectID: scope.projectID },
-      client: client2
+  await Promise.all([
+    queryClient.invalidateQueries({
+      queryKey: listAgentsQueryKey({
+        path: { orgID: scope.orgID, projectID: scope.projectID },
+        client: client2
+      })
+    }),
+    queryClient.invalidateQueries({
+      queryKey: listOrgAgentsQueryKey({ path: { orgID: scope.orgID }, client: client2 })
     })
-  });
+  ]);
 }
 
 // ../react/src/domains/usage.ts
@@ -10420,87 +11056,88 @@ import {
   useQueryClient as useQueryClient6,
   useSuspenseQuery as useSuspenseQuery3
 } from "@tanstack/react-query";
+var agentListRefetchInterval = activeAgentsRefetchInterval(
+  (data) => data?.pages.flatMap((page) => page.data) ?? []
+);
 
 // ../react/src/domains/cron-triggers.ts
 import { useInfiniteQuery as useInfiniteQuery4, useMutation as useMutation6, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
 
-// ../react/src/domains/integration-installs.ts
-import { useInfiniteQuery as useInfiniteQuery5, useMutation as useMutation7, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+// ../react/src/domains/integration-subscriptions.ts
+import {
+  useInfiniteQuery as useInfiniteQuery5,
+  useMutation as useMutation7,
+  useQueryClient as useQueryClient8
+} from "@tanstack/react-query";
+
+// ../react/src/domains/integrations.ts
+import { useInfiniteQuery as useInfiniteQuery6, useMutation as useMutation8, useQuery as useQuery7, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
 
 // ../react/src/domains/invitations.ts
-import { useMutation as useMutation8, useQuery as useQuery7, useQueryClient as useQueryClient9, useSuspenseQuery as useSuspenseQuery4 } from "@tanstack/react-query";
+import { useMutation as useMutation9, useQuery as useQuery8, useQueryClient as useQueryClient10, useSuspenseQuery as useSuspenseQuery4 } from "@tanstack/react-query";
 
 // ../react/src/domains/machine-pools.ts
-import { useInfiniteQuery as useInfiniteQuery6, useMutation as useMutation9, useQuery as useQuery8, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery7, useMutation as useMutation10, useQuery as useQuery9, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
 
 // ../react/src/domains/machines.ts
-import { useInfiniteQuery as useInfiniteQuery7, useMutation as useMutation10, useQuery as useQuery9, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery8, useMutation as useMutation11, useQuery as useQuery10, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
 
 // ../react/src/domains/mcp-registry.ts
-import { useInfiniteQuery as useInfiniteQuery8, useQuery as useQuery10, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery9, useQuery as useQuery11, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
 var serverInfoStaleTime = 5 * 60 * 1e3;
 
 // ../react/src/domains/mcp-server-tools.ts
-import { useQuery as useQuery11 } from "@tanstack/react-query";
+import { useQuery as useQuery12 } from "@tanstack/react-query";
 var mcpServerToolsStaleTime = 60 * 1e3;
 
 // ../react/src/domains/me.ts
-import { useMutation as useMutation11, useQueryClient as useQueryClient13, useSuspenseQuery as useSuspenseQuery5 } from "@tanstack/react-query";
+import { useMutation as useMutation12, useQueryClient as useQueryClient14, useSuspenseQuery as useSuspenseQuery5 } from "@tanstack/react-query";
 
 // ../react/src/domains/memory.ts
 import {
   skipToken,
-  useInfiniteQuery as useInfiniteQuery9,
-  useMutation as useMutation12,
-  useQuery as useQuery12,
-  useQueryClient as useQueryClient14
+  useInfiniteQuery as useInfiniteQuery10,
+  useMutation as useMutation13,
+  useQuery as useQuery13,
+  useQueryClient as useQueryClient15
 } from "@tanstack/react-query";
-import * as z15 from "zod";
-var memoryFileDigest = z15.object({ digest: z15.string() });
+import * as z16 from "zod";
+var memoryFileDigest = z16.object({ digest: z16.string() });
 
 // ../react/src/domains/model-providers.ts
 import {
-  useInfiniteQuery as useInfiniteQuery10,
-  useMutation as useMutation13,
+  useInfiniteQuery as useInfiniteQuery11,
+  useMutation as useMutation14,
   useQueries,
-  useQuery as useQuery13,
-  useQueryClient as useQueryClient15
+  useQuery as useQuery14,
+  useQueryClient as useQueryClient16
 } from "@tanstack/react-query";
 import { useEffect as useEffect2 } from "react";
-var modelCatalogPricingStaleTime = 5 * 60 * 1e3;
 
 // ../react/src/domains/org-api-keys.ts
-import { useInfiniteQuery as useInfiniteQuery11, useMutation as useMutation14, useQuery as useQuery14, useQueryClient as useQueryClient16 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery12, useMutation as useMutation15, useQuery as useQuery15, useQueryClient as useQueryClient17 } from "@tanstack/react-query";
 
 // ../react/src/domains/org-members.ts
-import { useMutation as useMutation15, useQuery as useQuery15, useQueryClient as useQueryClient17 } from "@tanstack/react-query";
+import { useMutation as useMutation16, useQuery as useQuery16, useQueryClient as useQueryClient18 } from "@tanstack/react-query";
 
 // ../react/src/domains/orgs.ts
-import { useInfiniteQuery as useInfiniteQuery12, useMutation as useMutation16, useQuery as useQuery16, useQueryClient as useQueryClient18 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery13, useMutation as useMutation17, useQuery as useQuery17, useQueryClient as useQueryClient19 } from "@tanstack/react-query";
 
 // ../react/src/domains/personal-access-tokens.ts
-import { useInfiniteQuery as useInfiniteQuery13, useMutation as useMutation17, useQueryClient as useQueryClient19 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery14, useMutation as useMutation18, useQueryClient as useQueryClient20 } from "@tanstack/react-query";
 
 // ../react/src/domains/project-grants.ts
-import { useInfiniteQuery as useInfiniteQuery14, useMutation as useMutation18, useQueryClient as useQueryClient20 } from "@tanstack/react-query";
+import { useInfiniteQuery as useInfiniteQuery15, useMutation as useMutation19, useQueryClient as useQueryClient21 } from "@tanstack/react-query";
 
 // ../react/src/domains/projects.ts
 import {
   skipToken as skipToken2,
-  useInfiniteQuery as useInfiniteQuery15,
-  useQueryClient as useQueryClient21,
+  useInfiniteQuery as useInfiniteQuery16,
+  useQueryClient as useQueryClient22,
   useSuspenseInfiniteQuery
 } from "@tanstack/react-query";
 
 // ../react/src/domains/secrets.ts
-import {
-  useInfiniteQuery as useInfiniteQuery16,
-  useMutation as useMutation19,
-  useQuery as useQuery17,
-  useQueryClient as useQueryClient22
-} from "@tanstack/react-query";
-
-// ../react/src/domains/skills.ts
 import {
   useInfiniteQuery as useInfiniteQuery17,
   useMutation as useMutation20,
@@ -10508,8 +11145,16 @@ import {
   useQueryClient as useQueryClient23
 } from "@tanstack/react-query";
 
+// ../react/src/domains/skills.ts
+import {
+  useInfiniteQuery as useInfiniteQuery18,
+  useMutation as useMutation21,
+  useQuery as useQuery19,
+  useQueryClient as useQueryClient24
+} from "@tanstack/react-query";
+
 // ../react/src/domains/tool-catalog.ts
-import { useQuery as useQuery19 } from "@tanstack/react-query";
+import { useQuery as useQuery20 } from "@tanstack/react-query";
 
 // src/chat.tsx
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
@@ -10518,10 +11163,10 @@ import { render } from "ink";
 // src/chat-ui.tsx
 import { Box as Box2, Static, Text as Text2, useApp } from "ink";
 import { useEffect as useEffect3, useMemo as useMemo2, useReducer, useState as useState2 } from "react";
-import * as z17 from "zod";
+import * as z18 from "zod";
 
 // src/agent-rendering.ts
-import * as z16 from "zod";
+import * as z17 from "zod";
 var formatAgentEventList = (response) => {
   const page = {
     data: response.data.map((event) => ({
@@ -10538,10 +11183,10 @@ var formatAgentEventList = (response) => {
   return { value: next_before_sequence == null ? page : { ...page, next_before_sequence } };
 };
 var summaryWidth = 100;
-var zJsonValue = z16.json();
-var zRunCommandInput = z16.object({ command: z16.string() });
+var zJsonValue = z17.json();
+var zRunCommandInput = z17.object({ command: z17.string() });
 function summaryValue(value) {
-  const text = z16.string().safeParse(value);
+  const text = z17.string().safeParse(value);
   return text.success ? text.data : JSON.stringify(value);
 }
 function toolCallSummary(name, input) {
@@ -10735,10 +11380,10 @@ import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var streamingTailLines = 8;
 var streamingTailChars = 1500;
-var zToolInput2 = z17.record(z17.string(), z17.json());
-var zToolOutput = z17.object({
+var zToolInput2 = z18.record(z18.string(), z18.json());
+var zToolOutput = z18.object({
   outcome: zToolCallOutcome,
-  contentBlocks: z17.array(zToolResultContentBlock)
+  contentBlocks: z18.array(zToolResultContentBlock)
 });
 function formatDuration(ms) {
   const seconds = Math.max(1, Math.round(ms / 1e3));
@@ -11104,7 +11749,7 @@ var agentEventsStreamOp = customOp({
   },
   run: async ({ client: client2, path, args, options }) => {
     const agentID = parseWithSchema(zAgentId, args[0], "agent id");
-    const afterSequence = parseWithSchema(z18.int().gte(0).optional(), options.afterSequence, "--after-sequence") ?? 0;
+    const afterSequence = parseWithSchema(z19.int().gte(0).optional(), options.afterSequence, "--after-sequence") ?? 0;
     const abort = new AbortController();
     process.once("SIGINT", () => {
       abort.abort();
@@ -11121,12 +11766,12 @@ var agentEventsStreamOp = customOp({
 
 // src/config-attachment.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import * as z19 from "zod";
-var zConfigSourceAttachment = z19.object({
-  file: z19.string().min(1).optional().describe("path to an agent config file (.yaml, .yml, or .json)"),
-  source: z19.string().min(1).optional().describe("inline agent config source (YAML or JSON)")
+import * as z20 from "zod";
+var zConfigSourceAttachment = z20.object({
+  file: z20.string().min(1).optional().describe("path to an agent config file (.yaml, .yml, or .json)"),
+  source: z20.string().min(1).optional().describe("inline agent config source (YAML or JSON)")
 });
-var zConfigAttachment = z19.object({
+var zConfigAttachment = z20.object({
   config: zAgentConfigId.optional().describe("existing agent config ID"),
   ...zConfigSourceAttachment.shape
 });
@@ -11160,59 +11805,341 @@ function renderConfigSource(attachment) {
     } catch {
       throw new CliInputError(`could not read config file: ${attachment.file}`);
     }
-    return { source, source_format: format };
-  }
-  if (attachment.source !== void 0) {
-    return { source: attachment.source, source_format: inlineFormat(attachment.source) };
+    return { source, source_format: format };
+  }
+  if (attachment.source !== void 0) {
+    return { source: attachment.source, source_format: inlineFormat(attachment.source) };
+  }
+  throw new CliInputError(SOURCE_HINT);
+}
+async function resolveConfigId(client2, path, attachment) {
+  requireExactlyOne([attachment.config, attachment.file, attachment.source], ATTACHMENT_HINT);
+  if (attachment.config !== void 0) return attachment.config;
+  const { data } = await sdk_gen_exports.createAgentConfig({
+    client: client2,
+    path,
+    body: renderConfigSource(attachment)
+  });
+  return data.id;
+}
+async function currentProfileConfigId(client2, path) {
+  const { data } = await sdk_gen_exports.getAgentProfile({ client: client2, path });
+  return data.current_config_id;
+}
+
+// src/format.ts
+function pickFields(source, fields) {
+  const picked = {};
+  for (const field of fields) {
+    const value = source[field];
+    if (value !== void 0) picked[field] = value;
+  }
+  return picked;
+}
+function formatTable(columns) {
+  return (response) => ({
+    value: {
+      data: response.data.map((item) => pickFields(item, columns)),
+      next_cursor: response.next_cursor
+    },
+    columns
+  });
+}
+function formatRecord() {
+  return (data) => ({ value: data });
+}
+function formatVoid(message = "ok") {
+  return () => ({ value: message });
+}
+
+// src/integration-setup.ts
+import * as z23 from "zod";
+
+// src/slack-setup.ts
+import * as z22 from "zod";
+
+// src/mcp-oauth.ts
+import * as z21 from "zod";
+async function authorizeMcpOAuthSecret(options) {
+  const { data: start } = await sdk_gen_exports.startSecretMcpoAuth({
+    client: options.client,
+    path: { orgID: options.orgId },
+    body: options.request
+  });
+  options.onAuthorization(start.authorization_url);
+  return pollUntilDeadline({
+    expiresAt: start.expires_at,
+    expiredMessage: "MCP OAuth authorization expired before the secret was created",
+    async fetchOnce() {
+      const { data } = await sdk_gen_exports.listSecrets({
+        client: options.client,
+        path: { orgID: options.orgId },
+        query: { mcp_oauth_flow_id: start.flow_id, limit: 1 }
+      });
+      return data.data[0];
+    }
+  });
+}
+var zBrowserFlag = z21.boolean().default(true).describe("open the authorization URL in a browser");
+function openAuthorizationUrl(report, title, url4, browser) {
+  report.url(title, url4);
+  if (browser) {
+    openInBrowser(url4, (message) => {
+      report.warn(message);
+    });
+  }
+}
+var zMcpOAuthBody = zMcpoAuthStartRequest.extend({ browser: zBrowserFlag });
+async function runMcpOAuth(context) {
+  const { client: client2, path, body, report } = context;
+  const { browser, ...request } = body;
+  let secret;
+  try {
+    secret = await authorizeMcpOAuthSecret({
+      client: client2,
+      orgId: path.orgID,
+      request,
+      onAuthorization(url4) {
+        openAuthorizationUrl(report, "Authorize this MCP server in your browser", url4, browser);
+        report.start("Waiting for the secret to be created");
+      }
+    });
+  } catch (error) {
+    report.fail("Authorization failed");
+    throw error;
+  }
+  report.stop("Secret created");
+  report.info(`Secret ID: ${secret.id}`);
+  report.done();
+}
+
+// src/slack-setup.ts
+var zSlackBody = z22.object({
+  app_name: z22.string().optional().describe("name for a new Slack app"),
+  app_configuration_token: z22.string().optional().describe("Slack app configuration token for a new app"),
+  icon_filename: z22.string().optional().describe("filename for the new Slack app icon"),
+  icon_data_base64: z22.string().optional().describe("base64-encoded Slack app icon"),
+  client_id: z22.string().optional().describe("existing Slack app client ID"),
+  client_secret: z22.string().optional().describe("existing Slack app client secret"),
+  signing_secret: z22.string().optional().describe("existing Slack app signing secret"),
+  return_to: z22.string().optional().describe("console-relative path opened after authorization"),
+  browser: zBrowserFlag
+});
+function parseRequest(body) {
+  const createAppFields = [
+    body.app_name,
+    body.app_configuration_token,
+    body.icon_filename,
+    body.icon_data_base64
+  ];
+  const existingAppFields = [body.client_id, body.client_secret, body.signing_secret];
+  const createsApp = createAppFields.some((value) => value !== void 0);
+  const usesExistingApp = existingAppFields.some((value) => value !== void 0);
+  if (createsApp && usesExistingApp) {
+    throw new CliInputError(
+      "choose either --app-name with --app-configuration-token, or existing app credentials"
+    );
+  }
+  if (usesExistingApp) {
+    const draft2 = {
+      client_id: body.client_id,
+      client_secret: body.client_secret,
+      signing_secret: body.signing_secret
+    };
+    if (body.return_to !== void 0) draft2.return_to = body.return_to;
+    const result2 = zCreateIntegrationOAuthSetupRequest.safeParse(draft2);
+    if (!result2.success) {
+      throw new CliInputError(
+        `invalid existing Slack app parameters:
+${z22.prettifyError(result2.error)}`
+      );
+    }
+    return { kind: "existing-app", body: result2.data };
+  }
+  if (body.icon_filename !== void 0 && body.icon_data_base64 === void 0) {
+    throw new CliInputError("--icon-filename requires --icon-data-base64");
+  }
+  const draft = {
+    app_name: body.app_name,
+    app_configuration_token: body.app_configuration_token
+  };
+  if (body.icon_data_base64 !== void 0) {
+    draft.icon = { data_base64: body.icon_data_base64 };
+    if (body.icon_filename !== void 0) draft.icon.filename = body.icon_filename;
+  }
+  if (body.return_to !== void 0) draft.return_to = body.return_to;
+  const result = zCreateSlackSetupRequest.safeParse(draft);
+  if (!result.success) {
+    throw new CliInputError(
+      `invalid Slack app parameters:
+${z22.prettifyError(result.error)}
+Pass --app-name and --app-configuration-token, or existing app credentials.`
+    );
+  }
+  return { kind: "create-app", body: result.data };
+}
+async function runSlackIntegration(context) {
+  const { client: client2, path, body, report } = context;
+  const request = parseRequest(body);
+  const setupPath = {
+    orgID: path.orgID,
+    projectID: path.projectID,
+    integrationID: path.integrationID
+  };
+  let start;
+  let slackAppId;
+  if (request.kind === "create-app") {
+    const { data } = await sdk_gen_exports.createIntegrationSlackSetup({
+      client: client2,
+      path: setupPath,
+      body: request.body
+    });
+    start = data;
+    slackAppId = data.slack_app_id;
+  } else {
+    const { data } = await sdk_gen_exports.createIntegrationOAuthSetup({
+      client: client2,
+      path: setupPath,
+      body: request.body
+    });
+    start = data;
+  }
+  openAuthorizationUrl(
+    report,
+    "Authorize the Slack app in your browser",
+    start.oauth_url,
+    body.browser
+  );
+  report.start("Waiting for the Slack integration to connect");
+  let integration;
+  try {
+    integration = await pollUntilDeadline({
+      expiresAt: start.expires_at,
+      expiredMessage: "Slack authorization expired before the integration connected",
+      async fetchOnce() {
+        const { data } = await sdk_gen_exports.getIntegration({ client: client2, path: setupPath });
+        return data.state === "active" && data.last_oauth_flow_id === start.flow_id ? data : void 0;
+      }
+    });
+  } catch (error) {
+    report.fail("Slack authorization failed");
+    if (slackAppId !== void 0) {
+      report.warn(`Slack app ${slackAppId} was created, but Omnara setup was not completed`);
+    }
+    throw error;
   }
-  throw new CliInputError(SOURCE_HINT);
+  report.stop("Slack integration connected");
+  report.info(`Integration ID: ${integration.id} (${integration.name})`);
+  report.info(
+    "Reconnect preserves existing integration settings. Use integrations get/update to inspect or change the launcher."
+  );
+  report.done();
 }
-async function resolveConfigId(client2, path, attachment) {
-  requireExactlyOne([attachment.config, attachment.file, attachment.source], ATTACHMENT_HINT);
-  if (attachment.config !== void 0) return attachment.config;
-  const { data } = await sdk_gen_exports.createAgentConfig({
+
+// src/integration-setup.ts
+var zIntegrationProfilesBody = z23.object({
+  profile_ids: z23.array(zAgentProfileId).max(16).describe("repeat for each offered profile; preserves other integration settings")
+});
+async function runIntegrationProfilesUpdate(context) {
+  const { client: client2, path, body, report } = context;
+  const { data: integration } = await sdk_gen_exports.getIntegration({ client: client2, path });
+  await sdk_gen_exports.updateIntegration({
     client: client2,
     path,
-    body: renderConfigSource(attachment)
+    body: profileIntegrationProfileUpdate(integration, body.profile_ids)
   });
-  return data.id;
-}
-async function currentProfileConfigId(client2, path) {
-  const { data } = await sdk_gen_exports.getAgentProfile({ client: client2, path });
-  return data.current_config_id;
+  report.info("Profiles saved. One launches immediately; several show a menu to select one.");
+  report.done();
 }
-
-// src/format.ts
-function pickFields(source, fields) {
-  const picked = {};
-  for (const field of fields) {
-    const value = source[field];
-    if (value !== void 0) picked[field] = value;
+var integrationCommandGroups = [
+  {
+    name: "integrations",
+    summary: "Manage project integrations, credentials and launchers",
+    operations: [
+      op({
+        verb: "definitions",
+        summary: "List available integration implementations and capabilities",
+        fn: sdk_gen_exports.listIntegrationDefinitions,
+        path: zListIntegrationDefinitionsPath,
+        format: formatRecord()
+      }),
+      op({
+        verb: "list",
+        summary: "List project integrations",
+        fn: sdk_gen_exports.listIntegrations,
+        path: zListIntegrationsPath,
+        query: zListIntegrationsQuery,
+        format: formatTable(["id", "name", "integration_kind", "state"])
+      }),
+      op({
+        verb: "get",
+        summary: "Read integration setup and exported capabilities",
+        fn: sdk_gen_exports.getIntegration,
+        path: zGetIntegrationPath,
+        format: formatRecord()
+      }),
+      op({
+        verb: "create",
+        summary: "Create a disconnected integration and optional launcher",
+        fn: sdk_gen_exports.createIntegration,
+        path: zCreateIntegrationPath,
+        body: zCreateIntegrationBody,
+        format: formatRecord()
+      }),
+      op({
+        verb: "update",
+        summary: "Replace integration settings; name and kind are immutable",
+        fn: sdk_gen_exports.updateIntegration,
+        path: zUpdateIntegrationPath,
+        body: zUpdateIntegrationBody,
+        format: formatRecord()
+      }),
+      op({
+        verb: "configure",
+        summary: "Verify GitHub or Discord credentials for an integration; use integrations slack for Slack",
+        fn: sdk_gen_exports.configureIntegration,
+        path: zConfigureIntegrationPath,
+        body: zConfigureIntegrationBody,
+        format: formatRecord()
+      }),
+      flowOp({
+        verb: "slack",
+        summary: "Connect this integration to Slack through browser authorization",
+        path: zGetIntegrationPath,
+        body: zSlackBody,
+        run: runSlackIntegration
+      }),
+      flowOp({
+        verb: "profiles",
+        summary: "Edit offered Slack or Discord profiles",
+        path: zGetIntegrationPath,
+        body: zIntegrationProfilesBody,
+        run: runIntegrationProfilesUpdate
+      }),
+      op({
+        verb: "disconnect",
+        summary: "Stop provider access while retaining integration setup and agents",
+        fn: sdk_gen_exports.disconnectIntegration,
+        path: zDisconnectIntegrationPath,
+        format: formatRecord()
+      }),
+      op({
+        verb: "delete",
+        summary: "Delete integration setup and revoke its capabilities; retain agents",
+        fn: sdk_gen_exports.deleteIntegration,
+        path: zDeleteIntegrationPath,
+        format: formatVoid("deleted")
+      })
+    ]
   }
-  return picked;
-}
-function formatTable(columns) {
-  return (response) => ({
-    value: {
-      data: response.data.map((item) => pickFields(item, columns)),
-      next_cursor: response.next_cursor
-    },
-    columns
-  });
-}
-function formatRecord() {
-  return (data) => ({ value: data });
-}
-function formatVoid(message = "ok") {
-  return () => ({ value: message });
-}
+];
 
 // src/machine-setup.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { accessSync, constants, existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir2, release } from "node:os";
 import { basename, dirname as dirname2, isAbsolute, join as join2, resolve } from "node:path";
-import * as z20 from "zod";
+import * as z24 from "zod";
 var zMachineSetupBody = zConnectByoMachineRequest;
 async function connectMachine(context) {
   const { client: client2, path, body, report } = context;
@@ -11249,9 +12176,9 @@ var daemonConfigFileName = "daemon.json";
 var installLockFileName = "install.lock";
 var daemonLockFileName = "daemon.lock";
 var daemonLockPollMs = 250;
-var zDaemonConfigFile = z20.looseObject({
-  machine_id: z20.string().optional(),
-  api_url: z20.string().optional()
+var zDaemonConfigFile = z24.looseObject({
+  machine_id: z24.string().optional(),
+  api_url: z24.string().optional()
 });
 function daemonHome() {
   const override = process.env.OMNARA_HOME;
@@ -11533,67 +12460,10 @@ function runInstaller(report, apiUrl, token, machineId, home) {
 
 // src/mcp-add.ts
 import { isMap, isScalar as isScalar2, parseDocument } from "yaml";
-import * as z22 from "zod";
-
-// src/mcp-oauth.ts
-import * as z21 from "zod";
-async function authorizeMcpOAuthSecret(options) {
-  const { data: start } = await sdk_gen_exports.startSecretMcpoAuth({
-    client: options.client,
-    path: { orgID: options.orgId },
-    body: options.request
-  });
-  options.onAuthorization(start.authorization_url);
-  return pollUntilDeadline({
-    expiresAt: start.expires_at,
-    expiredMessage: "MCP OAuth authorization expired before the secret was created",
-    async fetchOnce() {
-      const { data } = await sdk_gen_exports.listSecrets({
-        client: options.client,
-        path: { orgID: options.orgId },
-        query: { mcp_oauth_flow_id: start.flow_id, limit: 1 }
-      });
-      return data.data[0];
-    }
-  });
-}
-var zBrowserFlag = z21.boolean().default(true).describe("open the authorization URL in a browser");
-function openAuthorizationUrl(report, title, url4, browser) {
-  report.url(title, url4);
-  if (browser) {
-    openInBrowser(url4, (message) => {
-      report.warn(message);
-    });
-  }
-}
-var zMcpOAuthBody = zMcpoAuthStartRequest.extend({ browser: zBrowserFlag });
-async function runMcpOAuth(context) {
-  const { client: client2, path, body, report } = context;
-  const { browser, ...request } = body;
-  let secret;
-  try {
-    secret = await authorizeMcpOAuthSecret({
-      client: client2,
-      orgId: path.orgID,
-      request,
-      onAuthorization(url4) {
-        openAuthorizationUrl(report, "Authorize this MCP server in your browser", url4, browser);
-        report.start("Waiting for the secret to be created");
-      }
-    });
-  } catch (error) {
-    report.fail("Authorization failed");
-    throw error;
-  }
-  report.stop("Secret created");
-  report.info(`Secret ID: ${secret.id}`);
-  report.done();
-}
-
-// src/mcp-add.ts
+import * as z25 from "zod";
 var SERVER_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9-]{0,31}$/;
 var zMcpAddBody = zMcpoAuthStartRequest.omit({ owner: true, name: true }).extend({
-  server_name: z22.string().regex(
+  server_name: z25.string().regex(
     SERVER_KEY_PATTERN,
     "must start with a letter and contain at most 32 letters, digits, or hyphens"
   ).describe("MCP server key used in the agent config"),
@@ -11606,7 +12476,7 @@ function targetLabel(target) {
 function serverEntry(url4, secretId) {
   return { url: url4, auth: { type: "oauth", secret_id: secretId } };
 }
-var zJsonRecord = z22.record(z22.string(), z22.json());
+var zJsonRecord = z25.record(z25.string(), z25.json());
 function prepareJsonConfig(config2, serverName, mcpUrl) {
   const json8 = zJsonText.safeParse(config2.source ?? "");
   if (!json8.success) throw new CliInputError("the current agent config contains invalid JSON");
@@ -11768,9 +12638,9 @@ function runProfileMcpAdd(context) {
 // src/memory-files.ts
 import { open, writeFile } from "node:fs/promises";
 import { buffer } from "node:stream/consumers";
-import * as z23 from "zod";
-var zMemoryUploadBody = z23.object({
-  file: z23.string().min(1).describe("local file to upload")
+import * as z26 from "zod";
+var zMemoryUploadBody = z26.object({
+  file: z26.string().min(1).describe("local file to upload")
 });
 async function loadMemoryUpload(file) {
   const handle = await open(file, "r");
@@ -11802,7 +12672,7 @@ var memoryDownloadOp = customOp({
       { path: options.path ?? null },
       "query flags"
     );
-    const output = parseWithSchema(z23.string().min(1), options.output, "--output");
+    const output = parseWithSchema(z26.string().min(1), options.output, "--output");
     const { response } = await sdk_gen_exports.downloadMemoryFile({ client: client2, path, query, parseAs: "stream" });
     const digest = response.headers.get(FILE_DIGEST_HEADER);
     if (!digest) throw new CliInputError("file response is missing its digest");
@@ -11816,10 +12686,10 @@ var memoryDownloadOp = customOp({
 import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
 import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 import * as tar from "tar";
-import * as z24 from "zod";
-var zCreateSkillCliBody = z24.object({
+import * as z27 from "zod";
+var zCreateSkillCliBody = z27.object({
   owner: zSkillOwnerInput,
-  archive: z24.string().min(1).describe("path to a skill directory (packed automatically) or a .zip/.tar.gz archive")
+  archive: z27.string().min(1).describe("path to a skill directory (packed automatically) or a .zip/.tar.gz archive")
 });
 var ARCHIVE_SUFFIXES = [".zip", ".tar.gz", ".tgz"];
 function assertPackable(dir) {
@@ -11860,130 +12730,9 @@ async function loadSkillArchive(archivePath) {
   return new File([new Uint8Array(readFileSync4(archivePath))], filename);
 }
 
-// src/slack-integration.ts
-import * as z25 from "zod";
-var zSlackBody = z25.object({
-  app_name: z25.string().optional().describe("name for a new Slack app"),
-  app_configuration_token: z25.string().optional().describe("Slack app configuration token for a new app"),
-  icon_filename: z25.string().optional().describe("filename for the new Slack app icon"),
-  icon_data_base64: z25.string().optional().describe("base64-encoded Slack app icon"),
-  client_id: z25.string().optional().describe("existing Slack app client ID"),
-  client_secret: z25.string().optional().describe("existing Slack app client secret"),
-  signing_secret: z25.string().optional().describe("existing Slack app signing secret"),
-  return_to: z25.string().optional().describe("console-relative path opened after authorization"),
-  browser: zBrowserFlag
-});
-function parseRequest(body) {
-  const createAppFields = [
-    body.app_name,
-    body.app_configuration_token,
-    body.icon_filename,
-    body.icon_data_base64
-  ];
-  const existingAppFields = [body.client_id, body.client_secret, body.signing_secret];
-  const createsApp = createAppFields.some((value) => value !== void 0);
-  const usesExistingApp = existingAppFields.some((value) => value !== void 0);
-  if (createsApp && usesExistingApp) {
-    throw new CliInputError(
-      "choose either --app-name with --app-configuration-token, or existing app credentials"
-    );
-  }
-  if (usesExistingApp) {
-    const draft2 = {
-      provider: "slack",
-      client_id: body.client_id,
-      client_secret: body.client_secret,
-      signing_secret: body.signing_secret
-    };
-    if (body.return_to !== void 0) draft2.return_to = body.return_to;
-    const result2 = zCreateIntegrationOAuthSetupRequest.safeParse(draft2);
-    if (!result2.success) {
-      throw new CliInputError(
-        `invalid existing Slack app parameters:
-${z25.prettifyError(result2.error)}`
-      );
-    }
-    return { kind: "existing-app", body: result2.data };
-  }
-  if (body.icon_filename !== void 0 && body.icon_data_base64 === void 0) {
-    throw new CliInputError("--icon-filename requires --icon-data-base64");
-  }
-  const draft = {
-    app_name: body.app_name,
-    app_configuration_token: body.app_configuration_token
-  };
-  if (body.icon_data_base64 !== void 0) {
-    draft.icon = { data_base64: body.icon_data_base64 };
-    if (body.icon_filename !== void 0) draft.icon.filename = body.icon_filename;
-  }
-  if (body.return_to !== void 0) draft.return_to = body.return_to;
-  const result = zCreateSlackSetupRequest.safeParse(draft);
-  if (!result.success) {
-    throw new CliInputError(
-      `invalid Slack app parameters:
-${z25.prettifyError(result.error)}
-Pass --app-name and --app-configuration-token, or existing app credentials.`
-    );
-  }
-  return { kind: "create-app", body: result.data };
-}
-async function runSlackIntegration(context) {
-  const { client: client2, path, body, report } = context;
-  const request = parseRequest(body);
-  const setupPath = {
-    orgID: path.orgID,
-    projectID: path.projectID,
-    agentProfileID: path.agentProfileID
-  };
-  let start;
-  let slackAppId;
-  if (request.kind === "create-app") {
-    const { data } = await sdk_gen_exports.createSlackSetup({ client: client2, path: setupPath, body: request.body });
-    start = data;
-    slackAppId = data.slack_app_id;
-  } else {
-    const { data } = await sdk_gen_exports.createIntegrationOAuthSetup({
-      client: client2,
-      path: setupPath,
-      body: request.body
-    });
-    start = data;
-  }
-  openAuthorizationUrl(
-    report,
-    "Approve the Slack integration in your browser",
-    start.oauth_url,
-    body.browser
-  );
-  report.start("Waiting for the Slack integration to be created");
-  let integration;
-  try {
-    integration = await pollUntilDeadline({
-      expiresAt: start.expires_at,
-      expiredMessage: "Slack authorization expired before the integration was created",
-      async fetchOnce() {
-        const { data } = await sdk_gen_exports.listIntegrationInstalls({
-          client: client2,
-          path: { orgID: path.orgID, projectID: path.projectID },
-          query: { oauth_flow_id: start.flow_id, limit: 1 }
-        });
-        return data.data[0];
-      }
-    });
-  } catch (error) {
-    report.fail("Slack authorization failed");
-    if (slackAppId !== void 0) {
-      report.warn(`Slack app ${slackAppId} was created, but the integration was not completed`);
-    }
-    throw error;
-  }
-  report.stop("Slack integration created");
-  report.info(`Integration ID: ${integration.id}`);
-  report.done();
-}
-
 // src/manifest.ts
 var commandGroups = [
+  ...integrationCommandGroups,
   {
     name: "agents",
     aliases: ["agent"],
@@ -12020,7 +12769,7 @@ var commandGroups = [
         body: zConfigAttachment.extend({
           profile: zAgentProfileId.optional(),
           name: zAgentName.optional(),
-          message: z26.string().optional()
+          message: z28.string().optional()
         }),
         transformBody: async ({ profile, name, message, ...attachment }, { client: client2, path }) => ({
           profile,
@@ -12061,7 +12810,7 @@ var commandGroups = [
       flowOp({
         verb: "mcp-add",
         summary: "Create an OAuth secret and add an MCP server to an agent",
-        path: z26.object({
+        path: z28.object({
           orgID: zOrganizationId,
           projectID: zProjectId,
           agentID: zAgentId
@@ -12077,7 +12826,7 @@ var commandGroups = [
         format: (response) => formatRecord()(response.agent_input),
         path: zCreateAgentInputPath,
         body: zCreateAgentInputBody.partial({ content_blocks: true }).extend({
-          message: z26.string().optional().describe("plain text to send as a single text block")
+          message: z28.string().optional().describe("plain text to send as a single text block")
         }).transform(({ message, content_blocks, ...rest }, ctx) => {
           if (content_blocks !== void 0 && message === void 0) {
             return { ...rest, content_blocks };
@@ -12086,7 +12835,7 @@ var commandGroups = [
             return { ...rest, content_blocks: [{ type: "text", text: message }] };
           }
           ctx.addIssue("pass exactly one of --message or --content-blocks");
-          return z26.NEVER;
+          return z28.NEVER;
         })
       })
     ],
@@ -12103,8 +12852,8 @@ var commandGroups = [
             format: formatAgentEventList,
             path: zListEventsPath,
             query: zListEventsQuery.extend({
-              before_sequence: z26.int().gte(0).optional(),
-              after_sequence: z26.int().gte(0).optional()
+              before_sequence: z28.int().gte(0).optional(),
+              after_sequence: z28.int().gte(0).optional()
             })
           }),
           agentEventsStreamOp
@@ -12158,8 +12907,7 @@ var commandGroups = [
         summary: "Show an organization overview",
         fn: sdk_gen_exports.getOrgOverview,
         format: formatRecord(),
-        path: zGetOrgOverviewPath,
-        query: zGetOrgOverviewQuery
+        path: zGetOrgOverviewPath
       }),
       op({
         verb: "delete",
@@ -12601,7 +13349,7 @@ var commandGroups = [
       flowOp({
         verb: "mcp-oauth",
         summary: "Create a secret through an MCP server OAuth flow",
-        path: z26.object({ orgID: zOrganizationId }),
+        path: z28.object({ orgID: zOrganizationId }),
         body: zMcpOAuthBody,
         run: runMcpOAuth
       })
@@ -12808,25 +13556,13 @@ var commandGroups = [
       flowOp({
         verb: "mcp-add",
         summary: "Create an OAuth secret and add an MCP server to an agent profile",
-        path: z26.object({
+        path: z28.object({
           orgID: zOrganizationId,
           projectID: zProjectId,
           agentProfileID: zAgentProfileId
         }),
         body: zMcpAddBody,
         run: runProfileMcpAdd
-      }),
-      flowOp({
-        verb: "slack",
-        aliases: ["slack-setup"],
-        summary: "Connect Slack to an agent profile through OAuth",
-        path: z26.object({
-          orgID: zOrganizationId,
-          projectID: zProjectId,
-          agentProfileID: zAgentProfileId
-        }),
-        body: zSlackBody,
-        run: runSlackIntegration
       })
     ]
   },