@wolfx/opencode-magic-context 0.22.3 → 0.23.0

package/src/shared/announcement.ts

@@ -23,18 +23,18 @@ import { getMagicContextStorageDir } from "./data-path";
  * Bump only when there are user-visible changes worth a startup dialog.
  * Does NOT need to match the published package version.
  */
-export const ANNOUNCEMENT_VERSION = "0.22.0";
+export const ANNOUNCEMENT_VERSION = "0.23.0";
 
 /**
  * Short, user-facing bullet strings. Keep each line ~80 chars or shorter so the
  * TUI dialog renders cleanly without horizontal scroll on a typical terminal.
  */
 export const ANNOUNCEMENT_FEATURES: ReadonlyArray<string> = [
-    "NOW ON BY DEFAULT — Temporal awareness: the agent sees elapsed-time markers (e.g. +2h 15m) between messages and dated compartments, so it knows how long ago things happened. Opt out with temporal_awareness: false.",
-    "NOW ON BY DEFAULT — Auto-search hints: each turn a background ctx_search whispers a compact 'vague recall' when something relevant exists in your memories, past conversation, or git history. No full content injected. Opt out with memory.auto_search.enabled: false.",
-    "Experimental features graduated to stable config: temporal_awareness and caveman_text_compression are now top-level keys; auto_search and git_commit_indexing moved under memory.* . Run `doctor` to migrate old experimental.* settings (your opt-ins/opt-outs are preserved).",
-    "git_commit_indexing (make project history semantically searchable) stays opt-in — enable with memory.git_commit_indexing.enabled: true.",
-    "Audit hardening across both harnesses: memory config-bypass fix, supersede-delta cache-stability fixes, and dashboard correctness fixes.",
+    "Smarter context nudges: gentle <system-reminder> notes on tool outputs replace the old chat nudges — quieter, cache-safe, and they now also help subagents manage their own context.",
+    "The agent can now maintain its own project memories: update, archive (batch), and merge the memories it sees — not just write new ones. Memory categories are schema-enforced.",
+    "Big-session performance: historian trigger and token math moved off the database hot path — multi-second stalls on large sessions are gone (measured 250ms → 2.4ms per pass).",
+    "History compaction unstuck for sparse sessions: the protected-tail boundary is now size-based, so sessions with few user turns compact reliably instead of growing forever (issue #132).",
+    "Fixed: session titles no longer fail to generate in fresh directories (issue #129), plus 20+ correctness fixes from three audit rounds.",
 ];
 
 /**
@@ -52,23 +52,33 @@ function getStateFilePath(): string {
     return path.join(getMagicContextStorageDir(), STATE_FILENAME);
 }
 
-/**
- * Read the most recently dismissed announcement version, or `""` if none.
- *
- * Best-effort: any read failure returns `""` (which forces the announcement to
- * re-show). The cost of a spurious second dialog is much smaller than the cost
- * of suppressing a real announcement due to a transient FS error.
- */
-export function readLastAnnouncedVersion(): string {
+type AnnouncementStateRead =
+    | { status: "missing" }
+    | { status: "valid"; version: string }
+    | { status: "error" };
+
+function readAnnouncementState(): AnnouncementStateRead {
     try {
         const file = getStateFilePath();
-        if (!fs.existsSync(file)) return "";
-        return fs.readFileSync(file, "utf-8").trim();
+        if (!fs.existsSync(file)) return { status: "missing" };
+        const version = fs.readFileSync(file, "utf-8").trim();
+        if (!version) return { status: "error" };
+        return { status: "valid", version };
     } catch {
-        return "";
+        return { status: "error" };
     }
 }
 
+/**
+ * Read the most recently dismissed announcement version, or `""` if none can be
+ * returned. Callers that need to distinguish first-run from read/corruption
+ * failures should use the internal tri-state path in `shouldShowAnnouncement`.
+ */
+export function readLastAnnouncedVersion(): string {
+    const state = readAnnouncementState();
+    return state.status === "valid" ? state.version : "";
+}
+
 /**
  * Persist `version` as the most recently dismissed announcement. Best-effort:
  * write failures are swallowed so dialog-confirm flows never throw on storage
@@ -108,12 +118,17 @@ export function markAnnouncementSeen(version: string): void {
  */
 export function shouldShowAnnouncement(): boolean {
     if (!ANNOUNCEMENT_VERSION || ANNOUNCEMENT_FEATURES.length === 0) return false;
-    const lastVersion = readLastAnnouncedVersion();
-    if (!lastVersion) {
+    const state = readAnnouncementState();
+    if (state.status === "missing") {
         // No prior state: fresh install or wiped sandbox. Seed to current and
         // skip the announcement so we never pester first-run / ephemeral envs.
         markAnnouncementSeen(ANNOUNCEMENT_VERSION);
         return false;
     }
-    return lastVersion !== ANNOUNCEMENT_VERSION;
+    if (state.status === "error") {
+        // A corrupt or temporarily unreadable existing state file is not first-run.
+        // Do not advance the version; a later successful boot can still show it.
+        return false;
+    }
+    return state.version !== ANNOUNCEMENT_VERSION;
 }

package/src/shared/keep-subagents.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import {
+    _resetKeepSubagentsForTesting,
+    setKeepSubagents,
+    shouldKeepSubagents,
+} from "./keep-subagents";
+
+afterEach(() => {
+    _resetKeepSubagentsForTesting();
+});
+
+describe("keep-subagents flag", () => {
+    it("#given default #then subagent sessions are NOT kept (deleted on success)", () => {
+        expect(shouldKeepSubagents()).toBe(false);
+    });
+
+    it("#given setKeepSubagents(true) #then sessions are kept", () => {
+        setKeepSubagents(true);
+        expect(shouldKeepSubagents()).toBe(true);
+    });
+
+    it("#given setKeepSubagents(false) #then sessions are not kept", () => {
+        setKeepSubagents(true);
+        setKeepSubagents(false);
+        expect(shouldKeepSubagents()).toBe(false);
+    });
+
+    it("#given a non-true value #then coerces to false (only strict true keeps)", () => {
+        // boot wiring passes `config.keep_subagents === true`, but guard anyway.
+        setKeepSubagents(undefined as unknown as boolean);
+        expect(shouldKeepSubagents()).toBe(false);
+    });
+
+    it("#given reset helper #then returns to default false", () => {
+        setKeepSubagents(true);
+        _resetKeepSubagentsForTesting();
+        expect(shouldKeepSubagents()).toBe(false);
+    });
+});

package/src/shared/keep-subagents.ts

@@ -0,0 +1,33 @@
+/**
+ * Debug / data-collection switch: when enabled, Magic Context does NOT delete
+ * the child sessions it spawns for its own subagents (historian, dreamer,
+ * sidekick, memory-migration, key-files, user-memory review, recomp).
+ *
+ * By default these child sessions are deleted on success (only FAILED ones are
+ * kept for debugging). With `keep_subagents: true` ALL of them are retained, so
+ * their full transcript — prompt, tool calls, token usage, model output — stays
+ * inspectable in OpenCode's session store / the dashboard. Intended for
+ * short-term data collection (e.g. profiling what the dreamer actually does)
+ * before the dreamer v2 overhaul, NOT for steady-state use — kept sessions
+ * accumulate in the host's session DB until manually cleared.
+ *
+ * Process-global, set once at boot from config (mirrors `harness.ts`). A
+ * config change requires a restart to take effect. NEVER thread this through
+ * per-call args — it's a coarse, boot-time debug toggle.
+ */
+let keepSubagents = false;
+
+/** Set at plugin boot from `keep_subagents` config. */
+export function setKeepSubagents(value: boolean): void {
+    keepSubagents = value === true;
+}
+
+/** True when subagent child sessions should be retained (not deleted). */
+export function shouldKeepSubagents(): boolean {
+    return keepSubagents;
+}
+
+/** Test-only reset. Do NOT call from production paths. */
+export function _resetKeepSubagentsForTesting(): void {
+    keepSubagents = false;
+}

package/src/shared/live-server-client.ts

@@ -0,0 +1,152 @@
+/**
+ * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
+ * user `<system-reminder>` delivered via `promptAsync`).
+ *
+ * WHY a separate client instead of the plugin-provided `input.client`:
+ * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
+ * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
+ * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
+ * observes an "idle" runner while the live turn is still running, `ensureRunning`
+ * fails to coalesce, and OpenCode persists duplicate assistant children
+ * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
+ * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
+ * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
+ * message lands at the tail after the current assistant step.
+ *
+ * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
+ * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
+ * `/session/*`. We probe once at init and cache per `serverUrl`. When
+ * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
+ * remain the backstop) — MC deliberately does NOT fall back to the in-process
+ * client because that would knowingly trigger #28202.
+ */
+
+import { createOpencodeClient } from "@opencode-ai/sdk";
+
+export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
+
+const clientCache = new Map<string, LiveServerClient>();
+
+function cacheKey(serverUrl: string, directory: string): string {
+    return `${serverUrl}|${directory}`;
+}
+
+function normalizeServerUrl(serverUrl: string): string {
+    try {
+        return new URL(serverUrl).toString();
+    } catch {
+        return serverUrl;
+    }
+}
+
+/** Basic-auth header OpenCode expects when `OPENCODE_SERVER_PASSWORD` is set. */
+function serverAuthHeaders(): Record<string, string> | undefined {
+    const password = process.env.OPENCODE_SERVER_PASSWORD;
+    if (!password) return undefined;
+    const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+    return {
+        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
+    };
+}
+
+/**
+ * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
+ * `(serverUrl, directory)`. One client is reused across deliveries.
+ */
+export function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient {
+    const key = cacheKey(serverUrl, directory);
+    const cached = clientCache.get(key);
+    if (cached) return cached;
+    const client = createOpencodeClient({
+        baseUrl: serverUrl,
+        directory,
+        headers: serverAuthHeaders(),
+        fetch: globalThis.fetch,
+    });
+    clientCache.set(key, client);
+    return client;
+}
+
+// Per-serverUrl wake decision + probe TTL. One plugin process can host multiple
+// OpenCode windows with different listener URLs, so the decision must be keyed.
+interface ProbeDecision {
+    reachable: boolean;
+    probedAt: number;
+}
+const wakeDecisionByServerUrl = new Map<string, ProbeDecision>();
+
+// Re-probe window: a transient 404/timeout shouldn't permanently disable
+// Channel 2 for the whole session lifetime (per council-r3).
+const PROBE_TTL_MS = 10 * 60_000;
+
+/**
+ * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
+ * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
+ * (auth-protected listener still exists). `false` for 404 (plain TUI internal
+ * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
+ * Records the result + timestamp in the per-serverUrl cache.
+ */
+export async function probeServerReachable(
+    serverUrl: string | undefined,
+    timeoutMs = 1500,
+): Promise<boolean> {
+    if (!serverUrl) return false;
+    const normalized = normalizeServerUrl(serverUrl);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let reachable = false;
+    try {
+        const probeUrl = new URL("/session", serverUrl).toString();
+        const res = await globalThis.fetch(probeUrl, {
+            method: "GET",
+            headers: serverAuthHeaders(),
+            signal: controller.signal,
+        });
+        reachable = res.ok || res.status === 401 || res.status === 403;
+    } catch {
+        reachable = false;
+    } finally {
+        clearTimeout(timer);
+        wakeDecisionByServerUrl.set(normalized, { reachable, probedAt: Date.now() });
+    }
+    return reachable;
+}
+
+/** Record a probe result directly (test helper / explicit override). */
+export function setLiveServerWakeAvailable(
+    serverUrl: string | undefined,
+    available: boolean,
+): void {
+    if (!serverUrl) return;
+    wakeDecisionByServerUrl.set(normalizeServerUrl(serverUrl), {
+        reachable: available,
+        probedAt: Date.now(),
+    });
+}
+
+/**
+ * Should Channel 2 deliver through the live-server client for `serverUrl`?
+ * Returns false when never probed or the last probe failed. A stale decision
+ * (older than the TTL) returns false so the caller re-probes before delivering.
+ */
+export function useLiveServerWake(serverUrl?: string): boolean {
+    if (!serverUrl) return false;
+    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
+    if (!decision) return false;
+    if (Date.now() - decision.probedAt > PROBE_TTL_MS) return false;
+    return decision.reachable;
+}
+
+/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
+export function hasFreshProbe(serverUrl?: string): boolean {
+    if (!serverUrl) return false;
+    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
+    if (!decision) return false;
+    return Date.now() - decision.probedAt <= PROBE_TTL_MS;
+}
+
+/** Test helper — reset both caches between cases. */
+export function __resetLiveServerClientForTests(): void {
+    clientCache.clear();
+    wakeDecisionByServerUrl.clear();
+}

package/src/shared/prompt-context.ts

@@ -0,0 +1,135 @@
+/**
+ * Resolve the newest effective prompt context (agent + model + variant) for a
+ * session by reading recent messages from the OpenCode HTTP API.
+ *
+ * WHY: a Channel 2 ceiling nudge sends a synthetic user message via
+ * `promptAsync` with `noReply:false` (it DOES trigger an assistant turn).
+ * OpenCode's `createUserMessage` resolves variant relative to the chosen
+ * agent; passing model alone makes OpenCode pick the default agent whose model
+ * check then fails, bypassing the active variant and busting the provider
+ * prefix cache the prior turn warmed. So we pass agent + model + variant
+ * explicitly, mirroring the resolution AFT/opencode-xtra use for their wake
+ * notifications.
+ *
+ * Walk newest→oldest and merge field-by-field so the newest context-bearing
+ * message wins while older messages only fill fields it did not provide. Read
+ * BOTH the flat shape (`info.providerID`) used by AssistantMessage and the
+ * nested shape (`info.model.providerID`) used by UserMessage.
+ *
+ * Bounded via `query.limit` — the legacy `/session/{id}/message` endpoint
+ * hydrates the ENTIRE session without it (30k-45k messages on large sessions).
+ */
+
+export interface ResolvedPromptContext {
+    agent?: string;
+    model?: { providerID: string; modelID: string };
+    variant?: string;
+}
+
+interface RawInfo {
+    role?: string;
+    agent?: string;
+    variant?: string;
+    providerID?: string;
+    modelID?: string;
+    model?: { providerID?: string; modelID?: string; variant?: string };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null;
+}
+
+function extractMessages(response: unknown): unknown[] {
+    if (Array.isArray(response)) return response;
+    if (isRecord(response) && Array.isArray(response.data)) return response.data;
+    return [];
+}
+
+function extractFromMessage(message: unknown): ResolvedPromptContext | null {
+    if (!isRecord(message) || !isRecord(message.info)) return null;
+    const info = message.info as RawInfo;
+    const modelInfo = isRecord(info.model) ? info.model : undefined;
+
+    const agent = typeof info.agent === "string" ? info.agent : undefined;
+    const providerID =
+        typeof modelInfo?.providerID === "string"
+            ? modelInfo.providerID
+            : typeof info.providerID === "string"
+              ? info.providerID
+              : undefined;
+    const modelID =
+        typeof modelInfo?.modelID === "string"
+            ? modelInfo.modelID
+            : typeof info.modelID === "string"
+              ? info.modelID
+              : undefined;
+    const variant =
+        typeof modelInfo?.variant === "string"
+            ? modelInfo.variant
+            : typeof info.variant === "string"
+              ? info.variant
+              : undefined;
+
+    if (!agent && (!providerID || !modelID) && !variant) return null;
+    const out: ResolvedPromptContext = {};
+    if (agent) out.agent = agent;
+    if (providerID && modelID) out.model = { providerID, modelID };
+    if (variant) out.variant = variant;
+    return out;
+}
+
+function mergeContexts(
+    base: ResolvedPromptContext,
+    patch: ResolvedPromptContext,
+): ResolvedPromptContext {
+    return {
+        agent: base.agent ?? patch.agent,
+        model: base.model ?? patch.model,
+        variant: base.variant ?? patch.variant,
+    };
+}
+
+function isComplete(ctx: ResolvedPromptContext): boolean {
+    return Boolean(ctx.agent && ctx.model && ctx.variant);
+}
+
+const PROMPT_CONTEXT_MESSAGE_LIMIT = 50;
+
+export async function resolvePromptContext(
+    client: unknown,
+    sessionId: string,
+): Promise<ResolvedPromptContext | null> {
+    if (!client || !sessionId) return null;
+    const c = client as {
+        session?: {
+            messages?: (input: {
+                path: { id: string };
+                query?: { limit?: number };
+            }) => Promise<{ data?: unknown[] } | unknown[]>;
+        };
+    };
+    if (typeof c.session?.messages !== "function") return null;
+
+    let messages: unknown[] = [];
+    try {
+        const response = await c.session.messages({
+            path: { id: sessionId },
+            query: { limit: PROMPT_CONTEXT_MESSAGE_LIMIT },
+        });
+        messages = extractMessages(response);
+    } catch {
+        return null;
+    }
+    if (messages.length === 0) return null;
+
+    let result: ResolvedPromptContext = {};
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const ctx = extractFromMessage(messages[i]);
+        if (!ctx) continue;
+        result = mergeContexts(result, ctx);
+        if (isComplete(result)) return result;
+    }
+
+    if (!result.agent && !result.model && !result.variant) return null;
+    return result;
+}

package/src/shared/rpc-server.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, timingSafeEqual } from "node:crypto";
 import {
     mkdirSync,
     readdirSync,
@@ -14,6 +14,19 @@ import { isPidAlive, parseRpcPortFile, rpcPortDir, rpcPortFilePath } from "./rpc
 
 type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
 
+/**
+ * Constant-time bearer-token comparison. `timingSafeEqual` throws on
+ * length-mismatched buffers, so guard on length first (the length itself is not
+ * secret — the token bytes are). Avoids leaking the token via response-timing on
+ * the loopback auth check.
+ */
+function tokensMatch(presented: string, expected: string): boolean {
+    const a = Buffer.from(presented, "utf8");
+    const b = Buffer.from(expected, "utf8");
+    if (a.length !== b.length) return false;
+    return timingSafeEqual(a, b);
+}
+
 export class MagicContextRpcServer {
     private server: Server | null = null;
     private port = 0;
@@ -149,9 +162,12 @@ export class MagicContextRpcServer {
         // Require the per-process bearer token on every side-effecting call.
         // The legitimate TUI client reads it from the same port file it used to
         // discover the port; a process that only guessed the port cannot.
+        // Constant-time compare so a local attacker can't byte-probe the token
+        // via response-timing (length-guard first, since timingSafeEqual throws
+        // on length mismatch).
         const auth = req.headers.authorization;
         const presented = typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
-        if (presented !== this.token) {
+        if (!tokensMatch(presented, this.token)) {
             res.writeHead(401, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ error: "Unauthorized" }));
             req.resume();

package/src/shared/rpc-types.ts

@@ -97,7 +97,6 @@ export interface StatusDetail extends SidebarSnapshot {
     activeBytes: number;
     lastResponseTime: number;
     lastNudgeTokens: number;
-    lastNudgeBand: string;
     lastTransformError: string | null;
     isSubagent: boolean;
     pendingOps: Array<{ tagId: number; operation: string }>;
@@ -118,9 +117,7 @@ export interface StatusDetail extends SidebarSnapshot {
      */
     executeThresholdTokens?: number;
     protectedTagCount: number;
-    nudgeInterval: number;
     historyBudgetPercentage: number;
-    nextNudgeAfter: number;
     historyBlockTokens: number;
     compressionBudget: number | null;
     compressionUsage: string | null;

package/src/shared/safe-notification-target.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { isDefaultSessionTitle, waitForSafeNotificationTarget } from "./safe-notification-target";
+
+function clientWithTitle(title: string | undefined, calls?: { count: number }) {
+    return {
+        session: {
+            get: async (_input: unknown) => {
+                if (calls) calls.count += 1;
+                return { data: { title } };
+            },
+        },
+    };
+}
+
+describe("isDefaultSessionTitle", () => {
+    it("matches OpenCode default titles for parent and child sessions", () => {
+        expect(isDefaultSessionTitle("New session - 2026-06-10T15:33:11.538Z")).toBe(true);
+        expect(isDefaultSessionTitle("Child session - 2026-01-02T03:04:05.678Z")).toBe(true);
+    });
+
+    it("does not match real titles", () => {
+        expect(isDefaultSessionTitle("Quick test")).toBe(false);
+        expect(isDefaultSessionTitle("New session - notes")).toBe(false);
+        // Prefix alone isn't enough — the timestamp must match exactly,
+        // mirroring OpenCode's Session.isDefaultTitle.
+        expect(isDefaultSessionTitle("New session - 2026-06-10")).toBe(false);
+    });
+});
+
+describe("waitForSafeNotificationTarget", () => {
+    it("returns safe immediately for a titled session", async () => {
+        const calls = { count: 0 };
+        const result = await waitForSafeNotificationTarget(
+            clientWithTitle("Fix tagger collision", calls),
+            "ses-titled",
+            { attempts: 4, delayMs: 1 },
+        );
+        expect(result).toBe("safe");
+        expect(calls.count).toBe(1);
+    });
+
+    it("returns skip after exhausting attempts on a default-titled session", async () => {
+        const calls = { count: 0 };
+        const result = await waitForSafeNotificationTarget(
+            clientWithTitle("New session - 2026-06-10T15:33:11.538Z", calls),
+            "ses-fresh",
+            { attempts: 3, delayMs: 1 },
+        );
+        expect(result).toBe("skip");
+        expect(calls.count).toBe(3);
+    });
+
+    it("returns safe once the title flips to a real one mid-retry", async () => {
+        let call = 0;
+        const client = {
+            session: {
+                get: async () => {
+                    call += 1;
+                    return {
+                        data: {
+                            title: call < 2 ? "New session - 2026-06-10T15:33:11.538Z" : "Greeting",
+                        },
+                    };
+                },
+            },
+        };
+        const result = await waitForSafeNotificationTarget(client, "ses-flip", {
+            attempts: 4,
+            delayMs: 1,
+        });
+        expect(result).toBe("safe");
+        expect(call).toBe(2);
+    });
+
+    it("fails open when the client cannot report a title", async () => {
+        expect(
+            await waitForSafeNotificationTarget({}, "ses-no-api", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+        const throwing = {
+            session: {
+                get: async () => {
+                    throw new Error("transport down");
+                },
+            },
+        };
+        expect(
+            await waitForSafeNotificationTarget(throwing, "ses-throw", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+        // Direct-shape response (no `.data` wrapper) is also recognized.
+        const direct = {
+            session: { get: async () => ({ title: "Real title" }) },
+        };
+        expect(
+            await waitForSafeNotificationTarget(direct, "ses-direct", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+    });
+});