@aitne/daemon 0.1.9 → 0.1.10

package/dist/core/injection-policy.d.ts

@@ -105,3 +105,85 @@ export interface InjectionPolicy {
  * not a third boolean on this struct.
  */
 export declare function getInjectionPolicy(eventOrProcessKey: string): InjectionPolicy;
+/**
+ * FEEDBACK_LEARNING_LOOP_DESIGN.md §5 — the Stage-3 *opt-in* resolver for the
+ * feedback learning-loop's `<agent_lessons>` blocks.
+ *
+ * Co-located with `getInjectionPolicy` on purpose: this module is the single
+ * source of truth for "which surface sees which always-/sometimes-injected
+ * block", and the design explicitly rejects scattering an
+ * `isMessageEvent(event) || isNotifyDecidingRoutine(event)` check across
+ * `context-builder.ts` (it would re-introduce the fragmentation V20
+ * consolidated away). `<agent_lessons>` is **default-off** — only the handful
+ * of surfaces below want it — so it is an *opt-in* resolver, not a member of
+ * the `alwaysBlocks` *opt-out* set (which is for default-*on* heavy blocks a
+ * narrow routine sheds; a positive opt-out member would be the wrong polarity).
+ *
+ * Three fields, matching the design's documented shape:
+ *
+ *  - `global` — inject `policies/agent-lessons.md ## Lessons` (scope `agent`:
+ *    global agent-operating behaviour — notification discipline, filter
+ *    quality). Phase 3 consumer: `ContextBuilder`.
+ *  - `slim`   — use the hard-2048-byte, top-N-by-score variant on the hourly
+ *    notify turn (§6). Only `routine.hourly_check` sets it. Implies `global`.
+ *  - `self`   — eligible for the per-agent `policies/agents/<slug>/lessons.md`
+ *    block (scope `agent:<slug>`). **Phase 4 consumer.** The builder reads it
+ *    next to `<agent_identity>` and gates it on a resolved, path-safe slug
+ *    stamped onto `event.data.agentId` at the dispatch site — `self === true`
+ *    here means "this surface *may* carry self lessons"; an actual injection
+ *    additionally requires the run to be bound to an Agent. `hourly_check`
+ *    keeps `self: false` so the slim notify turn never carries a second block.
+ *
+ * **Surface keying is grounded in the real event-type strings build() sees,
+ * not the design's prose shorthand:**
+ *  - DM / dashboard messages arrive as `message.*` (dashboard DMs included —
+ *    they are `message.*` with `platform="dashboard"`).
+ *  - The morning routine's *notify-deciding* stage builds context as
+ *    `routine.morning_routine_today` (Stage A). The umbrella
+ *    `routine.morning_routine` never reaches `build()` (the orchestrator
+ *    decomposes it into the two stage events), and Stage B
+ *    (`routine.morning_routine_journal`) is a lite journal author that decides
+ *    no notifications — injecting lessons there would be wasted bytes against
+ *    the §0 cost constraint. So Stage A is keyed, the umbrella and Stage B are
+ *    not.
+ *  - `routine.hourly_check` is the escalated Stage-3 LLM/notify turn (gate
+ *    Layers 1–3 are code and build no prompt), so the slim block bites exactly
+ *    where the notify decision is made. The `.triage` lite classification is
+ *    intentionally excluded.
+ *  - `scheduled.task` is **binding-aware** (Phase 4). A *bare* scheduled.task
+ *    (generic close-the-loop task, observer-emitted cron, roadmap refresh — no
+ *    resolved Agent) gets nothing, preserving the §5 last-row opt-out. A
+ *    scheduled.task that *resolves to an Agent* (`agentBound`, a user-defined
+ *    task-output Agent — `report-writer` et al.) is the §5 "Defined-agent
+ *    execution" row: it gets global + self so feedback on the Agent's output
+ *    reaches that Agent (requirement #3). The builder supplies the binding fact
+ *    via `opts.agentBound` so the decision still lives in this one module rather
+ *    than fragmenting a `resolveAgentId() != null` check into `context-builder.ts`.
+ *  - Everything else — observers, `fetch_window`, `today_refresh`, and any
+ *    unlisted key — gets nothing (the §5 "this surface gets almost nothing"
+ *    row, mirroring `buildFetchWindowContext`).
+ */
+export interface AgentLessonsInjection {
+    /** Inject the global `policies/agent-lessons.md ## Lessons` block. */
+    readonly global: boolean;
+    /**
+     * Eligible for the per-agent `policies/agents/<slug>/lessons.md` block.
+     * Phase 4 consumer — gated additionally on a resolved slug at the build site.
+     */
+    readonly self: boolean;
+    /** Use the slim, hard-2048-byte, top-N-by-score hourly notify variant. */
+    readonly slim: boolean;
+}
+/**
+ * Resolve which `<agent_lessons>` block(s) a surface receives. See
+ * {@link AgentLessonsInjection} for the field/keying rationale.
+ *
+ * `opts.agentBound` (Phase 4) tells the resolver whether this firing resolved
+ * to an Agent (`resolveAgentId() != null`, surfaced by the builder as a stamped
+ * `event.data.agentId`). It only changes the binding-aware `scheduled.task`
+ * surface — every other key returns the same shape regardless — so a call with
+ * no opts is identical to the Phase-3 behaviour.
+ */
+export declare function getAgentLessonsInjection(eventOrProcessKey: string, opts?: {
+    agentBound?: boolean;
+}): AgentLessonsInjection;

package/dist/core/injection-policy.js

@@ -115,3 +115,61 @@ export function getInjectionPolicy(eventOrProcessKey) {
     }
     return DEFAULT_POLICY;
 }
+/**
+ * Pre-allocated frozen shapes — `getAgentLessonsInjection` returns shared
+ * instances so equality comparisons are stable and allocation-free, mirroring
+ * the `ALL_BLOCKS` / `NO_BLOCKS` pattern above.
+ */
+const LESSONS_DM_REVIEW = Object.freeze({
+    global: true,
+    self: true,
+    slim: false,
+});
+const LESSONS_HOURLY = Object.freeze({
+    global: true,
+    self: false,
+    slim: true,
+});
+const LESSONS_NONE = Object.freeze({
+    global: false,
+    self: false,
+    slim: false,
+});
+/**
+ * Resolve which `<agent_lessons>` block(s) a surface receives. See
+ * {@link AgentLessonsInjection} for the field/keying rationale.
+ *
+ * `opts.agentBound` (Phase 4) tells the resolver whether this firing resolved
+ * to an Agent (`resolveAgentId() != null`, surfaced by the builder as a stamped
+ * `event.data.agentId`). It only changes the binding-aware `scheduled.task`
+ * surface — every other key returns the same shape regardless — so a call with
+ * no opts is identical to the Phase-3 behaviour.
+ */
+export function getAgentLessonsInjection(eventOrProcessKey, opts) {
+    // DM / dashboard messages — the primary surface lessons calibrate.
+    if (eventOrProcessKey.startsWith("message.")) {
+        return LESSONS_DM_REVIEW;
+    }
+    switch (eventOrProcessKey) {
+        // Scheduled DM tone session (morning briefing, meeting nudges, …) — same
+        // conversational posture as a live DM.
+        case "scheduled.dm":
+        // Notify-deciding routines: morning Stage A + the review cadences. Each
+        // owns a go/no-go `/api/notify` decision that lessons should calibrate.
+        case "routine.morning_routine_today":
+        case "routine.evening_review":
+        case "routine.weekly_review":
+        case "routine.monthly_review":
+            return LESSONS_DM_REVIEW;
+        // Hourly notify turn — slim, hard-capped notification-discipline variant.
+        case "routine.hourly_check":
+            return LESSONS_HOURLY;
+        // Defined-agent task execution (§5 "Defined-agent execution"). A bare
+        // scheduled.task stays NONE (the §5 opt-out); one that resolves to an Agent
+        // gets global + self so a generated Agent sees feedback on its own output.
+        case "scheduled.task":
+            return opts?.agentBound ? LESSONS_DM_REVIEW : LESSONS_NONE;
+        default:
+            return LESSONS_NONE;
+    }
+}

package/dist/core/signal-detector.d.ts

@@ -1,3 +1,4 @@
+import type Database from "better-sqlite3";
 import type { AgentConfig } from "../config.js";
 /**
  * Raw signal entry that gets appended to user/profile.md ## Raw Signals section.
@@ -31,6 +32,7 @@ interface RawSignal {
  */
 export declare class SignalDetector {
     private readonly config;
+    private readonly deps;
     /** Track pending notifications for ignore detection */
     private readonly pendingNotifications;
     /** Rolling dedup cache: signal key → expiry timestamp */
@@ -41,7 +43,9 @@ export declare class SignalDetector {
     private ignoreCheckInterval;
     /** API base URL for Context File API (self-referencing) */
     private readonly apiBaseUrl;
-    constructor(config: AgentConfig);
+    constructor(config: AgentConfig, deps?: {
+        db?: Database.Database;
+    });
     /** Start the signal detector (periodic ignore check) */
     start(): void;
     /** Stop the signal detector */
@@ -67,9 +71,33 @@ export declare class SignalDetector {
      */
     onUserMessage(params: {
         platform: string;
+        channel?: string;
         content: string;
         responseToNotificationId?: string;
     }): void;
+    /**
+     * Record a positive action correlated with a notification. This is the
+     * narrow "acted" path: callers must have an actual task/action observation,
+     * never silence, before invoking it.
+     *
+     * NOTE — intentional Phase-1.5 seam, no production caller yet (by design).
+     * Firing `acted` deterministically needs the notification's subject
+     * `(source, ref)` in `pendingNotifications` to match a later observation,
+     * but that subject never reaches `trackNotification`: entity-related
+     * proactive DMs are re-authored by an agent turn and delivered via
+     * `POST /api/agent/notify`, which carries only message/platform/priority
+     * (no subject), and the direct `NotificationManager.send()` paths carry
+     * `data:{}`. So this stays correct + silence-safe but dormant — do NOT
+     * wire it from a silence- or substring-heuristic source (that re-opens the
+     * sign-inversion the promotion gate exists to kill). The loop is complete
+     * without it (`explicit` + `replied` drive promotion). See
+     * FEEDBACK_LEARNING_LOOP_DESIGN.md §11 v1.9#2 + v1.11.
+     */
+    onNotificationActed(params: {
+        notificationId: string;
+        actionRef?: string;
+        detail?: string;
+    }): void;
     /** Check for messages that have been ignored (no response within threshold) */
     private checkIgnoredMessages;
     /**
@@ -92,5 +120,15 @@ export declare class SignalDetector {
     static normalizeDedupKey(signal: RawSignal): string;
     /** Remove expired entries from the dedup cache */
     private pruneExpiredDedup;
+    private static isCorrectionContent;
+    private findPendingNotificationForReply;
+    private resolvePendingNotificationId;
+    private lookupNotificationMetadata;
+    private resolveAgentIdForNotification;
+    private recordNotificationOutcome;
+    private updateNotificationReaction;
+    private buildOutcomeSummary;
+    private sanitizeEvidence;
+    private static parseTrackedNotificationId;
 }
 export {};

package/dist/core/signal-detector.js

@@ -1,5 +1,7 @@
-import { formatSqliteDatetime } from "@aitne/shared";
+import { formatSqliteDatetime, redactSensitiveString } from "@aitne/shared";
+import { hasFeedbackSignalForAction, recordFeedbackSignal, } from "../db/feedback-signals-store.js";
 import { createLogger } from "../logging.js";
+import { resolveAgentId } from "./agents/agent-id-resolver.js";
 const logger = createLogger("signal-detector");
 /**
  * Maximum number of Raw Signal entries kept in user/profile.md. Prevents
@@ -37,6 +39,7 @@ const DEDUP_TTL_MS = 10 * 60 * 1000;
  */
 export class SignalDetector {
     config;
+    deps;
     /** Track pending notifications for ignore detection */
     pendingNotifications = new Map();
     /** Rolling dedup cache: signal key → expiry timestamp */
@@ -47,8 +50,9 @@ export class SignalDetector {
     ignoreCheckInterval = null;
     /** API base URL for Context File API (self-referencing) */
     apiBaseUrl;
-    constructor(config) {
+    constructor(config, deps = {}) {
         this.config = config;
+        this.deps = deps;
         this.ignoreThresholdMs = 30 * 60 * 1000; // 30 minutes
         this.apiBaseUrl = `http://localhost:${config.apiPort}`;
     }
@@ -71,10 +75,17 @@ export class SignalDetector {
      * Called by NotificationManager after successful delivery.
      */
     trackNotification(notificationId, platform, content) {
+        const metadata = this.lookupNotificationMetadata(notificationId);
         this.pendingNotifications.set(notificationId, {
             sentAt: Date.now(),
-            platform,
-            content: content.slice(0, 100), // Truncate for signal log
+            // Single fallback to the delivered platform here, not redundantly inside
+            // the lookup — the tracked id's suffix is the delivery platform anyway.
+            platform: metadata.platform ?? platform,
+            channel: metadata.channel,
+            content: (metadata.contentSummary ?? content).slice(0, 100), // Truncate for signal log
+            dispatchId: metadata.dispatchId,
+            notificationType: metadata.notificationType,
+            agentId: metadata.agentId,
         });
     }
     /**
@@ -85,12 +96,24 @@ export class SignalDetector {
         const { platform, emoji, responseTimeMs } = params;
         // Remove from pending (user responded)
         if (params.notificationId) {
-            this.pendingNotifications.delete(params.notificationId);
+            const pendingId = this.resolvePendingNotificationId(params.notificationId);
+            this.pendingNotifications.delete(pendingId);
+            this.recordNotificationOutcome({
+                notificationId: pendingId,
+                reaction: "replied",
+                valence: "positive",
+                evidence: {
+                    emoji,
+                    responseTimeMs,
+                    weight: 0.5,
+                },
+            });
         }
         const signal = {
             timestamp: formatSqliteDatetime(new Date()),
             type: "reaction",
-            detail: `${emoji} on ${platform}${responseTimeMs ? ` (${Math.round(responseTimeMs / 1000)}s)` : ""}`,
+            detail: `${emoji} on ${platform}`
+                + `${responseTimeMs ? ` (${Math.round(responseTimeMs / 1000)}s)` : ""}`,
         };
         void this.appendSignal(signal);
     }
@@ -100,29 +123,68 @@ export class SignalDetector {
      */
     onUserMessage(params) {
         const { content, responseToNotificationId } = params;
+        const pendingNotificationId = responseToNotificationId
+            ? this.resolvePendingNotificationId(responseToNotificationId)
+            : this.findPendingNotificationForReply(params.platform, params.channel);
         // Remove from pending (user responded)
-        if (responseToNotificationId) {
-            this.pendingNotifications.delete(responseToNotificationId);
+        if (pendingNotificationId) {
+            this.pendingNotifications.delete(pendingNotificationId);
         }
         // Detect correction instructions
-        const correctionPatterns = [
-            /shorter|brief|concise/i,
-            /more detail|elaborate|expand/i,
-            /\bin (english|spanish|french|german|portuguese|italian|chinese|japanese|korean|arabic|hindi|russian)\b/i,
-            /bullet points|bulleted list/i,
-        ];
-        for (const pattern of correctionPatterns) {
-            if (pattern.test(content)) {
-                const signal = {
-                    timestamp: formatSqliteDatetime(new Date()),
-                    type: "correction",
-                    detail: `"${content.slice(0, 60)}"`,
-                };
-                void this.appendSignal(signal);
-                return; // Only log the first matching correction
-            }
+        const isCorrection = SignalDetector.isCorrectionContent(content);
+        if (pendingNotificationId) {
+            this.recordNotificationOutcome({
+                notificationId: pendingNotificationId,
+                reaction: isCorrection ? "corrected" : "replied",
+                valence: isCorrection ? "correction" : "positive",
+                evidence: {
+                    excerpt: content.slice(0, 160),
+                    weight: isCorrection ? 1.0 : 0.5,
+                },
+            });
+        }
+        if (isCorrection) {
+            const signal = {
+                timestamp: formatSqliteDatetime(new Date()),
+                type: "correction",
+                detail: `"${content.slice(0, 60)}"`,
+            };
+            void this.appendSignal(signal);
+            return; // Only log the first matching correction
         }
     }
+    /**
+     * Record a positive action correlated with a notification. This is the
+     * narrow "acted" path: callers must have an actual task/action observation,
+     * never silence, before invoking it.
+     *
+     * NOTE — intentional Phase-1.5 seam, no production caller yet (by design).
+     * Firing `acted` deterministically needs the notification's subject
+     * `(source, ref)` in `pendingNotifications` to match a later observation,
+     * but that subject never reaches `trackNotification`: entity-related
+     * proactive DMs are re-authored by an agent turn and delivered via
+     * `POST /api/agent/notify`, which carries only message/platform/priority
+     * (no subject), and the direct `NotificationManager.send()` paths carry
+     * `data:{}`. So this stays correct + silence-safe but dormant — do NOT
+     * wire it from a silence- or substring-heuristic source (that re-opens the
+     * sign-inversion the promotion gate exists to kill). The loop is complete
+     * without it (`explicit` + `replied` drive promotion). See
+     * FEEDBACK_LEARNING_LOOP_DESIGN.md §11 v1.9#2 + v1.11.
+     */
+    onNotificationActed(params) {
+        const pendingId = this.resolvePendingNotificationId(params.notificationId);
+        this.pendingNotifications.delete(pendingId);
+        this.recordNotificationOutcome({
+            notificationId: pendingId,
+            reaction: "acted",
+            valence: "positive",
+            evidence: {
+                actionRef: params.actionRef,
+                detail: params.detail,
+                weight: 0.5,
+            },
+        });
+    }
     /** Check for messages that have been ignored (no response within threshold) */
     checkIgnoredMessages() {
         const now = Date.now();
@@ -136,6 +198,16 @@ export class SignalDetector {
                     detail: `${info.platform}: "${info.content}" unread for ${Math.round(elapsed / 60000)}min`,
                 };
                 void this.appendSignal(signal);
+                this.recordNotificationOutcome({
+                    notificationId: id,
+                    reaction: "ignored",
+                    valence: "neutral",
+                    evidence: {
+                        elapsedMs: elapsed,
+                        weight: 0.25,
+                        initiatesLesson: false,
+                    },
+                });
                 toRemove.push(id);
             }
         }
@@ -211,4 +283,185 @@ export class SignalDetector {
             }
         }
     }
+    static isCorrectionContent(content) {
+        const correctionPatterns = [
+            /shorter|brief|concise/i,
+            /more detail|elaborate|expand/i,
+            /\bin (english|spanish|french|german|portuguese|italian|chinese|japanese|korean|arabic|hindi|russian)\b/i,
+            /bullet points|bulleted list/i,
+            /\b(stop|no)\b.*\b(notify|message|remind|send|doing|do|again|that)\b/i,
+            /\b(do not|don't)\b/i,
+        ];
+        return correctionPatterns.some((pattern) => pattern.test(content));
+    }
+    findPendingNotificationForReply(platform, channel) {
+        const now = Date.now();
+        let candidate = null;
+        for (const [id, info] of this.pendingNotifications) {
+            if (info.platform !== platform)
+                continue;
+            if (channel && info.channel && info.channel !== channel)
+                continue;
+            if (now - info.sentAt > this.ignoreThresholdMs)
+                continue;
+            if (candidate === null || info.sentAt > candidate.sentAt) {
+                candidate = { id, sentAt: info.sentAt };
+            }
+        }
+        return candidate?.id ?? null;
+    }
+    resolvePendingNotificationId(notificationId) {
+        if (this.pendingNotifications.has(notificationId))
+            return notificationId;
+        for (const id of this.pendingNotifications.keys()) {
+            if (id.startsWith(`${notificationId}:`))
+                return id;
+        }
+        return notificationId;
+    }
+    lookupNotificationMetadata(notificationId) {
+        const parsed = SignalDetector.parseTrackedNotificationId(notificationId);
+        if (!this.deps.db || !parsed.dispatchId) {
+            return {
+                dispatchId: parsed.dispatchId,
+                platform: parsed.platform,
+                channel: null,
+                notificationType: null,
+                contentSummary: null,
+                agentId: null,
+                rowId: null,
+            };
+        }
+        const platformValue = parsed.platform;
+        const platformPredicate = platformValue ? "AND platform = ?" : "";
+        const values = platformValue
+            ? [parsed.dispatchId, platformValue]
+            : [parsed.dispatchId];
+        const row = this.deps.db
+            .prepare(`SELECT id, dispatch_id, platform, delivery_channel, notification_type, content_summary
+         FROM notification_log
+         WHERE dispatch_id = ? ${platformPredicate}
+         ORDER BY id DESC
+         LIMIT 1`)
+            .get(...values);
+        const notificationType = row?.notification_type ?? null;
+        return {
+            dispatchId: row?.dispatch_id ?? parsed.dispatchId,
+            platform: row?.platform ?? parsed.platform,
+            channel: row?.delivery_channel ?? null,
+            notificationType,
+            contentSummary: row?.content_summary ?? null,
+            agentId: this.resolveAgentIdForNotification(notificationType),
+            rowId: row?.id ?? null,
+        };
+    }
+    resolveAgentIdForNotification(notificationType) {
+        if (!this.deps.db || !notificationType?.startsWith("routine."))
+            return null;
+        // Runs only after a successful notification_log read on the same db, so a
+        // connection failure would already have surfaced upstream; the registry
+        // lookup + agents existence check are deterministic over a valid handle.
+        return resolveAgentId(this.deps.db, {
+            routine: notificationType.slice("routine.".length),
+        });
+    }
+    recordNotificationOutcome(params) {
+        const db = this.deps.db;
+        if (this.config.feedbackLearningEnabled === false || !db)
+            return;
+        // One guard for the whole behavioral-capture path: the reaction backfill,
+        // dedup probe, and signal insert all touch the same connection, so a single
+        // catch keeps a DB hiccup from crashing the background detector loop
+        // without leaving the reaction column write unguarded.
+        try {
+            const metadata = this.lookupNotificationMetadata(params.notificationId);
+            const dispatchId = metadata.dispatchId;
+            if (!dispatchId)
+                return;
+            this.updateNotificationReaction(db, dispatchId, metadata.platform, params.reaction);
+            if (hasFeedbackSignalForAction(db, {
+                source: "behavioral",
+                actionKind: "notification",
+                actionRef: dispatchId,
+                valence: params.valence,
+                userReaction: params.reaction,
+            })) {
+                return;
+            }
+            const scopeType = metadata.agentId ? "agent_slug" : "agent";
+            const summary = this.buildOutcomeSummary(params.reaction, metadata);
+            const evidence = this.sanitizeEvidence({
+                ...params.evidence,
+                userReaction: params.reaction,
+                notificationLogId: metadata.rowId,
+                notificationType: metadata.notificationType,
+                platform: metadata.platform,
+                contentSummary: metadata.contentSummary,
+            });
+            recordFeedbackSignal(db, {
+                source: "behavioral",
+                valence: params.valence,
+                scopeType,
+                scopeRef: metadata.agentId,
+                actionKind: "notification",
+                actionRef: dispatchId,
+                agentId: metadata.agentId,
+                summary,
+                evidence,
+            });
+        }
+        catch (err) {
+            logger.warn({ err, notificationId: params.notificationId, reaction: params.reaction }, "Failed to record notification outcome");
+        }
+    }
+    updateNotificationReaction(db, dispatchId, platform, reaction) {
+        if (platform) {
+            db.prepare(`UPDATE notification_log
+           SET user_reaction = ?, reacted_at = CURRENT_TIMESTAMP
+           WHERE dispatch_id = ? AND platform = ?`).run(reaction, dispatchId, platform);
+            return;
+        }
+        db.prepare(`UPDATE notification_log
+         SET user_reaction = ?, reacted_at = CURRENT_TIMESTAMP
+         WHERE dispatch_id = ?`).run(reaction, dispatchId);
+    }
+    buildOutcomeSummary(reaction, metadata) {
+        const content = metadata.contentSummary
+            ? ` "${metadata.contentSummary}"`
+            : "";
+        const notificationType = metadata.notificationType
+            ? ` (${metadata.notificationType})`
+            : "";
+        const raw = reaction === "ignored"
+            ? `Owner did not respond to notification${content}${notificationType}`
+            : reaction === "corrected"
+                ? `Owner corrected notification${content}${notificationType}`
+                : reaction === "acted"
+                    ? `Owner acted on notification${content}${notificationType}`
+                    : `Owner responded to notification${content}${notificationType}`;
+        return redactSensitiveString(raw.replace(/\s+/g, " ").trim()).slice(0, 280);
+    }
+    sanitizeEvidence(value) {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined)
+                continue;
+            if (typeof entry === "string") {
+                out[key] = redactSensitiveString(entry.replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 500));
+            }
+            else {
+                out[key] = entry;
+            }
+        }
+        return out;
+    }
+    static parseTrackedNotificationId(notificationId) {
+        const idx = notificationId.indexOf(":");
+        if (idx <= 0)
+            return { dispatchId: notificationId || null, platform: null };
+        return {
+            dispatchId: notificationId.slice(0, idx),
+            platform: notificationId.slice(idx + 1) || null,
+        };
+    }
 }