@vellumai/assistant 0.12.5-dev.202609251714.4e37a15 → 0.12.5-dev.202609251913.90d2e9d

package/ARCHITECTURE.md

@@ -906,6 +906,23 @@ graph LR
 
 ---
 
+## Automatic Done
+
+`src/conversations/auto-archive.ts` runs an opt-in automatic Done sweep after startup recovery, on assistant config or feature-flag invalidation, and hourly. It marks eligible inactive native chats through the existing `archived_at` state. Candidate selection and the conditional update share the same persisted eligibility predicates; runtime checks run synchronously with each conditional write. Explicit reopening records `last_reopened_at` to grant a full inactivity interval.
+
+```mermaid
+flowchart LR
+    TRIGGER[Startup recovery / config or feature-flag change / hourly timer] --> PAGE[Bounded candidate page]
+    PAGE --> GUARDIAN[Read pending guardian requests]
+    GUARDIAN --> CHECK[Recheck config and runtime activity]
+    CHECK --> CAS[Conditional SQLite Done update]
+    CAS --> SYNC[Conversation list and metadata invalidation]
+```
+
+Readiness, eligibility, restart behavior, and the gateway snapshot boundary are documented in [Automatic Done](docs/automatic-done.md).
+
+---
+
 ## Plugin-Declared Schedules: Declaration → Reconciler → cron_jobs
 
 Plugins contribute recurring schedules as a surface: directories under

package/docs/automatic-done.md

@@ -0,0 +1,32 @@
+# Automatic Done
+
+Chats Settings exposes `conversations.autoArchive` through the assistant config. `enabled` defaults to `false`; `afterDays` defaults to `7` and accepts `1`, `7`, `14`, or `30`. The worker additionally requires the `sidebar-done` feature flag so the setting cannot activate legacy archive behavior.
+
+Auto Archive marks eligible inactive chats **Done** by setting the existing `archived_at` field. The chat remains visible in All Chats and Done, retains its transcript, and can be reopened. No schedule is cancelled and no data is deleted. New visible activity uses the existing resurfacing path.
+
+## Eligibility
+
+Inactivity is elapsed wall time since the latest of the last message (or creation for an empty chat) and an explicit reopen. Title edits, read receipts, config edits and other `updated_at` writes do not count as conversation activity. Migration `386-conversations-last-reopened-at.ts` adds a nullable marker without backfilling or changing existing chats. Only an actual Done-to-open transition records that marker, giving a reopened chat a full configured interval.
+
+Candidates must be unarchived standard native chats. Native notification-origin chats are eligible; an external channel binding takes precedence over the legacy origin field. Pinned, private, scheduled, background, system, consolidation and child/subagent conversations are excluded. Chats with unread assistant output, pending guardian input, a live ACP session, a running workflow, an active mode session or a nonterminal subagent are excluded.
+
+The final runtime check also excludes accepted sends, queued/processing turns, voice residency, pending standalone surfaces, local interactions, background tool work, wake dispatches and unfinished turn finalization. ACP resume reservations are checked against their persisted parent before the resumed session registers as live.
+
+## Lifecycle and concurrency
+
+The assistant owns one worker, independent of client pages. Its first sweep waits for interrupted conversation recovery, database migration readiness and startup completion. Failed startup recovery leaves the worker paused until restart. Config or assistant feature-flag invalidation and an hourly timer trigger later sweeps; overlapping triggers coalesce. The gateway flag listener publishes invalidation only after its cache refresh succeeds, including reconnect catch-up, so consumers see the refreshed gate. A failed refresh emits no invalidation. Shutdown cancels retries, removes the subscription/timer and prevents a late recovery promise from starting work.
+
+Each sweep scans bounded pages of 100 candidates with an activity/id keyset. For every page, it reads the exhaustive pending guardian-request list through the gateway. A failed read leaves that page untouched. Final eligibility and the write run synchronously inside each SQLite retry attempt. The SQL compare-and-set checks sampled message/reopen cursors and all persisted eligibility again, so activity, pinning, input-related processing, workflow/session changes, or reopening during the asynchronous gateway read cannot overwrite newer state.
+
+Gateway-owned guardian requests live outside the assistant database. The page read is a snapshot, not a distributed transaction: a remote request created after that read cannot be atomically excluded by SQLite. Local interaction, processing and queue checks close the ordinary same-process window. The worker fails closed on an unavailable gateway or uncertain runtime state; the cross-service snapshot boundary remains explicit.
+
+Successful updates publish the existing conversation-list and per-conversation metadata invalidations once per changed page, including updates committed before a later failure. There is no new transport event or persistent worker cursor. A restart safely scans eligible rows again, and already Done rows are excluded.
+
+## Code and validation
+
+- `src/conversations/auto-archive.ts`: scheduling, startup barrier, guardian snapshot and invalidation batching.
+- `src/conversations/auto-archive-activity.ts`: synchronous runtime blockers.
+- `src/persistence/conversation-auto-archive.ts`: shared SQL eligibility, paging and conditional writes.
+- `src/persistence/conversation-crud.ts`: explicit reopen marker and existing activity resurfacing.
+
+Focused tests cover eligibility and cursor races, reopen grace, paging, pending input, retries, lifecycle cancellation, coalescing and client invalidation. Migration tests verify existing data and idempotence.

package/openapi.yaml

@@ -14462,6 +14462,8 @@ paths:
                         type: boolean
                       appPins:
                         type: boolean
+                      chatsSettings:
+                        type: boolean
                     required:
                       - memoryOptOut
                       - retryLastTurn
@@ -14696,6 +14698,8 @@ paths:
                         type: boolean
                       appPins:
                         type: boolean
+                      chatsSettings:
+                        type: boolean
                     required:
                       - memoryOptOut
                       - retryLastTurn
@@ -38727,6 +38731,41 @@ components:
     ConfigPatchRequest:
       type: object
       properties:
+        conversations:
+          anyOf:
+            - type: object
+              properties:
+                autoArchive:
+                  anyOf:
+                    - type: object
+                      properties:
+                        enabled:
+                          anyOf:
+                            - type: boolean
+                            - type: "null"
+                        afterDays:
+                          anyOf:
+                            - type: number
+                              enum:
+                                - 1
+                                - 7
+                                - 14
+                                - 30
+                            - type: "null"
+                      additionalProperties: {}
+                    - type: "null"
+              additionalProperties: {}
+            - type: "null"
+        notifications:
+          anyOf:
+            - type: object
+              properties:
+                newMessageEnabled:
+                  anyOf:
+                    - type: boolean
+                    - type: "null"
+              additionalProperties: {}
+            - type: "null"
         llm:
           type: object
           properties:
@@ -39460,6 +39499,42 @@ components:
     ConfigGetResponse:
       type: object
       properties:
+        conversations:
+          type: object
+          properties:
+            autoArchive:
+              type: object
+              properties:
+                enabled:
+                  default: false
+                  description: Automatically mark eligible inactive chats Done.
+                  type: boolean
+                afterDays:
+                  default: 7
+                  description: Elapsed days of inactivity before a chat is eligible for Done.
+                  type: number
+                  enum:
+                    - 1
+                    - 7
+                    - 14
+                    - 30
+              required:
+                - enabled
+                - afterDays
+              additionalProperties: {}
+          required:
+            - autoArchive
+          additionalProperties: {}
+        notifications:
+          type: object
+          properties:
+            newMessageEnabled:
+              default: true
+              description: Allow ordinary chat-reply alerts. Does not change unread state or action-required alerts.
+              type: boolean
+          required:
+            - newMessageEnabled
+          additionalProperties: {}
         llm:
           type: object
           properties:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.5-dev.202609251714.4e37a15",
+  "version": "0.12.5-dev.202609251913.90d2e9d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-evictor.test.ts

@@ -12,6 +12,7 @@ mock.module("../subagent/index.js", () => ({
 
 import {
   ConversationEvictor,
+  defaultMemoryThresholdBytes,
   type EvictableConversation,
 } from "../daemon/conversation-evictor.js";
 
@@ -268,6 +269,46 @@ describe("ConversationEvictor", () => {
       expect(resident.disposed).toBe(false);
       expect(idle.disposed).toBe(true);
     });
+
+    test("evicts a bounded batch per sweep, least recently used first", () => {
+      for (let i = 0; i < 15; i++) {
+        sessions.set(`conv-${i}`, createMockSession());
+      }
+      evictor = new ConversationEvictor(sessions, {
+        ttlMs: Number.MAX_SAFE_INTEGER,
+        maxConversations: Number.MAX_SAFE_INTEGER,
+        memoryThresholdBytes: 0,
+      });
+      for (let i = 0; i < 15; i++) {
+        evictor.touch(`conv-${i}`);
+      }
+
+      expect(evictor.sweep().memoryEvicted).toBe(10);
+      expect(sessions.has("conv-0")).toBe(false);
+      expect(sessions.has("conv-10")).toBe(true);
+      expect(evictor.sweep().memoryEvicted).toBe(5);
+      expect(sessions.size).toBe(0);
+    });
+
+    test("derives the threshold from the container limit at first sweep, not construction", () => {
+      const previous = process.env.VELLUM_MEMORY_LIMIT;
+      sessions.set("idle", createMockSession());
+      evictor = new ConversationEvictor(sessions, {
+        ttlMs: Number.MAX_SAFE_INTEGER,
+        maxConversations: Number.MAX_SAFE_INTEGER,
+      });
+      // Half of 1 MiB is far below any live RSS, so the phase must fire.
+      process.env.VELLUM_MEMORY_LIMIT = "1Mi";
+      try {
+        expect(evictor.sweep().memoryEvicted).toBe(1);
+      } finally {
+        if (previous === undefined) {
+          delete process.env.VELLUM_MEMORY_LIMIT;
+        } else {
+          process.env.VELLUM_MEMORY_LIMIT = previous;
+        }
+      }
+    });
   });
 
   describe("onEvict", () => {
@@ -326,3 +367,16 @@ describe("ConversationEvictor", () => {
     });
   });
 });
+
+describe("defaultMemoryThresholdBytes", () => {
+  const GIB = 1024 * 1024 * 1024;
+
+  test("is half the container limit", () => {
+    expect(defaultMemoryThresholdBytes(3 * GIB)).toBe(1.5 * GIB);
+    expect(defaultMemoryThresholdBytes(8 * GIB)).toBe(4 * GIB);
+  });
+
+  test("falls back to 3 GiB without a limit", () => {
+    expect(defaultMemoryThresholdBytes(null)).toBe(3 * GIB);
+  });
+});

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -1,5 +1,8 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { saveRawConfig } from "../config/loader.js";
+import type { NotificationChannel } from "../notifications/types.js";
+
 const evaluateSignalMock = mock();
 const enforceRoutingIntentMock = mock();
 const updateDecisionMock = mock();
@@ -8,6 +11,14 @@ const createEventMock = mock();
 const setEventDedupeKeyMock = mock();
 const dispatchDecisionMock = mock();
 const isPlatformClientConfiguredMock = mock();
+const writeHomeFeedItemForSignalMock = mock(
+  async (..._args: unknown[]) => null,
+);
+
+mock.module("../notifications/home-feed-side-effect.js", () => ({
+  writeHomeFeedItemForSignal: (...args: unknown[]) =>
+    writeHomeFeedItemForSignalMock(...args),
+}));
 
 mock.module("../channels/config.js", () => ({
   getDeliverableChannels: () => ["vellum", "telegram"],
@@ -101,6 +112,8 @@ import {
 } from "../notifications/emit-signal.js";
 
 beforeEach(() => {
+  saveRawConfig({});
+  writeHomeFeedItemForSignalMock.mockClear();
   evaluateSignalMock.mockReset();
   enforceRoutingIntentMock.mockReset();
   updateDecisionMock.mockReset();
@@ -121,6 +134,104 @@ beforeEach(() => {
   enforceRoutingIntentMock.mockImplementation((decision: unknown) => decision);
 });
 
+describe("emitNotificationSignal chat reply preference", () => {
+  test.each([
+    [false, false],
+    [true, true],
+    [false, true],
+    [true, false],
+  ])(
+    "preserves routing candidates when the setting changes %s -> %s",
+    async (initial, enabled) => {
+      saveRawConfig({ notifications: { newMessageEnabled: initial } });
+      const selectedChannels: NotificationChannel[] = [
+        "vellum",
+        "platform",
+        "telegram",
+      ];
+      const decision = {
+        shouldNotify: true,
+        selectedChannels,
+        reasoningSummary: "Selected reply delivery",
+        renderedCopy: {
+          vellum: { title: "Answer", body: "The result is ready." },
+        },
+        dedupeKey: "reply-1",
+        confidence: 1,
+        fallbackUsed: false,
+        persistedDecisionId: "decision-1",
+      };
+      evaluateSignalMock.mockResolvedValue(decision);
+      enforceRoutingIntentMock.mockReturnValue(decision);
+      runDeterministicChecksMock.mockImplementation(async () => {
+        await Promise.resolve();
+        saveRawConfig({ notifications: { newMessageEnabled: enabled } });
+        return { passed: true };
+      });
+      const result = await emitNotificationSignal({
+        sourceEventName: "chat.assistant_reply",
+        sourceChannel: "vellum",
+        sourceContextId: "conv-1",
+        attentionHints: {
+          urgency: "high",
+          requiresAction: false,
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+        routingIntent: "all_channels",
+      });
+      expect(runDeterministicChecksMock.mock.calls[0]?.[1]).toMatchObject({
+        selectedChannels: decision.selectedChannels,
+      });
+      expect(result.selectedChannels).toEqual(selectedChannels);
+      expect(result.dispatched).toBe(true);
+      expect(dispatchDecisionMock.mock.calls[0]?.[1]).toMatchObject({
+        shouldNotify: true,
+        selectedChannels,
+      });
+      expect(writeHomeFeedItemForSignalMock).toHaveBeenCalledTimes(1);
+      expect(writeHomeFeedItemForSignalMock.mock.calls[0]?.[1]).toMatchObject({
+        shouldNotify: true,
+        selectedChannels,
+      });
+      expect(updateDecisionMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test.each([
+    "schedule.result",
+    "guardian.question",
+    "ingress.access_request",
+    "activity.failed",
+    "chat.assistant_reply.extra",
+  ])("preserves platform selection for %s", async (sourceEventName) => {
+    saveRawConfig({ notifications: { newMessageEnabled: false } });
+    evaluateSignalMock.mockResolvedValue({
+      shouldNotify: true,
+      selectedChannels: ["vellum", "platform"],
+      reasoningSummary: "Urgent delivery",
+      renderedCopy: { vellum: { title: "Alert", body: "Action required." } },
+      dedupeKey: "alert-1",
+      confidence: 1,
+      fallbackUsed: false,
+      persistedDecisionId: "decision-1",
+    });
+    const result = await emitNotificationSignal({
+      sourceEventName,
+      sourceChannel: "vellum",
+      sourceContextId: "conv-1",
+      attentionHints: {
+        urgency: "critical",
+        requiresAction: true,
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+    });
+    expect(result.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(updateDecisionMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("emitNotificationSignal routing intent re-persistence", () => {
   test("re-persists selectedChannels/reasoningSummary when enforcement changes the decision", async () => {
     const preDecision = {

package/src/__tests__/gateway-flag-listener.test.ts

@@ -26,11 +26,12 @@ mock.module("../ipc/socket-path.js", () => ({
 // ---------------------------------------------------------------------------
 let refreshCallCount = 0;
 let refreshReturnsLoaded = true;
+let pendingRefresh: Promise<boolean> | undefined;
 
 mock.module("../config/assistant-feature-flags.js", () => ({
   refreshOverridesFromGateway: async () => {
     refreshCallCount++;
-    return refreshReturnsLoaded;
+    return pendingRefresh ?? refreshReturnsLoaded;
   },
   initFeatureFlagOverrides: async () => true,
   clearFeatureFlagOverridesCache: () => {},
@@ -136,6 +137,7 @@ describe("gateway-flag-listener", () => {
     mkdirSync(testRoot, { recursive: true });
     refreshCallCount = 0;
     refreshReturnsLoaded = true;
+    pendingRefresh = undefined;
     publishedTagSets = [];
     reconcileCallCount = 0;
     reconcileReturns = false;
@@ -177,7 +179,7 @@ describe("gateway-flag-listener", () => {
     expect(refreshCallCount).toBe(2);
   });
 
-  test("broadcasts feature-flags sync_changed when flags change", async () => {
+  test("broadcasts feature-flags sync_changed after connect and flag changes", async () => {
     await new Promise<void>((resolve) => {
       testServer.server.listen(socketPath, resolve);
     });
@@ -186,19 +188,59 @@ describe("gateway-flag-listener", () => {
     await testServer.waitForClient();
     await new Promise((r) => setTimeout(r, 100));
 
-    // Connect refresh should not broadcast — only an actual change does.
-    expect(publishedTagSets.length).toBe(0);
+    expect(publishedTagSets.length).toBe(1);
 
     testServer.emit("feature_flags_changed");
     await new Promise((r) => setTimeout(r, 100));
 
-    expect(publishedTagSets.length).toBe(1);
-    expect(publishedTagSets[0]).toEqual([
+    expect(publishedTagSets.length).toBe(2);
+    expect(publishedTagSets[1]).toEqual([
       "feature-flags:client",
       "feature-flags:assistant",
     ]);
   });
 
+  test("defers invalidation until the flag-change refresh settles", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    publishedTagSets = [];
+    const refresh = Promise.withResolvers<boolean>();
+    pendingRefresh = refresh.promise;
+    testServer.emit("feature_flags_changed");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(refreshCallCount).toBe(2);
+    expect(publishedTagSets).toEqual([]);
+    expect(reconcileCallCount).toBe(1);
+    refresh.resolve(true);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
+    expect(reconcileCallCount).toBe(2);
+  });
+
+  test("defers connection invalidation until the refreshed cache is available", async () => {
+    const refresh = Promise.withResolvers<boolean>();
+    pendingRefresh = refresh.promise;
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(refreshCallCount).toBe(1);
+    expect(publishedTagSets).toEqual([]);
+    refresh.resolve(true);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
+  });
+
   test("reconciles flag-gated profiles and broadcasts config_changed when the profile set changes", async () => {
     reconcileReturns = true;
     await new Promise<void>((resolve) => {
@@ -251,12 +293,22 @@ describe("gateway-flag-listener", () => {
     // The profile reconcile/broadcast are gated on flags actually loading.
     expect(reconcileCallCount).toBe(0);
     expect(configChangedCount).toBe(0);
+    expect(publishedTagSets).toEqual([]);
 
     testServer.emit("feature_flags_changed");
     await new Promise((r) => setTimeout(r, 100));
 
     expect(reconcileCallCount).toBe(0);
     expect(configChangedCount).toBe(0);
+    expect(publishedTagSets).toEqual([]);
+    refreshReturnsLoaded = true;
+    testServer.emit("feature_flags_changed");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(reconcileCallCount).toBe(1);
+    expect(configChangedCount).toBe(1);
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
   });
 
   test("reconciles profiles when the refresh reports flags loaded", async () => {
@@ -318,6 +370,7 @@ describe("gateway-flag-listener", () => {
     await new Promise((r) => setTimeout(r, 100));
     const countAfterReconnect = refreshCallCount;
     expect(countAfterReconnect).toBeGreaterThan(0);
+    expect(publishedTagSets).toHaveLength(countAfterReconnect);
 
     const payload = JSON.stringify({ event: "feature_flags_changed" }) + "\n";
     secondClient!.write(payload);

package/src/__tests__/identity-routes.test.ts

@@ -166,6 +166,7 @@ describe("identity routes — health endpoint", () => {
         memoryOptOut: true,
         retryLastTurn: true,
         appPins: true,
+        chatsSettings: true,
       });
 
       // Profiler should either be absent or show enabled: false
@@ -492,9 +493,9 @@ describe("identity routes — /readyz readiness gate", () => {
     expect(body.ready).toBe(false);
     expect(body.reason).toBe("db_migrations_failed");
     expect((body.dbMigrations as Record<string, unknown>).state).toBe("failed");
-    expect((body.dbMigrations as Record<string, unknown>).failedMigrations).toEqual(
-      [{ name: "flakyStep", error: "transient failure" }],
-    );
+    expect(
+      (body.dbMigrations as Record<string, unknown>).failedMigrations,
+    ).toEqual([{ name: "flakyStep", error: "transient failure" }]);
   });
 
   test("returns 200 even if CES is down", async () => {

package/src/__tests__/notification-platform-adapter.test.ts

@@ -1,11 +1,14 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { saveRawConfig } from "../config/loader.js";
+
 // ── Mock logger ──────────────────────────────────────────────────────────────
 
 // ── Mock sleep so retry tests don't slow down the suite ──────────────────────
 
+let onRetrySleep: () => Promise<void> = async () => {};
 mock.module("../util/retry.js", () => ({
-  sleep: async (_ms: number): Promise<void> => {},
+  sleep: async (_ms: number): Promise<void> => onRetrySleep(),
   isRetryableStatus: (status: number): boolean =>
     status === 429 || status >= 500,
   isRetryableNetworkError: (error: unknown): boolean => {
@@ -41,10 +44,12 @@ const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> =
   [];
 const fetchErrors: Error[] = [];
 let clientAvailable = true;
+let onClientCreation: () => Promise<void> = async () => {};
 
 mock.module("../platform/client.js", () => ({
   VellumPlatformClient: {
     create: async () => {
+      await onClientCreation();
       if (!clientAvailable) {
         return null;
       }
@@ -117,12 +122,89 @@ function makeDestination(
 
 describe("PlatformPushAdapter", () => {
   beforeEach(() => {
+    saveRawConfig({});
     fetchCalls.length = 0;
     fetchResponses.length = 0;
     fetchErrors.length = 0;
     clientAvailable = true;
+    onRetrySleep = async () => {};
+    onClientCreation = async () => {};
+  });
+
+  test("skips a disabled chat reply without sending a native push", async () => {
+    saveRawConfig({ notifications: { newMessageEnabled: false } });
+    const result = await new PlatformPushAdapter().send(
+      makePayload({ sourceEventName: "chat.assistant_reply" }),
+      makeDestination(),
+    );
+    expect(result).toMatchObject({
+      success: false,
+      skipped: true,
+      remotePushAccepted: false,
+    });
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("rechecks the setting after platform client creation", async () => {
+    onClientCreation = async () => {
+      saveRawConfig({ notifications: { newMessageEnabled: false } });
+    };
+    const result = await new PlatformPushAdapter().send(
+      makePayload({ sourceEventName: "chat.assistant_reply" }),
+      makeDestination(),
+    );
+    expect(result).toMatchObject({
+      success: false,
+      skipped: true,
+      remotePushAccepted: false,
+    });
+    expect(fetchCalls).toHaveLength(0);
   });
 
+  test.each([false, true])(
+    "stops retries after disabling replies (accepted push: %s)",
+    async (accepted) => {
+      fetchResponses.push({
+        ok: false,
+        status: 503,
+        body: accepted ? '{"accepted_platforms":["ios"]}' : "{}",
+      });
+      onRetrySleep = async () => {
+        saveRawConfig({ notifications: { newMessageEnabled: false } });
+      };
+      const result = await new PlatformPushAdapter().send(
+        makePayload({ sourceEventName: "chat.assistant_reply" }),
+        makeDestination(),
+      );
+      expect(fetchCalls).toHaveLength(1);
+      expect(result).toMatchObject({
+        success: accepted,
+        skipped: !accepted,
+        remotePushAccepted: accepted,
+        remotePushPlatforms: accepted ? ["ios"] : undefined,
+      });
+    },
+  );
+
+  test.each([
+    "schedule.result",
+    "schedule.notify",
+    "guardian.question",
+    "activity.failed",
+    "chat.assistant_reply.extra",
+  ])(
+    "keeps %s native push enabled when ordinary reply alerts are off",
+    async (sourceEventName) => {
+      saveRawConfig({ notifications: { newMessageEnabled: false } });
+      const result = await new PlatformPushAdapter().send(
+        makePayload({ sourceEventName }),
+        makeDestination(),
+      );
+      expect(result.success).toBe(true);
+      expect(fetchCalls).toHaveLength(1);
+    },
+  );
+
   test("channel is 'platform'", () => {
     expect(new PlatformPushAdapter().channel).toBe("platform");
   });