@sayknow-cli/coding-agent 0.2.7 → 0.3.1

package/src/modes/shared/agent-wire/unattended-session.ts

@@ -59,6 +59,14 @@ export interface WorkflowGateEmitter {
 	isUnattended(): boolean;
 	/** Open + emit a gate; resolves with the agent's answer (from workflow_gate_response). */
 	emitGate(input: OpenGateInput): Promise<unknown>;
+	/**
+	 * Optional bridge surface (present on {@link UnattendedSessionControlPlane}) that
+	 * lets an in-process extension observe emitted gates and answer them — used by
+	 * the notifications SDK to resolve a real ask gate from a remote reply.
+	 */
+	onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
+	resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+	listPendingGates?(): RpcWorkflowGate[];
 }
 
 export interface UnattendedSessionOptions {
@@ -82,6 +90,7 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 	#broker: WorkflowGateBroker | undefined;
 	readonly #pending = new Map<string, { resolve: (answer: unknown) => void; reject: (err: Error) => void }>();
 	readonly #earlyAnswers = new Map<string, unknown>();
+	readonly #gateListeners = new Set<(gate: RpcWorkflowGate) => void>();
 
 	constructor(private readonly opts: UnattendedSessionOptions) {}
 
@@ -89,6 +98,12 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 		return this.#controller !== undefined;
 	}
 
+	/** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
+	onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void {
+		this.#gateListeners.add(listener);
+		return () => this.#gateListeners.delete(listener);
+	}
+
 	get controller(): UnattendedRunController | undefined {
 		return this.#controller;
 	}
@@ -195,6 +210,13 @@ export class UnattendedSessionControlPlane implements RpcUnattendedControlPlane,
 			return Promise.reject(new Error("cannot emit a workflow gate before unattended mode is negotiated"));
 		}
 		const gate = this.#broker.openGate(input);
+		for (const listener of this.#gateListeners) {
+			try {
+				listener(gate);
+			} catch {
+				// A misbehaving observer must never break gate emission.
+			}
+		}
 		if (this.#earlyAnswers.has(gate.gate_id)) {
 			const answer = this.#earlyAnswers.get(gate.gate_id);
 			this.#earlyAnswers.delete(gate.gate_id);

package/src/modes/theme/theme.ts

@@ -183,6 +183,7 @@ export type SymbolKey =
 	| "tab.appearance"
 	| "tab.model"
 	| "tab.interaction"
+	| "tab.notifications"
 	| "tab.context"
 	| "tab.editing"
 	| "tab.tools"
@@ -347,6 +348,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"tab.appearance": "🎨",
 	"tab.model": "🤖",
 	"tab.interaction": "⌨",
+	"tab.notifications": "🔔",
 	"tab.context": "📋",
 	"tab.editing": "💻",
 	"tab.tools": "🔧",
@@ -606,6 +608,7 @@ const NERD_SYMBOLS: SymbolMap = {
 	"tab.appearance": "󰃣",
 	"tab.model": "󰚩",
 	"tab.interaction": "󰌌",
+	"tab.notifications": "󰂚",
 	"tab.context": "󰘸",
 	"tab.editing": "",
 	"tab.tools": "󰠭",
@@ -768,6 +771,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"tab.appearance": "[A]",
 	"tab.model": "[M]",
 	"tab.interaction": "[I]",
+	"tab.notifications": "[N]",
 	"tab.context": "[X]",
 	"tab.editing": "[E]",
 	"tab.tools": "[T]",

package/src/modes/types.ts

@@ -17,6 +17,7 @@ import type { MCPManager } from "../runtime-mcp";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { CredentialAutoImportOptions } from "../setup/credential-auto-import";
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -247,7 +248,7 @@ export interface InteractiveModeContext {
 	showSessionSelector(): void;
 	handleResumeSession(sessionPath: string): Promise<void>;
 	handleSessionDeleteCommand(): Promise<void>;
-	showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+	showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;
 	showDebugSelector(): void;
 	showSessionObserver(): void;
@@ -311,3 +312,8 @@ export interface InteractiveModeContext {
 	showExtensionError(extensionPath: string, error: string): void;
 	showToolError(toolName: string, error: string): void;
 }
+export interface OAuthSelectorOptions {
+	allowExternalCredentialDiscovery?: boolean;
+	trigger?: "bare-login";
+	externalCredentialDiscover?: CredentialAutoImportOptions["discover"];
+}

package/src/modes/utils/context-usage.ts

@@ -204,14 +204,14 @@ export function computeContextBreakdown(
 	if (contextWindow > 0) {
 		const compactionSettings = session.settings.getGroup("compaction") as CompactionSettings;
 		if (compactionSettings.enabled && compactionSettings.strategy !== "off") {
-			const threshold = resolveThresholdTokens(contextWindow, compactionSettings, model?.maxTokens ?? 0);
+			const threshold = resolveThresholdTokens(contextWindow, compactionSettings);
 			autoCompactBufferTokens = Math.max(0, contextWindow - threshold);
 		} else {
 			autoCompactBufferTokens = 0;
 		}
 		// Even when fully disabled, fall back to a sensible reserve floor for display.
 		if (autoCompactBufferTokens === 0 && compactionSettings.enabled) {
-			autoCompactBufferTokens = effectiveReserveTokens(contextWindow, compactionSettings, model?.maxTokens ?? 0);
+			autoCompactBufferTokens = effectiveReserveTokens(contextWindow, compactionSettings);
 		}
 	}
 	autoCompactBufferTokens = Math.min(autoCompactBufferTokens, Math.max(0, contextWindow - usedTokens));

package/src/modes/utils/ui-helpers.ts

@@ -205,6 +205,29 @@ export class UiHelpers {
 						}
 						return components;
 					}
+					if (message.customType === "subagent:steer" || message.customType === "subagent:steer:relay") {
+						const details = (
+							message as CustomMessage<{
+								from?: string;
+								to?: string;
+								body?: string;
+								state?: string;
+							}>
+						).details;
+						const components: Component[] = [];
+						const header = `${theme.fg("accent", `[Steer ${details?.state ?? "queued"}] ${details?.from ?? "?"} ⇨ ${details?.to ?? "?"}`)}`;
+						const headerComponent = new Text(header, 1, 0);
+						this.ctx.chatContainer.addChild(headerComponent);
+						components.push(headerComponent);
+						if (details?.body) {
+							for (const line of details.body.split("\n")) {
+								const lineComponent = new Text(theme.fg("muted", `  ${line}`), 0, 0);
+								this.ctx.chatContainer.addChild(lineComponent);
+								components.push(lineComponent);
+							}
+						}
+						return components;
+					}
 					const renderer = this.ctx.session.extensionRunner?.getMessageRenderer(message.customType);
 					// Both HookMessage and CustomMessage have the same structure, cast for compatibility
 					const component = new CustomMessageComponent(message as CustomMessage<unknown>, renderer);

package/src/notifications/attachment-registry.ts

@@ -0,0 +1,23 @@
+/**
+ * Process-wide registry mapping a session id to a sink that delivers a local
+ * file to the session's connected Telegram chat as a document. Registered by
+ * the notifications extension; consumed by the telegram_send tool.
+ */
+
+/** Delivers a local file to the session's Telegram chat. */
+export type TelegramFileSink = (file: { path: string; caption?: string }) => Promise<{ ok: boolean; error?: string }>;
+
+const sinks = new Map<string, TelegramFileSink>();
+
+/** Register `sink` for `sessionId`. Returns a disposer that clears it. */
+export function registerTelegramFileSink(sessionId: string, sink: TelegramFileSink): () => void {
+	sinks.set(sessionId, sink);
+	return () => {
+		if (sinks.get(sessionId) === sink) sinks.delete(sessionId);
+	};
+}
+
+/** The Telegram file sink for `sessionId`, if one is registered. */
+export function getTelegramFileSink(sessionId: string): TelegramFileSink | undefined {
+	return sinks.get(sessionId);
+}

package/src/notifications/chat-adapters.ts

@@ -0,0 +1,147 @@
+import type {
+	NotificationAdapterPayload,
+	NotificationEvent,
+	NotificationPresentationAdapter,
+	NotificationReplyRoute,
+} from "./engine";
+import { truncate } from "./helpers";
+
+type AdapterKind = "discord" | "slack";
+
+interface ChatAdapterOptions {
+	kind: AdapterKind;
+	channelId?: string;
+}
+
+interface InboundShape {
+	sessionId?: unknown;
+	actionId?: unknown;
+	answer?: unknown;
+	text?: unknown;
+	value?: unknown;
+}
+
+function text(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function publicLine(label: string, value: unknown): string | undefined {
+	const v = text(value);
+	return v ? `${label}: ${truncate(v, 280)}` : undefined;
+}
+
+function actionText(event: Extract<NotificationEvent, { type: "action_needed" }>, format: "discord" | "slack"): string {
+	if (event.kind === "idle") {
+		const summary = text(event.summary);
+		return summary ? `Agent idle\n${truncate(summary, 1200)}` : "Agent idle";
+	}
+	const question = truncate(text(event.question) ?? "Question", 1200);
+	const options = Array.isArray(event.options) ? event.options.map(option => String(option)) : [];
+	const lines = [`Question: ${question}`];
+	if (options.length > 0) {
+		lines.push(
+			...options.map((option, index) => {
+				const label = truncate(option, 180);
+				return format === "slack" ? `${index + 1}. ${label}` : `**${index + 1}.** ${label}`;
+			}),
+		);
+	} else {
+		lines.push("Reply with text.");
+	}
+	return lines.join("\n");
+}
+
+function frameText(event: Extract<NotificationEvent, { type: "frame" }>): string | undefined {
+	const frame = event.frame;
+	const kind = text(frame.type);
+	if (!kind) return undefined;
+	const lines = [`SKC ${kind.replace(/_/g, " ")}`];
+	for (const line of [
+		publicLine("title", frame.title),
+		publicLine("repo", frame.repo),
+		publicLine("branch", frame.branch),
+		publicLine("task", frame.task),
+		publicLine("goal", frame.goal),
+		publicLine("model", frame.model),
+	]) {
+		if (line) lines.push(line);
+	}
+	const body = text(frame.text) ?? text(frame.lastMessage) ?? text(frame.caption);
+	if (body) lines.push(truncate(body, 1800));
+	return lines.join("\n");
+}
+
+function routeFromInbound(input: unknown): NotificationReplyRoute | undefined {
+	const raw = input as InboundShape;
+	if (!raw || typeof raw !== "object") return undefined;
+	const sessionId = text(raw.sessionId);
+	const actionId = text(raw.actionId);
+	if (!sessionId || !actionId) return undefined;
+	const answer = raw.answer ?? raw.value ?? raw.text;
+	if (typeof answer !== "string" && typeof answer !== "number" && typeof answer !== "object") return undefined;
+	return { sessionId, actionId, answer: answer as NotificationReplyRoute["answer"] };
+}
+
+class DiscordNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "discord" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const content = event.type === "action_needed" ? actionText(event, "discord") : frameText(event);
+		if (!content) return [];
+		const payload: Record<string, unknown> = {
+			content,
+			allowed_mentions: { parse: [] },
+		};
+		if (this.opts.channelId) payload.channel_id = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+class SlackNotificationAdapter implements NotificationPresentationAdapter {
+	readonly kind = "slack" as const;
+	constructor(private readonly opts: ChatAdapterOptions) {}
+
+	render(event: NotificationEvent): NotificationAdapterPayload[] {
+		if (event.type === "action_resolved") return [];
+		const textValue = event.type === "action_needed" ? actionText(event, "slack") : frameText(event);
+		if (!textValue) return [];
+		const payload: Record<string, unknown> = {
+			text: textValue,
+			mrkdwn: true,
+		};
+		if (this.opts.channelId) payload.channel = this.opts.channelId;
+		return [
+			{
+				adapter: this.kind,
+				channelKey: this.opts.channelId,
+				body: payload,
+				route: event.type === "action_needed" ? { sessionId: event.sessionId, actionId: event.id } : undefined,
+			},
+		];
+	}
+
+	mapInbound(input: unknown): NotificationReplyRoute | undefined {
+		return routeFromInbound(input);
+	}
+}
+
+export function createDiscordAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new DiscordNotificationAdapter({ ...opts, kind: "discord" });
+}
+
+export function createSlackAdapter(opts: Omit<ChatAdapterOptions, "kind"> = {}): NotificationPresentationAdapter {
+	return new SlackNotificationAdapter({ ...opts, kind: "slack" });
+}

package/src/notifications/config-commands.ts

@@ -0,0 +1,50 @@
+/**
+ * In-thread configuration slash commands for the threaded session surface.
+ *
+ * Replies are thread-native now (the old `/answer <sessionId> …` command is
+ * removed), but the user can still adjust per-surface behaviour from inside a
+ * session thread with small slash commands:
+ *
+ * - `/verbose`            switch the mirror to verbose (full tool output + reasoning)
+ * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbosity lean|verbose`
+ * - `/redact on|off`      toggle redaction of streamed content
+ *
+ * This parser is pure so the command grammar is unit-testable; the daemon maps
+ * the returned change onto a `config_command` frame / settings update.
+ */
+
+/** A parsed in-thread configuration change. */
+export interface ConfigCommandChange {
+	verbosity?: "lean" | "verbose";
+	redact?: boolean;
+}
+
+/**
+ * Parse an in-thread config command. Returns the requested change, or
+ * `undefined` when the text is not a recognised config command (so the daemon
+ * can fall through to treating it as a free-text injection).
+ */
+export function parseInThreadConfigCommand(text: string): ConfigCommandChange | undefined {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("/")) return undefined;
+	const [rawCommand, ...rest] = trimmed.slice(1).split(/\s+/);
+	const command = rawCommand?.toLowerCase();
+	const arg = rest[0]?.toLowerCase();
+
+	switch (command) {
+		case "verbose":
+			return { verbosity: "verbose" };
+		case "lean":
+			return { verbosity: "lean" };
+		case "verbosity":
+			if (arg === "lean" || arg === "verbose") return { verbosity: arg };
+			return undefined;
+		case "redact":
+			if (arg === "on" || arg === "true" || arg === "1") return { redact: true };
+			if (arg === "off" || arg === "false" || arg === "0") return { redact: false };
+			return undefined;
+		default:
+			return undefined;
+	}
+}

package/src/notifications/config.ts

@@ -0,0 +1,128 @@
+import * as crypto from "node:crypto";
+import type { Settings } from "../config/settings";
+
+export interface NotificationConfig {
+	enabled: boolean;
+	botToken?: string;
+	chatId?: string;
+	discord: {
+		botToken?: string;
+		channelId?: string;
+	};
+	slack: {
+		botToken?: string;
+		channelId?: string;
+	};
+	redact: boolean;
+	verbosity: "lean" | "verbose";
+	idleTimeoutMs: number;
+}
+
+/** Read typed config from Settings. */
+export function getNotificationConfig(settings: Settings): NotificationConfig {
+	return {
+		enabled: settings.get("notifications.enabled"),
+		botToken: settings.get("notifications.telegram.botToken"),
+		chatId: settings.get("notifications.telegram.chatId"),
+		discord: {
+			botToken: settings.get("notifications.discord.botToken"),
+			channelId: settings.get("notifications.discord.channelId"),
+		},
+		slack: {
+			botToken: settings.get("notifications.slack.botToken"),
+			channelId: settings.get("notifications.slack.channelId"),
+		},
+		redact: settings.get("notifications.redact"),
+		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
+		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
+	};
+}
+
+/** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
+export function isGloballyConfigured(cfg: NotificationConfig): boolean {
+	return (
+		cfg.enabled &&
+		((Boolean(cfg.botToken) && Boolean(cfg.chatId)) ||
+			(Boolean(cfg.discord.botToken) && Boolean(cfg.discord.channelId)) ||
+			(Boolean(cfg.slack.botToken) && Boolean(cfg.slack.channelId)))
+	);
+}
+
+/** Resolve whether the notifications extension should be registered at SDK startup. */
+export function shouldRegisterNotificationsExtension(input: {
+	env: NodeJS.ProcessEnv;
+	cfg?: NotificationConfig;
+}): boolean {
+	if (input.env.SKC_NOTIFICATIONS === "0") return false;
+	if (input.env.SKC_NOTIFICATIONS === "1" || input.env.SKC_NOTIFICATIONS_TOKEN) return true;
+	return input.cfg ? isGloballyConfigured(input.cfg) : false;
+}
+
+/**
+ * Resolve whether THIS session should run notifications.
+ * Precedence (highest first):
+ *  1) env.SKC_NOTIFICATIONS === "0"  -> false (hard opt-out)
+ *  2) sessionDisabled === true       -> false (local /notify off)
+ *  3) env.SKC_NOTIFICATIONS === "1" || env.SKC_NOTIFICATIONS_TOKEN present -> true (legacy explicit)
+ *  4) isGloballyConfigured(cfg)      -> true (global auto-on)
+ *  5) otherwise false
+ */
+export function isSessionNotificationsEnabled(input: {
+	cfg: NotificationConfig;
+	env: NodeJS.ProcessEnv;
+	sessionDisabled: boolean;
+}): boolean {
+	if (input.env.SKC_NOTIFICATIONS === "0") return false;
+	if (input.sessionDisabled) return false;
+	if (input.env.SKC_NOTIFICATIONS === "1" || input.env.SKC_NOTIFICATIONS_TOKEN) return true;
+	return isGloballyConfigured(input.cfg);
+}
+
+/** Mask a bot token for display: first 4 chars + "…" + "(len N)"; "(unset)" when undefined/empty. Never reveal full token. */
+export function maskToken(token: string | undefined): string {
+	if (!token) return "(unset)";
+	return `${token.slice(0, 4)}…(len ${token.length})`;
+}
+
+/** Stable non-reversible fingerprint of a token: sha256 hex, first 12 chars. */
+export function tokenFingerprint(token: string): string {
+	return crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+
+/** Short session tag for display, e.g. last 6 chars of sessionId. */
+export function sessionTag(sessionId: string): string {
+	return sessionId.slice(-6);
+}
+
+export interface RedactableAction {
+	id: string;
+	kind: string;
+	sessionId: string;
+	question?: string;
+	options?: string[];
+	summary?: string;
+}
+
+/**
+ * When redact is true, strip sensitive content for remote delivery:
+ *  - ask: NOT redacted. An ask is an interactive prompt the human must read and
+ *    answer on the remote surface; redacting its question/options would make it
+ *    unanswerable, defeating remote answering. Asks are returned unchanged.
+ *  - idle: summary removed, (no question/options).
+ * When redact is false, return the action unchanged.
+ *
+ * Redaction still applies to streamed content frames (turn_stream, context_update,
+ * image_attachment) which are suppressed at their emit sites, not here.
+ */
+export function buildRedactedAction(
+	action: RedactableAction,
+	opts: { redact: boolean; sessionTag: string },
+): RedactableAction {
+	if (!opts.redact) return action;
+
+	// Asks stay fully readable/answerable even under redaction.
+	if (action.kind === "ask") return action;
+
+	const { summary: _summary, question: _question, ...base } = action;
+	return base;
+}

package/src/notifications/engine.ts

@@ -0,0 +1,100 @@
+import { buildRedactedAction, type RedactableAction } from "./config";
+
+export type NotificationEvent =
+	| ({ type: "action_needed" } & RedactableAction)
+	| { type: "action_resolved"; id: string; sessionId: string; resolvedBy?: string }
+	| { type: "frame"; sessionId: string; frame: Record<string, unknown> };
+
+export interface NotificationReplyRoute {
+	sessionId: string;
+	actionId: string;
+	answer: number | string | { selected?: Array<number | string>; custom?: string };
+}
+
+export interface NotificationAdapterPayload {
+	adapter: string;
+	channelKey?: string;
+	body: unknown;
+	route?: Omit<NotificationReplyRoute, "answer">;
+}
+
+export interface NotificationPresentationAdapter {
+	readonly kind: "telegram" | "discord" | "slack";
+	render(event: NotificationEvent): NotificationAdapterPayload[];
+	mapInbound(input: unknown): NotificationReplyRoute | undefined;
+}
+
+export interface EngineSessionSink {
+	sendReply(route: NotificationReplyRoute): void;
+}
+
+export interface NotificationEngineOptions {
+	redact: boolean;
+	sessionTag: (sessionId: string) => string;
+}
+
+/**
+ * Shared presentation engine for managed notification clients.
+ *
+ * It owns fanout, redaction boundaries, pending-action routing, and reply
+ * delivery into session sinks. Transport adapters stay pure: render an internal
+ * event into a public-safe payload and map an inbound transport interaction
+ * back into a session/action answer.
+ */
+export class NotificationPresentationEngine {
+	readonly adapters: readonly NotificationPresentationAdapter[];
+	private readonly sessions = new Map<string, EngineSessionSink>();
+	private readonly pending = new Map<string, { sessionId: string; actionId: string }>();
+
+	constructor(
+		adapters: readonly NotificationPresentationAdapter[],
+		private readonly opts: NotificationEngineOptions,
+	) {
+		this.adapters = adapters;
+	}
+
+	connectSession(sessionId: string, sink: EngineSessionSink): void {
+		this.sessions.set(sessionId, sink);
+	}
+
+	dropSession(sessionId: string): void {
+		this.sessions.delete(sessionId);
+		for (const [key, route] of this.pending) {
+			if (route.sessionId === sessionId) this.pending.delete(key);
+		}
+	}
+
+	fanout(event: NotificationEvent): NotificationAdapterPayload[] {
+		const safeEvent = this.redactEvent(event);
+		if (safeEvent.type === "action_needed" && safeEvent.kind === "ask") {
+			this.pending.set(safeEvent.id, { sessionId: safeEvent.sessionId, actionId: safeEvent.id });
+		}
+		if (safeEvent.type === "action_resolved") {
+			this.pending.delete(safeEvent.id);
+		}
+		return this.adapters.flatMap(adapter => adapter.render(safeEvent));
+	}
+
+	routeInbound(adapterKind: NotificationPresentationAdapter["kind"], input: unknown): boolean {
+		const adapter = this.adapters.find(candidate => candidate.kind === adapterKind);
+		const route = adapter?.mapInbound(input);
+		if (!route) return false;
+		const pending = this.pending.get(route.actionId);
+		if (!pending || pending.sessionId !== route.sessionId) return false;
+		const sink = this.sessions.get(route.sessionId);
+		if (!sink) return false;
+		sink.sendReply(route);
+		return true;
+	}
+
+	private redactEvent(event: NotificationEvent): NotificationEvent {
+		if (event.type !== "action_needed") return event;
+		return {
+			...buildRedactedAction(event, {
+				redact: this.opts.redact,
+				sessionTag: this.opts.sessionTag(event.sessionId),
+			}),
+			type: "action_needed",
+		};
+	}
+}