@aitne/daemon 0.1.7 → 0.1.9

package/dist/adapters/docs-qa-adapter.js

@@ -5,7 +5,7 @@ import { createLogger } from "../logging.js";
 const logger = createLogger("docs-qa-adapter");
 /**
  * DocsQAAdapter — SSE-based MessageAdapter for the operator-facing
- * Docs Q&A panel (DOCS_QA_B7_DESIGN.md §3.2).
+ * Docs Q&A panel (see DOCS_QA_B7_DESIGN.md).
  *
  * Parallel to `DashboardAdapter`: same SSE/HTTP transport, same
  * dispatcher entry point, but a separate channel registry and a
@@ -17,10 +17,10 @@ const logger = createLogger("docs-qa-adapter");
  * Implements:
  *   - `IDashboardStream`: dispatcher fans outbound calls out to this
  *     adapter via `CompositeDashboardStream`. The streaming validator
- *     splice lives inside `sendStreamChunk` per §11.3. The
- *     persistence-side `validateAndRewrite` runs in the dispatcher
- *     (gated on `isDocsQAMessage(event)` per §11.1) — not here — so
- *     this adapter never sees the full assembled output.
+ *     splice lives inside `sendStreamChunk`. The persistence-side
+ *     `validateAndRewrite` runs in the dispatcher (gated on
+ *     `isDocsQAMessage(event)`) — not here — so this adapter never
+ *     sees the full assembled output.
  *   - `MessageAdapter`: registered with `MessageHub` so the standard
  *     adapter lifecycle (`start`/`stop`) and `notificationEligible`
  *     contract apply. `sendMessage` is required by the interface but
@@ -50,12 +50,11 @@ export class DocsQAAdapter {
     /**
      * Register a new SSE client. Mints a `channelId`, emits the initial
      * `session_info` event so the dashboard knows the id to echo on
-     * subsequent POSTs (D5 — SSE-first channelId minting), and returns
-     * the id for the route's `onAbort` to unregister with.
+     * subsequent POSTs, and returns the id for the route's `onAbort` to
+     * unregister with.
      *
-     * No `resumeSessionId` parameter (§11.6): QA panel state lives in
-     * React state in-memory; the panel does not persist transcripts
-     * across reload.
+     * No `resumeSessionId` parameter: QA panel state lives in React state
+     * in-memory; the panel does not persist transcripts across reload.
      */
     registerClient(client) {
         const channelId = randomUUID();
@@ -89,7 +88,7 @@ export class DocsQAAdapter {
      * Translate an HTTP POST into a `MessageEvent` and feed it to the
      * dispatcher. Forces `intent: "docs_qa"`, `platform: "dashboard"`,
      * `isDm: true` regardless of the body — the route already guarded
-     * the body shape; this is the second forced-fields layer per §3.3.
+     * the body shape; this is the second forced-fields layer.
      */
     handleIncomingMessage(channelId, content, options) {
         const event = createEvent({
@@ -135,9 +134,10 @@ export class DocsQAAdapter {
     /**
      * Forward a streaming text delta through the per-channel citation
      * validator and emit the validated suffix. Unknown channelIds
-     * silently no-op (matches `dashboard-adapter.ts:211-218`) so the
-     * `CompositeDashboardStream` fan-out works without per-channel
-     * ownership tracking — only the adapter that owns the id emits.
+     * silently no-op (matches `dashboard-adapter.ts`'s unknown-channel
+     * no-op) so the `CompositeDashboardStream` fan-out works without
+     * per-channel ownership tracking — only the adapter that owns the
+     * id emits.
      */
     sendStreamChunk(channelId, chunk) {
         const entry = this.clients.get(channelId);
@@ -215,4 +215,3 @@ export class DocsQAAdapter {
             .map(([id]) => id);
     }
 }
-//# sourceMappingURL=docs-qa-adapter.js.map

package/dist/adapters/message-hub.d.ts

@@ -1,7 +1,7 @@
 import type Database from "better-sqlite3";
 import type { AgentConfig } from "../config.js";
 import { type NotificationDestinationPlatform } from "../messaging/constants.js";
-import type { MessageAdapter, ProcessingIndicatorHandle } from "./types.js";
+import type { MessageAdapter, OutboundAttachmentRef, ProcessingIndicatorHandle } from "./types.js";
 export declare class MessageDeliveryError extends Error {
     constructor(message: string);
 }
@@ -61,10 +61,9 @@ export declare class MessageHub {
     sendToExactUserDestinations(text: string, platforms: readonly string[], logContext?: ProactiveLogContext): Promise<MessageDelivery[]>;
     private deliverToResolvedPlatforms;
     sendToUser(text: string, platforms?: string[], logContext?: ProactiveLogContext): Promise<MessageDelivery[]>;
-    sendToPlatform(platform: string, channel: string, text: string, threadId?: string): Promise<MessageDelivery>;
+    sendToPlatform(platform: string, channel: string, text: string, threadId?: string, attachments?: OutboundAttachmentRef[]): Promise<MessageDelivery>;
     beginProcessingIndicator(platform: string, channel: string, threadId?: string): Promise<ProcessingIndicatorHandle>;
     startAll(): Promise<void>;
     stopAll(): Promise<void>;
 }
 export {};
-//# sourceMappingURL=message-hub.d.ts.map

package/dist/adapters/message-hub.js

@@ -34,8 +34,14 @@ export class MessageHub {
             logger.warn({ platform: adapter.platformName }, "Adapter already registered, replacing");
         }
         this.adapters.set(adapter.platformName, adapter);
+        // Seed as "connecting" — not "ok". The API server starts listening
+        // before startAll() runs during boot, so /health (and the dashboard
+        // status card) polled in the multi-second window between register() and
+        // startAll() would otherwise claim a live connection that hadn't
+        // happened yet. startAll() promotes each entry to "ok" / "error" once
+        // the adapter's start() resolves.
         this.adapterStatus.set(adapter.platformName, {
-            runtimeState: "ok",
+            runtimeState: "connecting",
             error: null,
         });
         logger.info({ platform: adapter.platformName }, "Adapter registered");
@@ -261,7 +267,7 @@ export class MessageHub {
     async sendToUser(text, platforms, logContext) {
         return this.sendToUserDestinations(text, platforms, logContext);
     }
-    async sendToPlatform(platform, channel, text, threadId) {
+    async sendToPlatform(platform, channel, text, threadId, attachments) {
         const adapter = this.adapters.get(platform);
         if (!adapter) {
             throw new MessageDeliveryError(`Adapter not found for platform "${platform}"`);
@@ -274,6 +280,7 @@ export class MessageHub {
             channel: resolvedChannel,
             text: this.decorateOutboundText(platform, text),
             threadId,
+            attachments,
         });
         if (channel === "user" && this.db) {
             upsertOwnerChannel(this.db, {
@@ -356,4 +363,3 @@ export class MessageHub {
         }
     }
 }
-//# sourceMappingURL=message-hub.js.map

package/dist/adapters/notification-manager.d.ts

@@ -5,6 +5,29 @@ import type { INotificationManager, ReplyActivityHandle } from "../core/dispatch
 import type { MessageReplyTarget } from "../core/dispatcher-types.js";
 import type { SignalDetector } from "../core/signal-detector.js";
 import type { MessageHub } from "./message-hub.js";
+export interface NotificationManagerOptions {
+    /**
+     * Maximum number of times `deliverReply` will attempt the originating
+     * platform before falling back to the configured proactive destinations.
+     * Tests pin this to 1 (no retry) or 3 (full path) and zero out the
+     * backoff to keep the suite fast. Production defaults — see
+     * {@link DEFAULT_REPLY_RETRY_ATTEMPTS} — keep the user-visible wait
+     * under one second even on the worst case.
+     */
+    replyRetryAttempts?: number;
+    /**
+     * Base backoff in ms; the actual delay between attempts is
+     * `base * 2^(attempt-1)` so 200 → 400 across the default 3-attempt
+     * loop. Set to 0 in tests.
+     */
+    replyRetryBackoffBaseMs?: number;
+    /**
+     * Test seam — replaces `setTimeout`-based sleeping with a synchronous
+     * resolver in unit tests. Production omits this and uses the real
+     * `setTimeout(...).unref()` so the timer never blocks daemon shutdown.
+     */
+    sleep?: (ms: number) => Promise<void>;
+}
 type DestinationMode = "default" | "configured_only";
 export declare class NotificationManager implements INotificationManager {
     private readonly messageHub;
@@ -15,6 +38,17 @@ export declare class NotificationManager implements INotificationManager {
     private readonly batchSlots;
     /** Per-`event.type` timestamp of the last actual delivery (ms since epoch). */
     private readonly lastDeliveryAtMs;
+    /**
+     * Per-event-type rate limiter. Tracks a per-type ring buffer of recent
+     * delivery timestamps; if a type exceeds {@link PER_TYPE_RATE_LIMIT}
+     * within {@link PER_TYPE_RATE_WINDOW_MS}, further sends of THAT type are
+     * dropped (logged) without consuming the global budget. Without this
+     * gate, a misbehaving emitter for one event type can monopolise the
+     * global `maxNotificationsPerHour` budget and silently starve unrelated
+     * notifications. Safety categories (`security`/`deadline`/`error`/
+     * `critical`) bypass this gate as they do the global one.
+     */
+    private readonly perTypeDeliveryWindow;
     /**
      * Single scheduled flush timer. When set, a callback is armed for the
      * earliest-pending queue's flush time. Queued sends reuse the existing
@@ -24,7 +58,10 @@ export declare class NotificationManager implements INotificationManager {
     private flushTimer;
     /** Flush-in-progress guard so overlapping timer fires don't double-send. */
     private flushing;
-    constructor(messageHub: MessageHub, db: Database.Database, config: AgentConfig);
+    private readonly replyRetryAttempts;
+    private readonly replyRetryBackoffBaseMs;
+    private readonly sleep;
+    constructor(messageHub: MessageHub, db: Database.Database, config: AgentConfig, options?: NotificationManagerOptions);
     /** Set the SignalDetector for implicit feedback tracking. */
     setSignalDetector(detector: SignalDetector): void;
     beginReplyActivity(event: MessageEvent): Promise<ReplyActivityHandle>;
@@ -48,7 +85,25 @@ export declare class NotificationManager implements INotificationManager {
         originSessionId?: number;
         replyTo?: MessageReplyTarget;
     }): Promise<void>;
-    /** Direct reply to a MessageEvent — bypasses quiet-hours, rate-limits, and batching. */
+    /**
+     * Direct reply to a MessageEvent — bypasses quiet-hours, rate-limits,
+     * and batching.
+     *
+     * Bounded retry with exponential backoff absorbs the transient
+     * platform-failure class (Slack 5xx, socket reset, WhatsApp relay flap).
+     * Without it, a one-shot path silently swallows those errors and leaves
+     * the user with no acknowledgement of their DM while `agent_actions`
+     * shows the turn as completed — the symptom is "agent feels stuck;
+     * user resends; agent double-runs the same turn".
+     *
+     * Final-fallback contract: when the originating platform refuses
+     * every attempt, we route the same payload through the proactive
+     * delivery path (`messageHub.sendToUser`) tagged as a safety-category
+     * `"error"` so it bypasses quiet hours and rate limits. The owner
+     * still hears about their reply on at least one channel they've
+     * configured. `deliverProactive` catches its own errors, so this is
+     * the terminal node — no further retry recursion.
+     */
     private deliverReply;
     /**
      * Shared direct-delivery primitive. Returns true on successful send,
@@ -68,6 +123,25 @@ export declare class NotificationManager implements INotificationManager {
      * notifications bypass the suppression gates.
      */
     private deliverProactive;
+    /**
+     * Close out `notification_log` rows left in the `batched` state by a
+     * prior daemon crash. The flush timer never re-fires after a crash —
+     * the in-memory queue dies with the process — so the corresponding
+     * `batched` row never transitions to `delivered` / `suppressed`. Without
+     * this sweep, those rows accumulate forever and the dashboard's
+     * notification feed shows ghost entries.
+     *
+     * 30-minute floor: the batch window is configurable but bounded; rows
+     * younger than that may legitimately still be in-flight (cooldown not
+     * yet elapsed) when the new daemon boots, so we only sweep what's
+     * provably orphaned. Idempotent — re-running it is a no-op.
+     *
+     * Called once from the boot path (event-pipeline) before adapters
+     * register, so the dashboard never sees the stale rows mid-recovery.
+     */
+    static closeStaleBatchedRows(db: Database.Database): {
+        closed: number;
+    };
     /**
      * Cancel any pending batch flush. Called on daemon shutdown.
      *
@@ -96,10 +170,34 @@ export declare class NotificationManager implements INotificationManager {
      * timer is rearmed at the new earliest due time.
      */
     private flushBatches;
+    /**
+     * Returns ms-since-epoch when the current quiet-hours window ends, or
+     * null when quiet hours are not active. Used by
+     * {@link scheduleBatchFlush} to defer pending batches past the
+     * quiet-hours boundary so they actually deliver instead of being
+     * suppressed at flush time.
+     *
+     * Thin wrapper around the shared `core/quiet-hours.ts` helper —
+     * NotificationManager and `ScheduleWatcher` (BROWSER_TASK_REDESIGN_PLAN
+     * §12 Q#5) share the same overnight-window math.
+     */
+    private nextQuietHoursEndMs;
     /** Check if current time is within quiet hours (uses configured timezone) */
     isQuietHours(): boolean;
+    /** Frozen snapshot of the configured window — kept inline so the
+     *  cache invalidates naturally on every call (config can hot-reload
+     *  via PATCH /api/config). */
+    private quietHoursWindow;
     /** Check if hourly or daily notification limits have been reached */
     private isRateLimited;
+    /**
+     * Per-type gate. True when this event type has hit
+     * {@link PER_TYPE_RATE_LIMIT} deliveries in the trailing
+     * {@link PER_TYPE_RATE_WINDOW_MS}. Trims expired timestamps inline so
+     * the ring buffer stays bounded.
+     */
+    private isTypeRateLimited;
+    private recordTypeDelivery;
     /** Check if the notification falls under a safety category */
     private isSafetyCategory;
     /** Infer notification priority from event */
@@ -108,4 +206,3 @@ export declare class NotificationManager implements INotificationManager {
     private logNotificationRows;
 }
 export {};
-//# sourceMappingURL=notification-manager.d.ts.map

package/dist/adapters/notification-manager.js

@@ -1,8 +1,28 @@
-import { isMessageEvent, getAgentDayBoundsUtc, nowInTimezone } from "@aitne/shared";
+import { isMessageEvent, getAgentDayBoundsUtc } from "@aitne/shared";
 import { randomUUID } from "node:crypto";
+import { isInQuietHoursAt, nextQuietHoursEndMs as computeNextQuietHoursEndMs, } from "../core/quiet-hours.js";
+import { MessageDeliveryError } from "./message-hub.js";
 import { recordProactiveForwardDeliveries } from "../core/channel-timeline.js";
 import { createLogger } from "../logging.js";
 const logger = createLogger("notification-manager");
+/**
+ * Log a delivery failure at the severity it deserves. A
+ * `MessageDeliveryError` means the message could not reach the user for an
+ * environmental reason — no proactive destination configured, or the
+ * configured one is momentarily unavailable (e.g. WhatsApp relay flap). That
+ * is a WARN-class condition, not a code fault: the failed `notification_log`
+ * row already records the miss for the dashboard, so emitting it at ERROR just
+ * floods the error stream (it was the single largest error category in the
+ * daemon log) and buries genuine faults. Anything else is unexpected — keep it
+ * at ERROR.
+ */
+function logDeliveryFailure(err, msg) {
+    if (err instanceof MessageDeliveryError) {
+        logger.warn({ err }, msg);
+        return;
+    }
+    logger.error({ err }, msg);
+}
 const NOOP_REPLY_ACTIVITY = {
     stop: async () => { },
 };
@@ -13,6 +33,34 @@ const SAFETY_CATEGORIES = [
     "error",
     "critical",
 ];
+/**
+ * Default bounded-retry shape for `deliverReply`. Sized so the operator's
+ * worst-case wait for an acknowledged DM is small (~600 ms across two
+ * backoffs at 200 ms + 400 ms) while still smoothing over the transient
+ * 5xx / socket-reset class of platform failures.
+ */
+const DEFAULT_REPLY_RETRY_ATTEMPTS = 3;
+const DEFAULT_REPLY_RETRY_BACKOFF_BASE_MS = 200;
+/**
+ * Per-type rate limit. Sized to allow legitimate bursts of the same
+ * notification type (e.g. three rapid-fire calendar updates) but stop a
+ * stuck-loop emitter from monopolising the global budget. 3 deliveries
+ * per 5 minutes per `event.type` matches the upper bound observed in
+ * normal operation; anything beyond is treated as a regression in the
+ * emitting code path and dropped with a warn log.
+ */
+const PER_TYPE_RATE_LIMIT = 3;
+const PER_TYPE_RATE_WINDOW_MS = 5 * 60 * 1000;
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        const t = setTimeout(resolve, ms);
+        // Don't keep the event loop alive solely because a retry timer is
+        // pending — daemon shutdown should not hang on an in-flight reply
+        // backoff.
+        if (typeof t.unref === "function")
+            t.unref();
+    });
+}
 function truncateSummary(message) {
     return message.length > 200 ? `${message.slice(0, 197)}...` : message;
 }
@@ -25,6 +73,17 @@ export class NotificationManager {
     batchSlots = new Map();
     /** Per-`event.type` timestamp of the last actual delivery (ms since epoch). */
     lastDeliveryAtMs = new Map();
+    /**
+     * Per-event-type rate limiter. Tracks a per-type ring buffer of recent
+     * delivery timestamps; if a type exceeds {@link PER_TYPE_RATE_LIMIT}
+     * within {@link PER_TYPE_RATE_WINDOW_MS}, further sends of THAT type are
+     * dropped (logged) without consuming the global budget. Without this
+     * gate, a misbehaving emitter for one event type can monopolise the
+     * global `maxNotificationsPerHour` budget and silently starve unrelated
+     * notifications. Safety categories (`security`/`deadline`/`error`/
+     * `critical`) bypass this gate as they do the global one.
+     */
+    perTypeDeliveryWindow = new Map();
     /**
      * Single scheduled flush timer. When set, a callback is armed for the
      * earliest-pending queue's flush time. Queued sends reuse the existing
@@ -34,10 +93,21 @@ export class NotificationManager {
     flushTimer = null;
     /** Flush-in-progress guard so overlapping timer fires don't double-send. */
     flushing = false;
-    constructor(messageHub, db, config) {
+    replyRetryAttempts;
+    replyRetryBackoffBaseMs;
+    sleep;
+    constructor(messageHub, db, config, options = {}) {
         this.messageHub = messageHub;
         this.db = db;
         this.config = config;
+        // Defensive clamp: a misconfigured `replyRetryAttempts <= 0` would
+        // turn `deliverReply` into a no-op (the for-loop body never runs)
+        // and silently break every DM reply. Clamp to a minimum of 1 so the
+        // worst legitimate misconfiguration is "no retries" rather than "no
+        // delivery at all".
+        this.replyRetryAttempts = Math.max(1, options.replyRetryAttempts ?? DEFAULT_REPLY_RETRY_ATTEMPTS);
+        this.replyRetryBackoffBaseMs = Math.max(0, options.replyRetryBackoffBaseMs ?? DEFAULT_REPLY_RETRY_BACKOFF_BASE_MS);
+        this.sleep = options.sleep ?? defaultSleep;
     }
     /** Set the SignalDetector for implicit feedback tracking. */
     setSignalDetector(detector) {
@@ -115,14 +185,64 @@ export class NotificationManager {
             originSessionId: options?.originSessionId,
         });
     }
-    /** Direct reply to a MessageEvent — bypasses quiet-hours, rate-limits, and batching. */
+    /**
+     * Direct reply to a MessageEvent — bypasses quiet-hours, rate-limits,
+     * and batching.
+     *
+     * Bounded retry with exponential backoff absorbs the transient
+     * platform-failure class (Slack 5xx, socket reset, WhatsApp relay flap).
+     * Without it, a one-shot path silently swallows those errors and leaves
+     * the user with no acknowledgement of their DM while `agent_actions`
+     * shows the turn as completed — the symptom is "agent feels stuck;
+     * user resends; agent double-runs the same turn".
+     *
+     * Final-fallback contract: when the originating platform refuses
+     * every attempt, we route the same payload through the proactive
+     * delivery path (`messageHub.sendToUser`) tagged as a safety-category
+     * `"error"` so it bypasses quiet hours and rate limits. The owner
+     * still hears about their reply on at least one channel they've
+     * configured. `deliverProactive` catches its own errors, so this is
+     * the terminal node — no further retry recursion.
+     */
     async deliverReply(message, event, priority) {
-        // Existing contract: MessageEvent replies swallow delivery errors
-        // (already logged + row recorded). Discard the boolean.
-        await this.deliverDirect(message, event, priority, {
+        const target = {
             platform: event.platform,
             channel: event.channel,
             threadId: event.threadId,
+        };
+        for (let attempt = 1; attempt <= this.replyRetryAttempts; attempt++) {
+            const delivered = await this.deliverDirect(message, event, priority, target);
+            if (delivered)
+                return;
+            if (attempt < this.replyRetryAttempts) {
+                const delay = this.replyRetryBackoffBaseMs * Math.pow(2, attempt - 1);
+                logger.info({
+                    attempt,
+                    nextDelayMs: delay,
+                    platform: target.platform,
+                    channel: target.channel,
+                    eventType: event.type,
+                }, "Reply delivery failed; backing off for retry");
+                if (delay > 0)
+                    await this.sleep(delay);
+            }
+        }
+        logger.warn({
+            platform: target.platform,
+            channel: target.channel,
+            attempts: this.replyRetryAttempts,
+            eventType: event.type,
+        }, "Reply delivery exhausted retries — falling back to proactive destinations");
+        // Final fallback. `category: "error"` puts this in
+        // SAFETY_CATEGORIES so the proactive path skips both
+        // `isQuietHours()` and `isRateLimited()` — the user is actively
+        // waiting for a response and we must not silence the fallback.
+        await this.deliverProactive({
+            message,
+            event,
+            priority,
+            category: "error",
+            destinationMode: "default",
         });
     }
     /**
@@ -163,7 +283,7 @@ export class NotificationManager {
                     status: "failed",
                 });
             }
-            logger.error({ err }, "Failed to send notification");
+            logDeliveryFailure(err, "Failed to send notification");
             return false;
         }
     }
@@ -203,6 +323,22 @@ export class NotificationManager {
             logger.info({ fromBatch: fromBatch ?? false, eventType: event.type }, "Notification suppressed (rate limit)");
             return;
         }
+        // Per-event-type secondary gate. Runs AFTER the global limiter so
+        // suppression order is consistent (global → per-type). A burst of
+        // the same type cannot starve unrelated notifications by exhausting
+        // the global budget alone — both gates have to allow the send.
+        if (!isSafety && this.isTypeRateLimited(event.type)) {
+            this.logNotificationRows({
+                dispatchId,
+                event,
+                messageSummary: summary,
+                priority,
+                deliveries: [],
+                status: "suppressed",
+            });
+            logger.warn({ fromBatch: fromBatch ?? false, eventType: event.type }, "Notification suppressed (per-type rate limit; check emitter for stuck loop)");
+            return;
+        }
         try {
             const logContext = {
                 dispatchId,
@@ -245,7 +381,9 @@ export class NotificationManager {
             // critical alert would silently freeze subsequent normal
             // notifications of the same event type into the batch queue.
             if (!isSafety) {
-                this.lastDeliveryAtMs.set(event.type, Date.now());
+                const now = Date.now();
+                this.lastDeliveryAtMs.set(event.type, now);
+                this.recordTypeDelivery(event.type, now);
             }
             if (this.signalDetector) {
                 for (const delivery of deliveries) {
@@ -264,8 +402,37 @@ export class NotificationManager {
                     status: "failed",
                 });
             }
-            logger.error({ err }, "Failed to send notification");
+            logDeliveryFailure(err, "Failed to send notification");
+        }
+    }
+    /**
+     * Close out `notification_log` rows left in the `batched` state by a
+     * prior daemon crash. The flush timer never re-fires after a crash —
+     * the in-memory queue dies with the process — so the corresponding
+     * `batched` row never transitions to `delivered` / `suppressed`. Without
+     * this sweep, those rows accumulate forever and the dashboard's
+     * notification feed shows ghost entries.
+     *
+     * 30-minute floor: the batch window is configurable but bounded; rows
+     * younger than that may legitimately still be in-flight (cooldown not
+     * yet elapsed) when the new daemon boots, so we only sweep what's
+     * provably orphaned. Idempotent — re-running it is a no-op.
+     *
+     * Called once from the boot path (event-pipeline) before adapters
+     * register, so the dashboard never sees the stale rows mid-recovery.
+     */
+    static closeStaleBatchedRows(db) {
+        const result = db
+            .prepare(`UPDATE notification_log
+            SET status = 'suppressed',
+                delivered_at = CURRENT_TIMESTAMP
+          WHERE status = 'batched'
+            AND created_at < datetime('now', '-30 minutes')`)
+            .run();
+        if (result.changes > 0) {
+            logger.warn({ closed: result.changes }, "Closed stale batched notification rows from prior crash");
         }
+        return { closed: result.changes };
     }
     /**
      * Cancel any pending batch flush. Called on daemon shutdown.
@@ -355,11 +522,23 @@ export class NotificationManager {
             if (dueAt < earliest)
                 earliest = dueAt;
         }
-        const delay = Math.max(0, earliest - now);
+        // If quiet hours are currently active, push the next flush
+        // attempt to the wall-clock moment they end. Without this guard,
+        // `flushBatches` would fire on the cooldown timer, hit `isQuietHours()`
+        // inside `deliverProactive`, and log the queued batch as `suppressed`
+        // — the user loses the message entirely instead of receiving it the
+        // moment quiet hours lift. `nextQuietHoursEndMs()` returns null when
+        // quiet hours are not configured or already over.
+        const quietEnd = this.isQuietHours() ? this.nextQuietHoursEndMs() : null;
+        const effective = quietEnd !== null && quietEnd > earliest ? quietEnd : earliest;
+        const delay = Math.max(0, effective - now);
         this.flushTimer = setTimeout(() => {
             this.flushTimer = null;
             void this.flushBatches();
         }, delay);
+        if (typeof this.flushTimer.unref === "function") {
+            this.flushTimer.unref();
+        }
     }
     /**
      * Flush every queue whose cooldown window has elapsed. Each due slot is
@@ -406,20 +585,33 @@ export class NotificationManager {
             this.scheduleBatchFlush();
         }
     }
+    /**
+     * Returns ms-since-epoch when the current quiet-hours window ends, or
+     * null when quiet hours are not active. Used by
+     * {@link scheduleBatchFlush} to defer pending batches past the
+     * quiet-hours boundary so they actually deliver instead of being
+     * suppressed at flush time.
+     *
+     * Thin wrapper around the shared `core/quiet-hours.ts` helper —
+     * NotificationManager and `ScheduleWatcher` (BROWSER_TASK_REDESIGN_PLAN
+     * §12 Q#5) share the same overnight-window math.
+     */
+    nextQuietHoursEndMs() {
+        return computeNextQuietHoursEndMs(new Date(), this.quietHoursWindow());
+    }
     /** Check if current time is within quiet hours (uses configured timezone) */
     isQuietHours() {
-        const local = nowInTimezone(this.config.timezone || undefined);
-        const currentMinutes = local.hours * 60 + local.minutes;
-        const [startH, startM] = this.config.quietHoursStart.split(":").map(Number);
-        const [endH, endM] = this.config.quietHoursEnd.split(":").map(Number);
-        const startMinutes = startH * 60 + startM;
-        const endMinutes = endH * 60 + endM;
-        if (startMinutes <= endMinutes) {
-            // Same day range (e.g., 09:00-17:00)
-            return currentMinutes >= startMinutes && currentMinutes < endMinutes;
-        }
-        // Overnight range (e.g., 23:00-07:00)
-        return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+        return isInQuietHoursAt(new Date(), this.quietHoursWindow());
+    }
+    /** Frozen snapshot of the configured window — kept inline so the
+     *  cache invalidates naturally on every call (config can hot-reload
+     *  via PATCH /api/config). */
+    quietHoursWindow() {
+        return {
+            start: this.config.quietHoursStart,
+            end: this.config.quietHoursEnd,
+            timezone: this.config.timezone || undefined,
+        };
     }
     /** Check if hourly or daily notification limits have been reached */
     isRateLimited() {
@@ -451,6 +643,36 @@ export class NotificationManager {
             .get(bounds.start, bounds.end);
         return dailyCount.cnt >= this.config.maxNotificationsPerDay;
     }
+    /**
+     * Per-type gate. True when this event type has hit
+     * {@link PER_TYPE_RATE_LIMIT} deliveries in the trailing
+     * {@link PER_TYPE_RATE_WINDOW_MS}. Trims expired timestamps inline so
+     * the ring buffer stays bounded.
+     */
+    isTypeRateLimited(eventType) {
+        const now = Date.now();
+        const cutoff = now - PER_TYPE_RATE_WINDOW_MS;
+        const recent = this.perTypeDeliveryWindow.get(eventType);
+        if (!recent)
+            return false;
+        // Trim in place — `recent` is the live array referenced by the map.
+        while (recent.length > 0 && recent[0] < cutoff)
+            recent.shift();
+        if (recent.length === 0) {
+            this.perTypeDeliveryWindow.delete(eventType);
+            return false;
+        }
+        return recent.length >= PER_TYPE_RATE_LIMIT;
+    }
+    recordTypeDelivery(eventType, atMs) {
+        const existing = this.perTypeDeliveryWindow.get(eventType);
+        if (existing) {
+            existing.push(atMs);
+        }
+        else {
+            this.perTypeDeliveryWindow.set(eventType, [atMs]);
+        }
+    }
     /** Check if the notification falls under a safety category */
     isSafetyCategory(category, priority) {
         if (category && SAFETY_CATEGORIES.includes(category)) {
@@ -533,4 +755,3 @@ export class NotificationManager {
         }
     }
 }
-//# sourceMappingURL=notification-manager.js.map