fix: thread toast duration through session hook config

- preserves toast_duration_ms when building the narrowed hook config
- keeps dream notifications on the configured duration instead of falling back to 5s
- includes regression coverage
- keep restart/setup toasts on 10s fallback

Author: kecsap

CONFIGURATION.md

@@ -113,6 +113,7 @@ Higher-tier models with longer cache windows benefit from a longer TTL. Setting
 | `ctx_reduce_enabled` | `boolean` | `true` | When `false`, hides `ctx_reduce` tool, disables all nudges/reminders, and strips reduction guidance from prompts. Heuristic cleanup, compartments, memory, and search still work. Useful for testing whether automatic cleanup alone is sufficient. |
 | `cache_ttl` | `string` or `object` | `"5m"` | Time after a response before applying pending ops. String or per-model map. |
 | `protected_tags` | `number` (1–100) | `20` | Last N active tags immune from immediate dropping. |
+| `toast_duration_ms` | `number` (1000–60000) | `5000` | TUI toast lifetime for Magic Context notifications in milliseconds. Increase this if toasts disappear too quickly. |
 | `execute_threshold_percentage` | `number` (20–80) or `object` | `65` | Context usage that forces queued ops to execute. Capped at 80% max for cache safety. Supports per-model map. |
 | `execute_threshold_tokens` | `object` (per-model map) | — | **Optional absolute-tokens variant of `execute_threshold_percentage`.** Per-model map (e.g. `{ "default": 150000, "github-copilot/gpt-5.2-codex": 40000 }`). When set for a model, overrides the percentage-based threshold for that model. Clamped to `80% × context_limit` with a warn log. Requires a resolvable context limit — falls through to percentage if unavailable. See below. |
 | `clear_reasoning_age` | `number` | `50` | Clear thinking/reasoning blocks older than N tags. |
@@ -627,6 +628,7 @@ Tier boundaries are hardcoded to keep behavior predictable and prevent cache-bus
     "anthropic/claude-opus-4-6": 50
   },
   "protected_tags": 10,
+  "toast_duration_ms": 12000,
   "history_budget_percentage": 0.15,
   "temporal_awareness": true,
 

assets/magic-context.schema.json

@@ -461,6 +461,13 @@
         }
       ]
     },
+    "toast_duration_ms": {
+      "default": 5000,
+      "description": "TUI toast lifetime in milliseconds for Magic Context notifications (min: 1000, max: 60000, default: 5000)",
+      "type": "number",
+      "minimum": 1000,
+      "maximum": 60000
+    },
     "execute_threshold_percentage": {
       "default": 65,
       "description": "Context percentage that forces queued operations to execute. Number or per-model object ({ default: 65, \"provider/model\": 45 }). Values above 80 are rejected because the runtime caps at 80% for cache safety (MAX_EXECUTE_THRESHOLD). Default: DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE",

packages/plugin/src/config/index.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 import { detectConfigFile, parseJsonc } from "../shared/jsonc-parser";
+import { log } from "../shared/logger";
 import { migrateLegacyAgentEnabledInMemory } from "./agent-disable";
 import { migrateLegacyExperimental } from "./migrate-experimental";
 import {

packages/plugin/src/config/schema/magic-context.ts

@@ -234,6 +234,8 @@ export interface MagicContextConfig {
     historian?: HistorianConfig;
     dreamer?: DreamerConfig;
     cache_ttl: string | { default: string; [modelKey: string]: string };
+    /** TUI toast lifetime in milliseconds for Magic Context notifications. Default: 5000. */
+    toast_duration_ms?: number;
     execute_threshold_percentage: number | { default: number; [modelKey: string]: number };
     /** Absolute token thresholds per model. When set for a given model (or via `default`),
      *  this overrides `execute_threshold_percentage` for that model. Useful for hard caps
@@ -364,6 +366,14 @@ export const MagicContextConfigSchema = z
             .describe(
                 'Cache TTL: string (e.g. "5m") or per-model object ({ default: "5m", "model-id": "10m" })',
             ),
+        toast_duration_ms: z
+            .number()
+            .min(1_000)
+            .max(60_000)
+            .default(5_000)
+            .describe(
+                "TUI toast lifetime in milliseconds for Magic Context notifications (min: 1000, max: 60000, default: 5000)",
+            ),
         execute_threshold_percentage: z
             .union([
                 z.number().min(20).max(80, EXECUTE_THRESHOLD_CAP_MESSAGE),

packages/plugin/src/hooks/magic-context/command-handler.test.ts

@@ -721,13 +721,13 @@ describe("createMagicContextCommandHandler", () => {
                 1,
                 "ses-dream",
                 "Starting dream run...",
-                {},
+                { toastDurationMs: 5000 },
             );
             expect(sendNotification).toHaveBeenNthCalledWith(
                 2,
                 "ses-dream",
                 expect.stringContaining("### Tasks"),
-                {},
+                { toastDurationMs: 5000 },
             );
         });
 
@@ -775,7 +775,7 @@ describe("createMagicContextCommandHandler", () => {
                 3,
                 "ses-dream",
                 "Dream already queued for this project",
-                {},
+                { toastDurationMs: 5000 },
             );
             expect(executeDream).toHaveBeenCalledTimes(1);
         });

packages/plugin/src/hooks/magic-context/command-handler.ts

@@ -270,6 +270,7 @@ async function executeDreaming(
             text: string,
             params: NotificationParams,
         ) => Promise<void>;
+        toastDurationMs?: number;
         dreamer?: {
             config: DreamerConfig;
             projectPath: string;
@@ -288,11 +289,15 @@ async function executeDreaming(
     },
     sessionId: string,
 ): Promise<never> {
+    const dreamNotificationParams: NotificationParams = {
+        toastDurationMs: deps.toastDurationMs ?? 5000,
+    };
+
     if (!deps.dreamer?.config?.tasks?.length) {
         await deps.sendNotification(
             sessionId,
             "## /ctx-dream\n\nDreaming is not configured for this project.",
-            {},
+            dreamNotificationParams,
         );
         throwSentinel("CTX-DREAM");
     }
@@ -303,11 +308,11 @@ async function executeDreaming(
     // runner with an unexpired lease is never deleted just because it is older than 2m.
     const entry = enqueueDream(deps.db, deps.dreamer.projectPath, "manual", true);
     if (!entry) {
-        await deps.sendNotification(sessionId, "Dream already queued for this project", {});
+        await deps.sendNotification(sessionId, "Dream already queued for this project", dreamNotificationParams);
         throwSentinel("CTX-DREAM");
     }
 
-    await deps.sendNotification(sessionId, "Starting dream run...", {});
+    await deps.sendNotification(sessionId, "Starting dream run...", dreamNotificationParams);
 
     const result = deps.dreamer.executeDream
         ? await deps.dreamer.executeDream(sessionId)
@@ -334,7 +339,7 @@ async function executeDreaming(
         result
             ? summarizeDreamResult(result)
             : "Dream queued, but another worker is already processing the queue.",
-        {},
+        dreamNotificationParams,
     );
     throwSentinel("CTX-DREAM");
 }
@@ -366,6 +371,8 @@ export function createMagicContextCommandHandler(deps: {
         text: string,
         params: NotificationParams,
     ) => Promise<void>;
+    /** Configured toast lifetime (ms) forwarded into diagnostics logs. */
+    toastDurationMs?: number;
     sidekick?: {
         config: SidekickConfig;
         projectPath: string;
@@ -434,7 +441,11 @@ export function createMagicContextCommandHandler(deps: {
             if (isStatus) {
                 if (isTuiConnected(sessionId)) {
                     // In TUI, push an RPC action so the TUI poller shows a native dialog
-                    pushNotification("action", { action: "show-status-dialog" }, sessionId);
+                    pushNotification(
+                        "action",
+                        { action: "show-status-dialog" },
+                        sessionId,
+                    );
                     sessionLog(sessionId, "command ctx-status: pushed show-status-dialog to TUI");
                     throwSentinel(input.command);
                 }

packages/plugin/src/hooks/magic-context/hook-handlers.ts

@@ -130,11 +130,13 @@ export function getLiveNotificationParams(
     liveModelBySession: LiveModelBySession,
     variantBySession: VariantBySession,
     agentBySession?: AgentBySession,
+    toastDurationMs?: number,
 ): {
     agent?: string;
     variant?: string;
     providerId?: string;
     modelId?: string;
+    toastDurationMs?: number;
 } {
     const model = liveModelBySession.get(sessionId);
     const variant = variantBySession.get(sessionId);
@@ -143,6 +145,7 @@ export function getLiveNotificationParams(
         ...(agent ? { agent } : {}),
         ...(variant ? { variant } : {}),
         ...(model ? { providerId: model.providerID, modelId: model.modelID } : {}),
+        ...(typeof toastDurationMs === "number" ? { toastDurationMs } : {}),
     };
 }
 

packages/plugin/src/hooks/magic-context/hook.ts

@@ -79,6 +79,7 @@ export interface MagicContextDeps {
     config: {
         protected_tags: number;
         ctx_reduce_enabled?: boolean;
+        toast_duration_ms?: number;
         clear_reasoning_age?: number;
         execute_threshold_percentage?: number | { default: number; [modelKey: string]: number };
         execute_threshold_tokens?: { default?: number; [modelKey: string]: number | undefined };
@@ -333,7 +334,13 @@ export function createMagicContextHook(deps: MagicContextDeps) {
         userMemoriesEnabled: dreamerConfig?.user_memories?.enabled === true,
         ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
         getNotificationParams: (sid) =>
-            getLiveNotificationParams(sid, liveModelBySession, variantBySession, agentBySession),
+            getLiveNotificationParams(
+                sid,
+                liveModelBySession,
+                variantBySession,
+                agentBySession,
+                deps.config.toast_duration_ms,
+            ),
     });
     const sidekickRunnable = isSidekickRunnable(deps.config);
     const sidekickConfig = sidekickRunnable ? deps.config.sidekick : undefined;
@@ -379,6 +386,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
                 liveModelBySession,
                 variantBySession,
                 agentBySession,
+                deps.config.toast_duration_ms,
             ),
         getModelKey: (sessionId) => {
             const model = liveModelBySession.get(sessionId);
@@ -444,6 +452,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
                 liveModelBySession,
                 variantBySession,
                 agentBySession,
+                deps.config.toast_duration_ms,
             ),
         onSessionCacheInvalidated: (sessionId: string) => {
             clearInjectionCache(sessionId);
@@ -523,6 +532,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
     const commandHandler = createMagicContextCommandHandler({
         db,
         protectedTags: deps.config.protected_tags,
+        toastDurationMs: deps.config.toast_duration_ms,
         executeThresholdPercentage: deps.config.execute_threshold_percentage ?? 65,
         executeThresholdTokens: deps.config.execute_threshold_tokens,
         historyBudgetPercentage: deps.config.history_budget_percentage,
@@ -573,6 +583,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
                     liveModelBySession,
                     variantBySession,
                     agentBySession,
+                    deps.config.toast_duration_ms,
                 ),
                 ...params,
             });
@@ -697,6 +708,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
                                       liveModelBySession,
                                       variantBySession,
                                       agentBySession,
+                                      deps.config.toast_duration_ms,
                                   ),
                               isTuiConnected,
                               pushTuiDialogAction: (sid, resume) =>

packages/plugin/src/hooks/magic-context/send-session-notification.ts

@@ -6,6 +6,8 @@ export interface NotificationParams {
     variant?: string;
     providerId?: string;
     modelId?: string;
+    /** TUI toast lifetime in milliseconds (default: 5000). */
+    toastDurationMs?: number;
 }
 
 export type NotificationDeliveryDisposition = "sent" | "skipped" | "failed";
@@ -71,31 +73,32 @@ export async function sendIgnoredMessage(
     // is too easy to miss — dogfood 2026-05-30.
     forcePersist = false,
 ): Promise<NotificationDeliveryDisposition> {
+    const title = extractToastTitle(text);
+    const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+    const toastVariant = inferToastVariant(text);
+    const duration = params.toastDurationMs ?? 5000;
+
     // In TUI mode, show as toast via RPC instead of ignored message — UNLESS the
     // caller asked to force-persist (long-running outcome must stay in scrollback).
     // Cannot use process.env.OPENCODE_CLIENT — it's undefined in the server plugin process.
     const { isTuiConnected: checkTui } = await import("../../shared/rpc-notifications");
     if (!forcePersist && checkTui(sessionId)) {
         try {
-            const c = client as Record<string, unknown>;
-            const tui = c?.tui as Record<string, unknown> | undefined;
-            if (typeof tui?.showToast === "function") {
-                // Intentional: call via property access to preserve `this` binding on the SDK client.
-                // The tui object is an SDK-generated client where methods live on the prototype.
-                const tuiClient = tui as Record<string, (...args: unknown[]) => Promise<unknown>>;
-                await tuiClient.showToast({
-                    body: {
-                        title: extractToastTitle(text),
-                        message: text.length > 200 ? `${text.slice(0, 200)}…` : text,
-                        variant: inferToastVariant(text),
-                        duration: 5000,
-                    },
-                });
-                return "sent";
-            }
+            const { pushNotification } = await import("../../shared/rpc-notifications");
+            pushNotification(
+                "toast",
+                {
+                    title,
+                    message,
+                    variant: toastVariant,
+                    duration,
+                },
+                sessionId,
+            );
+            return "sent";
         } catch {
-            // showToast failed or tui client is unavailable — fall through to ignored message.
-            sessionLog(sessionId, "TUI showToast failed, falling back to ignored message");
+            // RPC enqueue failed — fall through to ignored message.
+            sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
         }
     }
     // Title-safety guard (issue #129): an ignored message is hidden from the

packages/plugin/src/plugin/hooks/create-session-hooks.test.ts

@@ -0,0 +1,41 @@
+/// <reference types="bun-types" />
+
+import { beforeEach, describe, expect, it, mock } from "bun:test";
+
+const createMagicContextHookMock = mock(() => ({ mocked: true }));
+
+mock.module("../../hooks/magic-context", () => ({
+    createMagicContextHook: createMagicContextHookMock,
+}));
+
+describe("createSessionHooks", () => {
+    beforeEach(() => {
+        createMagicContextHookMock.mockClear();
+    });
+
+    it("threads notification config into the magic-context hook", async () => {
+        const { createSessionHooks } = await import("./create-session-hooks");
+
+        createSessionHooks({
+            ctx: {
+                client: {},
+                directory: "/tmp/project",
+            } as never,
+            liveSessionState: {
+                liveModelBySession: new Map(),
+                variantBySession: new Map(),
+                agentBySession: new Map(),
+            },
+            pluginConfig: {
+                enabled: true,
+                protected_tags: 10,
+                cache_ttl: "5m",
+                toast_duration_ms: 30_000,
+            } as never,
+        });
+
+        expect(createMagicContextHookMock).toHaveBeenCalledTimes(1);
+        const args = createMagicContextHookMock.mock.calls[0]?.[0] as { config?: { toast_duration_ms?: number } };
+        expect(args.config?.toast_duration_ms).toBe(30_000);
+    });
+});