deepline 0.2.39 → 0.2.40

package/dist/cli/index.js

@@ -1044,7 +1044,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.39",
+  version: "0.2.40",
   contracts: {
     api: {
       name: "sdk-http-api",
@@ -1672,6 +1672,9 @@ var HttpClient = class {
       headers
     });
   }
+  async put(path, body, headers) {
+    return this.request(path, { method: "PUT", body, headers });
+  }
   /**
    * Send a DELETE request.
    *
@@ -1822,6 +1825,61 @@ function withCoworkNetworkHint(message) {
 ${COWORK_NETWORK_HINT}`;
 }
 
+// ../shared_libs/product-notifications/contract.ts
+var PRODUCT_NOTIFICATION_EVENT_CATALOG = [
+  {
+    id: "play.cron.succeeded",
+    label: "Cron success",
+    description: "A scheduled Play run completed successfully.",
+    source: "cron",
+    outcome: "succeeded",
+    defaultEnabled: true
+  },
+  {
+    id: "play.cron.failed",
+    label: "Cron failure",
+    description: "A scheduled Play could not start or its run reached a failed terminal state.",
+    source: "cron",
+    outcome: "failed",
+    defaultEnabled: true
+  },
+  {
+    id: "play.webhook.succeeded",
+    label: "Webhook success",
+    description: "An accepted webhook-triggered Play completed successfully.",
+    source: "webhook",
+    outcome: "succeeded",
+    defaultEnabled: true
+  },
+  {
+    id: "play.webhook.failed",
+    label: "Webhook failure",
+    description: "An accepted webhook-triggered Play reached a failed terminal state.",
+    source: "webhook",
+    outcome: "failed",
+    defaultEnabled: true
+  }
+];
+var PRODUCT_NOTIFICATION_EVENT_TYPE_SET = new Set(
+  PRODUCT_NOTIFICATION_EVENT_CATALOG.map((event) => event.id)
+);
+var PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES = [
+  "channels:read",
+  "chat:write",
+  "groups:read"
+];
+var PRODUCT_NOTIFICATION_RETRY_DELAYS_MS = [
+  0,
+  6e4,
+  5 * 6e4,
+  15 * 6e4,
+  60 * 6e4
+];
+var PRODUCT_NOTIFICATION_MAX_ATTEMPTS = PRODUCT_NOTIFICATION_RETRY_DELAYS_MS.length;
+var PRODUCT_NOTIFICATION_DELIVERY_LEASE_MS = 2 * 6e4;
+var PRODUCT_NOTIFICATION_SUCCESS_TTL_MS = 15 * 6e4;
+var PRODUCT_NOTIFICATION_FAILURE_TTL_MS = 24 * 60 * 6e4;
+
 // src/stream-reconnect.ts
 var STREAM_RECONNECT_BASE_DELAY_MS = 500;
 var STREAM_RECONNECT_MAX_DELAY_MS = 15e3;
@@ -5378,6 +5436,95 @@ var DeeplineClient = class {
     );
     return response.plays ?? [];
   }
+  /** Read product-notification destinations, subscriptions, event catalog, and DLQ health. */
+  async getNotificationSettings() {
+    return this.http.get("/api/v2/settings/notifications");
+  }
+  /** Start the Slack OAuth flow required by product notifications. */
+  async connectNotificationSlack(options) {
+    return this.http.post("/api/v2/integrations/connect", {
+      provider: "slack",
+      scopes: [...PRODUCT_NOTIFICATION_SLACK_OAUTH_SCOPES],
+      ...options?.successUrl ? { success_url: options.successUrl } : {},
+      ...options?.failureUrl ? { failure_url: options.failureUrl } : {}
+    });
+  }
+  /** List Slack channels visible to the connected Deepline Slack app. */
+  async listNotificationSlackChannels(query) {
+    const suffix = query ? `?query=${encodeURIComponent(query)}` : "";
+    return this.http.get(`/api/v2/settings/notifications/channels${suffix}`);
+  }
+  /** Select the Slack channel used for product notifications. */
+  async setNotificationSlack(channel) {
+    return this.http.put("/api/v2/settings/notifications", { channel });
+  }
+  /** Send one synchronous test ping and return Slack's delivery result. */
+  async testNotificationSlack() {
+    return this.http.post("/api/v2/settings/notifications/test", {});
+  }
+  /** Disable Slack product notifications without deleting the OAuth connection. */
+  async disableNotificationSlack() {
+    return this.http.delete("/api/v2/settings/notifications");
+  }
+  /** Enable or disable event IDs from the server-provided notification catalog. */
+  async setNotificationSubscriptions(eventTypes, enabled) {
+    return this.http.patch("/api/v2/settings/notifications/subscriptions", {
+      eventTypes,
+      enabled
+    });
+  }
+  /** List exhausted deliveries. Dead-lettered messages never replay automatically. */
+  async listNotificationDlq(limit = 25) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq?limit=${encodeURIComponent(String(limit))}`
+    );
+  }
+  /** Inspect one exhausted notification delivery. */
+  async getNotificationDlqDelivery(deliveryId) {
+    return this.http.get(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`
+    );
+  }
+  /** Explicitly retry or archive one dead-lettered notification delivery. */
+  async updateNotificationDlqDelivery(deliveryId, action) {
+    return this.http.post(
+      `/api/v2/settings/notifications/dlq/${encodeURIComponent(deliveryId)}`,
+      { action }
+    );
+  }
+  /** List the workspace's named notification rules. */
+  async getNotifications() {
+    return this.http.get("/api/v2/notifications");
+  }
+  /** List Slack channels available to an already-connected Slack integration. */
+  async listNotificationChannels(query) {
+    const suffix = query ? `?search=${encodeURIComponent(query)}` : "";
+    return this.http.get(`/api/v2/notifications/slack/channels${suffix}`);
+  }
+  /** Create a named notification routed through an existing provider integration. */
+  async createNotification(input2) {
+    return this.http.post("/api/v2/notifications", input2);
+  }
+  /** Update a notification's target, event selection, or enabled state. */
+  async updateNotification(notificationId, input2) {
+    return this.http.patch(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`,
+      input2
+    );
+  }
+  /** Send a validation ping to one notification. */
+  async testNotification(notificationId) {
+    return this.http.post(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}/test`,
+      {}
+    );
+  }
+  /** Archive one notification without touching its provider integration. */
+  async deleteNotification(notificationId) {
+    return this.http.delete(
+      `/api/v2/notifications/${encodeURIComponent(notificationId)}`
+    );
+  }
   /**
    * Search callable plays and return compact play descriptions.
    *
@@ -22743,6 +22890,20 @@ async function handlePlayList(args) {
     if (play.inputSchema || play.hasInputSchema) {
       process.stdout.write("    inputSchema: yes\n");
     }
+    const configuredTriggers = [
+      play.triggerStatus?.cron ? `cron=${play.triggerStatus.cron}` : null,
+      play.triggerStatus?.webhook ? `webhook=${play.triggerStatus.webhook}` : null
+    ].filter(Boolean);
+    if (configuredTriggers.length > 0) {
+      process.stdout.write(`    triggers: ${configuredTriggers.join(", ")}
+`);
+      if (play.triggerStatus?.blockedReason) {
+        process.stdout.write(
+          `    trigger issue: ${play.triggerStatus.blockedReason}
+`
+        );
+      }
+    }
     process.stdout.write(`    run: deepline plays run ${reference} --watch
 `);
   }
@@ -36037,6 +36198,7 @@ var SDK_SIDECAR_CRITICAL_PACKAGE_FILES = [
   "dist/bundling-sources/shared_libs/observability/telemetry.ts",
   "dist/bundling-sources/shared_libs/play-runtime/backend.ts",
   "dist/bundling-sources/shared_libs/plays/bundling/index.ts",
+  "dist/bundling-sources/shared_libs/product-notifications/contract.ts",
   "dist/bundling-sources/shared_libs/tool-execution-error.ts"
 ];
 var SDK_SIDECAR_CRITICAL_DEPENDENCY_FILES = [
@@ -37894,6 +38056,588 @@ Examples:
   });
 }
 
+// src/cli/commands/settings.ts
+var eventHelp = PRODUCT_NOTIFICATION_EVENT_CATALOG.map(
+  (event) => `  ${event.id.padEnd(28)} ${event.description}`
+).join("\n");
+function slackDestination(settings) {
+  return settings.destinations.find((entry) => entry.kind === "slack");
+}
+function eventLines(settings) {
+  const enabled = new Map(
+    settings.subscriptions.map((entry) => [entry.eventType, entry.enabled])
+  );
+  return settings.catalog.map(
+    (event) => `${event.id}: ${enabled.get(event.id) === true ? "enabled" : "disabled"} \u2014 ${event.description}`
+  );
+}
+function requireCatalogEvent(settings, eventType) {
+  const event = settings.catalog.find((entry) => entry.id === eventType);
+  if (!event) {
+    throw new Error(
+      `Unknown notification event "${eventType}". Run deepline settings notifications subscriptions list.`
+    );
+  }
+  return event;
+}
+async function printSettings(options) {
+  const settings = await new DeeplineClient().getNotificationSettings();
+  const slack = slackDestination(settings);
+  printCommandEnvelope(
+    {
+      settings,
+      render: {
+        sections: [
+          {
+            title: "Slack destination",
+            lines: slack ? [
+              `status: ${String(slack.status ?? "unknown")}`,
+              `channel: #${String(slack.channelName ?? slack.channelId ?? "unknown")}`,
+              ...slack.lastErrorMessage ? [`issue: ${String(slack.lastErrorMessage)}`] : []
+            ] : ["Not configured."]
+          },
+          { title: "subscriptions", lines: eventLines(settings) },
+          {
+            title: "dead letter queue",
+            lines: [
+              `${settings.dlq.count}${settings.dlq.capped ? "+" : ""} deliveries require review`
+            ]
+          }
+        ],
+        actions: slack ? [
+          {
+            label: "Validate Slack",
+            command: "deepline settings notifications test slack"
+          }
+        ] : [
+          {
+            label: "Connect Slack",
+            command: "deepline settings notifications connect slack --open"
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function registerSettingsCommands(program) {
+  const settings = program.command("settings").description("Manage workspace product settings.");
+  const notifications = settings.command("notifications").description(
+    "Configure Deepline product notifications and delivery safety."
+  ).addHelpText(
+    "after",
+    `
+Workflow:
+  1. deepline settings notifications connect slack --open
+  2. deepline settings notifications channels --query pipeline
+  3. deepline settings notifications set slack --channel '#pipeline-alerts'
+  4. deepline settings notifications test slack
+  5. deepline settings notifications subscriptions list
+
+Slack is the delivery integration. This command group only manages product
+notifications; there is no general integrations CLI.
+`
+  );
+  notifications.command("get").description("Show destination, subscriptions, and DLQ health.").option("--json", "Emit JSON output").action(printSettings);
+  notifications.command("connect").description("Start the OAuth connection required by a destination.").argument("<destination>", "Destination kind (currently slack)").option("--open", "Open the Slack authorization URL in a browser").option("--dry-run", "Describe the mutation without starting OAuth").option("--json", "Emit JSON output").action(
+    async (destination, options) => {
+      if (destination !== "slack")
+        throw new Error("Only slack is supported.");
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, destination, action: "start_oauth" },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().connectNotificationSlack();
+      const browser = options.open ? openInBrowser(result.redirect_url, { deduplicate: false }) : "not_requested";
+      printCommandEnvelope(
+        {
+          ...result,
+          browser,
+          render: {
+            sections: [
+              {
+                title: "Slack authorization",
+                lines: [result.redirect_url, `browser: ${browser}`]
+              }
+            ],
+            actions: [
+              {
+                label: "After authorization",
+                command: "deepline settings notifications set slack --channel '#channel'"
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("channels").description("List Slack channels visible to the connected Deepline app.").option("--query <text>", "Filter channels by name").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationSlackChannels(
+      options.query
+    );
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "Slack channels",
+              lines: result.channels.length ? result.channels.map(
+                (channel) => `#${channel.name} (${channel.id})${channel.isPrivate ? " private" : ""}`
+              ) : ["No visible channels matched."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("set").description("Set a product-notification destination.").argument("<destination>", "Destination kind (currently slack)").requiredOption("--channel <channel>", "Slack channel name or ID").option("--dry-run", "Validate intent without changing settings").option("--json", "Emit JSON output").action(
+    async (destination, options) => {
+      if (destination !== "slack")
+        throw new Error("Only slack is supported.");
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, destination, channel: options.channel },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().setNotificationSlack(
+        options.channel
+      );
+      printCommandEnvelope(
+        {
+          ok: true,
+          result,
+          render: {
+            sections: [
+              { title: "Slack destination saved", lines: [options.channel] }
+            ],
+            actions: [
+              {
+                label: "Validate delivery",
+                command: "deepline settings notifications test slack"
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("test").description("Send a validation ping to a destination.").argument("<destination>", "Destination kind (currently slack)").option("--dry-run", "Describe the external send without sending").option("--json", "Emit JSON output").action(async (destination, options) => {
+    if (destination !== "slack") throw new Error("Only slack is supported.");
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, destination, action: "send_test_ping" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await new DeeplineClient().testNotificationSlack();
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [{ title: "Slack validation", lines: [result.message] }]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("disable").description("Disable a product-notification destination.").argument("<destination>", "Destination kind (currently slack)").option("--dry-run", "Describe the mutation without changing settings").option("--json", "Emit JSON output").action(async (destination, options) => {
+    if (destination !== "slack") throw new Error("Only slack is supported.");
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, destination, action: "disable" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await new DeeplineClient().disableNotificationSlack();
+    printCommandEnvelope(
+      {
+        ok: true,
+        result,
+        render: {
+          sections: [{ title: "Slack destination", lines: ["disabled"] }]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  const subscriptions = notifications.command("subscriptions").description("List and configure supported notification events.").addHelpText(
+    "after",
+    `
+Supported events (shared product catalog):
+${eventHelp}
+`
+  );
+  subscriptions.command("list").description("List every supported event and its current state.").option("--json", "Emit JSON output").action(async (options) => {
+    const current = await new DeeplineClient().getNotificationSettings();
+    printCommandEnvelope(
+      {
+        catalog: current.catalog,
+        subscriptions: current.subscriptions,
+        render: {
+          sections: [{ title: "subscriptions", lines: eventLines(current) }]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  subscriptions.command("describe").description("Describe one event from the shared product catalog.").argument("<event>", "Event ID; run subscriptions list to enumerate").option("--json", "Emit JSON output").action(async (eventType, options) => {
+    const current = await new DeeplineClient().getNotificationSettings();
+    const event = requireCatalogEvent(current, eventType);
+    const subscription = current.subscriptions.find(
+      (entry) => entry.eventType === event.id
+    );
+    printCommandEnvelope(
+      {
+        event,
+        enabled: subscription?.enabled === true,
+        render: {
+          sections: [
+            {
+              title: event.id,
+              lines: [
+                event.description,
+                `enabled: ${subscription?.enabled === true}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  for (const enabled of [true, false]) {
+    subscriptions.command(enabled ? "enable" : "disable").description(`${enabled ? "Enable" : "Disable"} one supported event.`).argument("<event>", "Event ID; run subscriptions list to enumerate").option("--dry-run", "Validate intent without changing settings").option("--json", "Emit JSON output").action(async (eventType, options) => {
+      const client2 = new DeeplineClient();
+      const current = await client2.getNotificationSettings();
+      const event = requireCatalogEvent(current, eventType);
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, event, enabled },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client2.setNotificationSubscriptions(
+        [event.id],
+        enabled
+      );
+      printCommandEnvelope(
+        {
+          ok: true,
+          event: event.id,
+          enabled,
+          result,
+          render: {
+            sections: [
+              {
+                title: "subscription updated",
+                lines: [`${event.id}: ${enabled ? "enabled" : "disabled"}`]
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    });
+  }
+  const dlq = notifications.command("dlq").description("Inspect and explicitly resolve inert failed deliveries.");
+  dlq.command("list").option("--limit <count>", "Maximum deliveries", "25").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationDlq(
+      Number(options.limit)
+    );
+    const deliveries = result.deliveries ?? [];
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "dead letter queue",
+              lines: deliveries.length ? deliveries.map(
+                (entry) => `${String(entry._id)}: ${String(entry.lastErrorCode ?? "delivery_failed")}`
+              ) : ["empty"]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  dlq.command("get").argument("<delivery-id>").option("--json", "Emit JSON output").action(async (deliveryId, options) => {
+    const result = await new DeeplineClient().getNotificationDlqDelivery(
+      deliveryId
+    );
+    printCommandEnvelope(result, {
+      json: options.json
+    });
+  });
+  for (const action of ["retry", "archive"]) {
+    dlq.command(action).description(
+      `${action === "retry" ? "Replay once from attempt zero" : "Archive"} one delivery.`
+    ).argument("<delivery-id>").option("--dry-run", "Describe the mutation without changing state").option("--json", "Emit JSON output").action(async (deliveryId, options) => {
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, action, deliveryId },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().updateNotificationDlqDelivery(
+        deliveryId,
+        action
+      );
+      printCommandEnvelope(
+        { ok: true, action, deliveryId, result },
+        { json: options.json }
+      );
+    });
+  }
+}
+function notificationByName(settings, reference) {
+  const notification = (settings.notifications ?? []).find(
+    (entry) => entry.id === reference || entry.name === reference
+  );
+  if (!notification) {
+    throw new Error(
+      `No notification named "${reference}". Run deepline notifications list.`
+    );
+  }
+  return notification;
+}
+function parseSlackTarget(value) {
+  const match = /^slack:(.+)$/i.exec(value.trim());
+  if (!match?.[1]) {
+    throw new Error("Use --to slack:#channel.");
+  }
+  return match[1];
+}
+function collectEvent(value, previous = []) {
+  return [...previous, value];
+}
+function registerNotificationCommands(program) {
+  const notifications = program.command("notifications").description("Choose which Play outcomes notify which people and channels.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline notifications events
+  deepline notifications slack channels --search pipeline
+  deepline notifications add pipeline-watchdog --to slack:#pipeline-alerts --for play.cron.failed
+  deepline notifications test pipeline-watchdog
+
+Slack connections are managed in Dashboard \u2192 Integrations. This command only
+chooses the connected Slack channel and the events it receives.
+`
+  );
+  notifications.command("events").description("List the Play events available to a notification.").option("--json", "Emit JSON output").action(async (options) => {
+    const settings = await new DeeplineClient().getNotifications();
+    printCommandEnvelope(
+      {
+        events: settings.catalog,
+        render: {
+          sections: [
+            {
+              title: "available events",
+              lines: settings.catalog.length ? settings.catalog.map(
+                (event) => `${event.id}: ${event.description}`
+              ) : ["No notification events are available."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("list").description("List named notifications and their selected Play events.").option("--json", "Emit JSON output").option("--compact", "Emit only names, state, target, and event IDs").action(async (options) => {
+    const settings = await new DeeplineClient().getNotifications();
+    const rules = settings.notifications ?? [];
+    printCommandEnvelope(
+      {
+        notifications: options.compact ? rules.map((rule) => ({
+          id: rule.id,
+          name: rule.name,
+          enabled: rule.enabled,
+          target: `#${rule.target.name}`,
+          eventTypes: rule.eventTypes
+        })) : rules,
+        count: rules.length,
+        render: {
+          sections: [
+            {
+              title: "notifications",
+              lines: rules.length ? rules.map(
+                (rule) => `${rule.name}: ${rule.enabled ? "on" : "paused"} \u2192 #${rule.target.name} (${rule.eventTypes.join(", ") || "no events"})`
+              ) : [
+                "None yet. Add one with deepline notifications add <name> --to slack:#channel --for play.cron.failed."
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  notifications.command("get").argument("<name>", "Notification name or ID").description("Show one named notification.").option("--json", "Emit JSON output").action(async (name, options) => {
+    const rule = notificationByName(
+      await new DeeplineClient().getNotifications(),
+      name
+    );
+    printCommandEnvelope({ notification: rule }, { json: options.json });
+  });
+  notifications.command("add").argument("<name>", "Short stable name, for example pipeline-watchdog").requiredOption(
+    "--to <target>",
+    "Target, for example slack:#pipeline-alerts"
+  ).option(
+    "--for <event>",
+    "Event ID; repeat for more events. Run notifications events to list them",
+    collectEvent,
+    []
+  ).option("--dry-run", "Describe the notification without saving it").option("--json", "Emit JSON output").action(
+    async (name, options) => {
+      if (!options.for.length) {
+        throw new Error("Choose at least one event with --for <event>.");
+      }
+      const channel = parseSlackTarget(options.to);
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, name, target: options.to, eventTypes: options.for },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await new DeeplineClient().createNotification({
+        name,
+        provider: "slack",
+        channel,
+        eventTypes: options.for
+      });
+      printCommandEnvelope(
+        {
+          notification: result,
+          render: {
+            sections: [{ title: "notification saved", lines: [name] }],
+            actions: [
+              {
+                label: "Send a test",
+                command: `deepline notifications test ${name}`
+              }
+            ]
+          }
+        },
+        { json: options.json }
+      );
+    }
+  );
+  notifications.command("edit").argument("<name>", "Notification name or ID").option("--to <target>", "New target, for example slack:#pipeline-alerts").option(
+    "--for <event>",
+    "Replace selected events; repeat for more events. Run notifications events to list them",
+    collectEvent,
+    []
+  ).option("--dry-run", "Describe the change without saving it").option("--json", "Emit JSON output").action(
+    async (name, options) => {
+      const client2 = new DeeplineClient();
+      const rule = notificationByName(await client2.getNotifications(), name);
+      const channel = options.to ? parseSlackTarget(options.to) : rule.target.name;
+      const eventTypes = options.for.length ? options.for : rule.eventTypes;
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, notification: rule.id, channel, eventTypes },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client2.updateNotification(rule.id, {
+        name: rule.name,
+        channel,
+        eventTypes
+      });
+      printCommandEnvelope({ notification: result }, { json: options.json });
+    }
+  );
+  const slack = notifications.command("slack").description("Select a channel from the connected Slack integration.");
+  slack.command("channels").option("--search <text>", "Filter channel names").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await new DeeplineClient().listNotificationChannels(
+      options.search
+    );
+    printCommandEnvelope(
+      {
+        ...result,
+        render: {
+          sections: [
+            {
+              title: "Slack channels",
+              lines: result.channels.length ? result.channels.map((channel) => `#${channel.name}`) : ["No visible channels matched."]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+  });
+  for (const [command, enabled] of [
+    ["pause", false],
+    ["resume", true]
+  ]) {
+    notifications.command(command).argument("<name>", "Notification name or ID").option("--dry-run", "Describe the change without saving it").option("--json", "Emit JSON output").action(async (name, options) => {
+      const client2 = new DeeplineClient();
+      const rule = notificationByName(await client2.getNotifications(), name);
+      if (options.dryRun) {
+        printCommandEnvelope(
+          { dryRun: true, notification: rule.id, enabled },
+          { json: options.json }
+        );
+        return;
+      }
+      const result = await client2.updateNotification(rule.id, { enabled });
+      printCommandEnvelope({ notification: result }, { json: options.json });
+    });
+  }
+  notifications.command("test").argument("<name>", "Notification name or ID").option("--dry-run", "Describe the external send without sending").option("--json", "Emit JSON output").action(async (name, options) => {
+    const client2 = new DeeplineClient();
+    const rule = notificationByName(await client2.getNotifications(), name);
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, notification: rule.id, action: "send_test" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await client2.testNotification(rule.id);
+    printCommandEnvelope(
+      { ...result, notification: rule.name },
+      { json: options.json }
+    );
+  });
+  notifications.command("delete").argument("<name>", "Notification name or ID").description(
+    "Archive one notification without touching its provider integration."
+  ).option("--dry-run", "Describe the deletion without changing state").option("--json", "Emit JSON output").action(async (name, options) => {
+    const client2 = new DeeplineClient();
+    const rule = notificationByName(await client2.getNotifications(), name);
+    if (options.dryRun) {
+      printCommandEnvelope(
+        { dryRun: true, notification: rule.id, action: "archive" },
+        { json: options.json }
+      );
+      return;
+    }
+    const result = await client2.deleteNotification(rule.id);
+    printCommandEnvelope(
+      { ...result, notification: rule.name },
+      { json: options.json }
+    );
+  });
+}
+
 // ../shared_libs/cli/command-compatibility.json
 var command_compatibility_default = {
   enrich: {
@@ -39030,6 +39774,8 @@ Exit codes:
   registerSessionsCommands(program);
   registerWorkflowCommands(program);
   registerSecretsCommands(program);
+  registerSettingsCommands(program);
+  registerNotificationCommands(program);
   registerBillingCommands(program);
   registerMonitorsCommands(program);
   registerOrgCommands(program);