@gajae-code/coding-agent 0.11.3 → 0.11.5

package/src/main.ts

@@ -20,6 +20,7 @@ import {
 	VERSION,
 } from "@gajae-code/utils";
 import chalk from "chalk";
+import { runCli } from "./cli";
 import type { Args } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { buildInitialMessage } from "./cli/initial-message";
@@ -36,6 +37,8 @@ import { BUNDLED_GROK_BUILD_EXTENSION_ID, getBundledGrokBuildExtensionFactory }
 import { initializeWithSettings } from "./discovery";
 import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import { admitManagedOwnerBeforeCli, completeManagedOwnerRecovery } from "./gjc-runtime/managed-owner-admission";
+import { isManagedOwnerSupervisorArgv, runManagedOwnerSupervisor } from "./gjc-runtime/managed-owner-supervisor";
 import { persistCoordinatorRuntimeInputReady } from "./gjc-runtime/session-state-sidecar";
 import { isTmuxOwnerIsolationCliArgv, runTmuxOwnerIsolationCliFromStdin } from "./gjc-runtime/tmux-owner-isolation-cli";
 import type { AcpStartupOptions } from "./modes/acp/startup-options";
@@ -58,6 +61,7 @@ import type { AgentSession } from "./session/agent-session";
 import {
 	type ResumeSessionIdentity,
 	resolveResumableSession,
+	type SessionDestination,
 	type SessionDirectoryMigrationPolicy,
 	type SessionInfo,
 	SessionManager,
@@ -535,7 +539,8 @@ type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string) => Promise
 type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelectionResult>;
 type OpenExistingSessionStrict = (
 	identity: ResumeSessionIdentity,
-	sessionDir?: string,
+	destination: SessionDestination,
+	storage?: undefined,
 	migrationPolicy?: SessionDirectoryMigrationPolicy,
 ) => Promise<StrictSessionOpenResult>;
 
@@ -722,6 +727,10 @@ export async function createSessionManager(
 	activeSettings: Settings = settings,
 ): Promise<SessionManager | undefined> {
 	const migrationPolicy = activeSettings.get("session.directoryMigration") === "disabled" ? "disabled" : "copy-retain";
+	const sessionDestination = () =>
+		parsed.sessionDir
+			? SessionManager.explicitDestination(parsed.sessionDir)
+			: SessionManager.managedDestination(cwd, activeSettings.getAgentDir());
 	if (parsed.resume === true) {
 		return undefined;
 	}
@@ -731,13 +740,13 @@ export async function createSessionManager(
 		}
 		const forkSource = parsed.fork;
 		if (forkSource.includes("/") || forkSource.includes("\\") || forkSource.endsWith(".jsonl")) {
-			return await SessionManager.forkFrom(forkSource, cwd, parsed.sessionDir, undefined, migrationPolicy);
+			return await SessionManager.forkFrom(forkSource, cwd, sessionDestination(), undefined, migrationPolicy);
 		}
 		const match = await resolveResumableSession(forkSource, cwd, parsed.sessionDir);
 		if (!match) {
 			throw new Error(`Session "${forkSource}" not found.`);
 		}
-		return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir, undefined, migrationPolicy);
+		return await SessionManager.forkFrom(match.session.path, cwd, sessionDestination(), undefined, migrationPolicy);
 	}
 
 	if (parsed.noSession) {
@@ -746,7 +755,12 @@ export async function createSessionManager(
 	if (typeof parsed.resume === "string") {
 		const sessionArg = parsed.resume;
 		if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-			return await SessionManager.open(sessionArg, parsed.sessionDir, undefined, migrationPolicy);
+			return await SessionManager.open(
+				sessionArg,
+				SessionManager.explicitDestination(path.dirname(sessionArg)),
+				undefined,
+				migrationPolicy,
+			);
 		}
 		const match = await resolveResumableSession(sessionArg, cwd, parsed.sessionDir);
 		if (!match) {
@@ -763,21 +777,21 @@ export async function createSessionManager(
 				return await SessionManager.forkFrom(
 					match.session.path,
 					cwd,
-					parsed.sessionDir,
+					sessionDestination(),
 					undefined,
 					migrationPolicy,
 				);
 			}
 		}
-		return await SessionManager.open(match.session.path, parsed.sessionDir, undefined, migrationPolicy);
+		return await SessionManager.open(match.session.path, sessionDestination(), undefined, migrationPolicy);
 	}
 	if (parsed.continue) {
-		return await SessionManager.continueRecent(cwd, parsed.sessionDir, undefined, migrationPolicy);
+		return await SessionManager.continueRecent(cwd, sessionDestination(), undefined, migrationPolicy);
 	}
 	// --resume without value is handled separately (needs picker UI)
 	// If --session-dir provided without --continue/--resume, create new session there
 	if (parsed.sessionDir) {
-		return SessionManager.create(cwd, parsed.sessionDir);
+		return SessionManager.create(cwd, SessionManager.explicitDestination(parsed.sessionDir));
 	}
 	// A lifecycle `/session_create` child must start a FRESH session that adopts
 	// the pre-allocated id (GJC_SESSION_ID), never auto-resume existing history in
@@ -795,14 +809,13 @@ export async function createSessionManager(
 	// buildSessionOptions restores the session's model/thinking instead of
 	// overriding them with CLI defaults.
 	if (activeSettings.get("autoResume")) {
-		const manager = await SessionManager.continueRecent(cwd, parsed.sessionDir, undefined, migrationPolicy);
+		const manager = await SessionManager.continueRecent(cwd, sessionDestination(), undefined, migrationPolicy);
 		if (manager.getEntries().length > 0) {
 			parsed.continue = true;
 		}
 		return manager;
 	}
-	const sessionDir = parsed.sessionDir ?? SessionManager.getDefaultSessionDir(cwd, activeSettings.getAgentDir());
-	return SessionManager.create(cwd, sessionDir);
+	return SessionManager.create(cwd, SessionManager.managedDestination(cwd, activeSettings.getAgentDir()));
 }
 
 async function maybeAutoChdir(parsed: Args): Promise<void> {
@@ -1106,7 +1119,9 @@ export async function runRootCommand(
 		try {
 			opened = await (deps.openExistingSessionStrict ?? SessionManager.openExistingStrict)(
 				selection.identity,
-				parsedArgs.sessionDir,
+				parsedArgs.sessionDir
+					? SessionManager.explicitDestination(parsedArgs.sessionDir)
+					: SessionManager.managedDestination(resumeCwd, settings.getAgentDir()),
 				undefined,
 				resumeMigrationPolicy,
 			);
@@ -1604,6 +1619,15 @@ export async function main(args: string[]): Promise<void> {
 		await runTmuxOwnerIsolationCliFromStdin();
 		return;
 	}
-	const { runCli } = await import("./cli");
+	if (isManagedOwnerSupervisorArgv(args)) {
+		await runManagedOwnerSupervisor();
+		return;
+	}
+	const admission = await admitManagedOwnerBeforeCli();
+	if (admission.kind === "blocked") return;
+	if (admission.kind === "recovery") {
+		await completeManagedOwnerRecovery(admission.context);
+		return;
+	}
 	await runCli(args.length === 0 ? ["launch"] : args);
 }

package/src/modes/acp/acp-agent.ts

@@ -74,6 +74,7 @@ interface PromptWaiter {
 	/** Highest inbound frame sequence already observed when the prompt was acknowledged. */
 	boundary: number;
 	correlation: PromptCorrelation;
+	messageProgress?: { textEmitted: boolean; thoughtEmitted: boolean };
 	pendingTerminal?: PromptCorrelation;
 	resolve: (response: PromptResponse) => void;
 	reject: (error: Error) => void;
@@ -1298,9 +1299,16 @@ export class AcpAgent implements Agent {
 		if (wirePayload) {
 			for (const notification of mapAgentWireEventPayloadToAcpSessionUpdates(wirePayload as never, id, {
 				cwd: record.cwd,
+				getMessageProgress: message => {
+					if (!activePrompt || !object(message)) return undefined;
+					activePrompt.messageProgress ??= { textEmitted: false, thoughtEmitted: false };
+					return activePrompt.messageProgress;
+				},
 			}))
 				await this.#publishSessionUpdate(id, notification, adapter);
 		}
+		if (event.type === "message_end" && object(event.message)?.role === "assistant" && activePrompt)
+			activePrompt.messageProgress = undefined;
 		if (event.type === "agent_end") await this.#emitEndOfTurnUpdates(id, adapter);
 		if (activePrompt) this.#settlePrompt(record, activePrompt);
 	}

package/src/modes/components/ansi-display-validator.ts

@@ -0,0 +1,54 @@
+/** Removes every terminal control sequence except bounded SGR parameters (0-255). */
+export function validateDisplayLine(line: string): string {
+	let result = "";
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index]!;
+		const code = char.charCodeAt(0);
+		if (char === "\t") {
+			result += "    ";
+			continue;
+		}
+		if (char === "\x1b") {
+			const next = line[index + 1];
+			if (next === "[") {
+				const match = /^\x1b\[([0-9]{1,3}(?:;[0-9]{1,3})*)m/.exec(line.slice(index));
+				if (match && match[0].length <= 64 && match[1]!.split(";").every(parameter => Number(parameter) <= 255)) {
+					result += match[0];
+					index += match[0].length - 1;
+					continue;
+				}
+				index = skipEscapeSequence(line, index + 2, /[@-~]/);
+				continue;
+			}
+			if (next === "]" || next === "P" || next === "_" || next === "^" || next === "X") {
+				index = skipStringControl(line, index + 2);
+				continue;
+			}
+			if (next === "_") {
+				index = skipStringControl(line, index + 2);
+				continue;
+			}
+			index += next ? 1 : 0;
+			continue;
+		}
+		if (code >= 0x80 && code <= 0x9f) continue;
+		if (code < 0x20 || code === 0x7f) continue;
+		result += char;
+	}
+	return result;
+}
+
+function skipEscapeSequence(text: string, start: number, final: RegExp): number {
+	for (let index = start; index < text.length; index++) {
+		if (final.test(text[index]!)) return index;
+	}
+	return text.length - 1;
+}
+
+function skipStringControl(text: string, start: number): number {
+	for (let index = start; index < text.length; index++) {
+		if (text[index] === "\x07") return index;
+		if (text[index] === "\x1b" && text[index + 1] === "\\") return index + 1;
+	}
+	return text.length - 1;
+}

package/src/modes/components/custom-editor.ts

@@ -59,9 +59,22 @@ const DEFAULT_ACTION_KEYS = Object.fromEntries(
 
 const PASTE_DECISION_TIMEOUT_MS = 5_000;
 const PENDING_PASTE_INPUT_MAX = 64;
+const PENDING_PASTE_INPUT_MAX_BYTES = 256 * 1024;
 
 type PastePendingClearReason = "timeout" | "queue-limit";
 
+export interface PasteTextContext {
+	readonly signal: AbortSignal;
+	/** Run one synchronous composer mutation only while this paste transaction is current. */
+	commit(commit: () => boolean): boolean;
+}
+
+interface PendingPasteDecision {
+	readonly controller: AbortController;
+	readonly pasteContent: string;
+	readonly remaining: string;
+}
+
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
@@ -94,9 +107,9 @@ export class CustomEditor extends Editor {
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
 	/** Called before bracketed paste content is inserted. Return true to consume it. */
-	onPasteText?: (text: string) => boolean | Promise<boolean>;
-	/** Called when async paste handling drops queued input instead of replaying it. */
-	onPastePendingInputCleared?: (reason: PastePendingClearReason, droppedInputCount: number) => void;
+	onPasteText?: (text: string, context: PasteTextContext) => boolean | Promise<boolean>;
+	/** Called when pending paste handling is cancelled after restoring queued input. */
+	onPastePendingInputCleared?: (reason: PastePendingClearReason, restoredInputCount: number) => void;
 	/** Called when the configured dequeue shortcut is pressed. */
 	onDequeue?: () => void;
 	/** Called when the configured queue shortcut is pressed. */
@@ -117,7 +130,9 @@ export class CustomEditor extends Editor {
 	#pasteDecisionPending = false;
 	#pasteDecisionToken = 0;
 	#pasteDecisionTimeout: NodeJS.Timeout | undefined;
+	#pendingPasteDecision: PendingPasteDecision | undefined;
 	#pendingPasteInput: string[] = [];
+	#pendingPasteInputBytes = 0;
 
 	setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void {
 		this.#actionKeys.set(action, [...keys]);
@@ -165,75 +180,127 @@ export class CustomEditor extends Editor {
 		}
 	}
 
-	#clearPendingPasteState(): number {
+	#resetPendingPasteState(abortReason?: Error): string[] {
 		this.#clearPasteDecisionTimeout();
+		if (abortReason) this.#pendingPasteDecision?.controller.abort(abortReason);
 		this.#pasteDecisionPending = false;
 		this.#pasteDecisionToken += 1;
-		const droppedInputCount = this.#pendingPasteInput.length;
+		this.#pendingPasteDecision = undefined;
+		const queuedInput = this.#pendingPasteInput;
 		this.#pendingPasteInput = [];
-		return droppedInputCount;
+		this.#pendingPasteInputBytes = 0;
+		return queuedInput;
+	}
+
+	#pendingPasteEventCount(): number {
+		return this.#pendingPasteInput.length + (this.#pendingPasteDecision?.remaining ? 1 : 0);
+	}
+
+	#restoreCancelledPaste(reason: PastePendingClearReason, overflowInput?: string): void {
+		const decision = this.#pendingPasteDecision;
+		const queuedInput = this.#resetPendingPasteState(new Error(`Paste handling cancelled: ${reason}`));
+		if (decision) {
+			super.handleInput(`\x1b[200~${decision.pasteContent}\x1b[201~`);
+			this.#drainPendingPasteInput(decision.remaining, queuedInput);
+			if (overflowInput !== undefined) this.handleInput(overflowInput);
+		}
+		this.onPastePendingInputCleared?.(
+			reason,
+			queuedInput.length + (decision?.remaining ? 1 : 0) + (overflowInput === undefined ? 0 : 1),
+		);
 	}
 
 	#startPasteDecisionTimeout(token: number): void {
 		this.#clearPasteDecisionTimeout();
 		this.#pasteDecisionTimeout = setTimeout(() => {
 			if (token !== this.#pasteDecisionToken) return;
-			const droppedInputCount = this.#clearPendingPasteState();
-			this.onPastePendingInputCleared?.("timeout", droppedInputCount);
+			this.#restoreCancelledPaste("timeout");
 		}, PASTE_DECISION_TIMEOUT_MS);
 		this.#pasteDecisionTimeout.unref?.();
 	}
 
 	dispose(): void {
-		this.#clearPendingPasteState();
+		this.#resetPendingPasteState(new Error("Editor disposed during paste handling"));
 		this.#pasteHandler = new BracketedPasteHandler();
 		super.dispose();
 	}
 
-	#drainPendingPasteInput(initialInput?: string): void {
+	#drainPendingPasteInput(initialInput: string | undefined, queuedInput: readonly string[]): void {
 		if (initialInput && initialInput.length > 0) {
 			this.handleInput(initialInput);
 		}
-		while (!this.#pasteDecisionPending) {
-			const nextInput = this.#pendingPasteInput.shift();
-			if (nextInput === undefined) break;
-			this.handleInput(nextInput);
+		for (const input of queuedInput) {
+			this.handleInput(input);
 		}
 	}
 
 	#handleBracketedPaste(pasteContent: string, remaining: string): void {
-		const applyPasteResult = (token: number, handled: boolean | undefined) => {
+		const remainingBytes = Buffer.byteLength(remaining);
+		if (remainingBytes > PENDING_PASTE_INPUT_MAX_BYTES) {
+			super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
+			if (remaining.length > 0) this.handleInput(remaining);
+			this.onPastePendingInputCleared?.("queue-limit", 1);
+			return;
+		}
+		const token = this.#pasteDecisionToken + 1;
+		const controller = new AbortController();
+		this.#pasteDecisionToken = token;
+		this.#pasteDecisionPending = true;
+		this.#pendingPasteDecision = { controller, pasteContent, remaining };
+		this.#pendingPasteInputBytes = remainingBytes;
+		let commitUsed = false;
+
+		const applyPasteResult = (handled: boolean | undefined) => {
 			if (token !== this.#pasteDecisionToken) return;
-			this.#clearPasteDecisionTimeout();
+			const queuedInput = this.#resetPendingPasteState();
 			if (!handled) {
 				super.handleInput(`\x1b[200~${pasteContent}\x1b[201~`);
 			}
-			this.#pasteDecisionPending = false;
-			this.#drainPendingPasteInput(remaining);
+			this.#drainPendingPasteInput(remaining, queuedInput);
 		};
-		const pasteResult = this.onPasteText?.(pasteContent);
+
+		let pasteResult: boolean | Promise<boolean> | undefined;
+		try {
+			pasteResult = this.onPasteText?.(pasteContent, {
+				signal: controller.signal,
+				commit: commit => {
+					if (
+						commitUsed ||
+						token !== this.#pasteDecisionToken ||
+						!this.#pasteDecisionPending ||
+						controller.signal.aborted
+					) {
+						return false;
+					}
+					commitUsed = true;
+					return commit();
+				},
+			});
+		} catch {
+			applyPasteResult(false);
+			return;
+		}
 
 		if (pasteResult instanceof Promise) {
-			const token = this.#pasteDecisionToken + 1;
-			this.#pasteDecisionToken = token;
-			this.#pasteDecisionPending = true;
 			this.#startPasteDecisionTimeout(token);
-			void pasteResult.then(
-				handled => applyPasteResult(token, handled),
-				() => applyPasteResult(token, false),
-			);
+			void pasteResult.then(applyPasteResult, () => applyPasteResult(false));
 		} else {
-			applyPasteResult(this.#pasteDecisionToken, pasteResult);
+			applyPasteResult(pasteResult);
 		}
 	}
 
 	handleInput(data: string): void {
 		if (this.#pasteDecisionPending) {
-			this.#pendingPasteInput.push(data);
-			if (this.#pendingPasteInput.length > PENDING_PASTE_INPUT_MAX) {
-				const droppedInputCount = this.#clearPendingPasteState();
-				this.onPastePendingInputCleared?.("queue-limit", droppedInputCount);
+			const inputBytes = Buffer.byteLength(data);
+			if (
+				this.#pendingPasteEventCount() >= PENDING_PASTE_INPUT_MAX ||
+				this.#pendingPasteInputBytes + inputBytes > PENDING_PASTE_INPUT_MAX_BYTES
+			) {
+				this.#restoreCancelledPaste("queue-limit", data);
+				return;
 			}
+			this.#pendingPasteInput.push(data);
+			this.#pendingPasteInputBytes += inputBytes;
 			return;
 		}
 
@@ -245,8 +312,12 @@ export class CustomEditor extends Editor {
 		}
 
 		if (this.onPasteText) {
-			const paste = this.#pasteHandler.process(data);
+			const paste =
+				data === "\x1b" && !this.#pasteHandler.hasPendingFrame
+					? ({ handled: false } as const)
+					: this.#pasteHandler.process(data);
 			if (paste.handled) {
+				if (paste.leading.length > 0) this.handleInput(paste.leading);
 				if (paste.pasteContent !== undefined) {
 					this.onViewportFollowLive?.();
 					this.#handleBracketedPaste(paste.pasteContent, paste.remaining);

package/src/modes/components/custom-provider-wizard.ts

@@ -41,6 +41,7 @@ export class CustomProviderWizardComponent extends Container {
 		credential: "",
 		models: "",
 	};
+	#submitInFlight = false;
 	#onSubmit: (input: CustomProviderWizardSubmit) => void;
 	#onCancel: () => void;
 	#onRender: () => void;
@@ -294,7 +295,7 @@ export class CustomProviderWizardComponent extends Container {
 			this.#step = "credential";
 		} else if (this.#step === "confirm" || this.#step === "force-confirm") {
 			if (this.#selectedIndex === 0) {
-				this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+				this.#submit();
 				return;
 			}
 			this.#step = "models";
@@ -303,6 +304,30 @@ export class CustomProviderWizardComponent extends Container {
 		this.#onRender();
 	}
 
+	#submit(): void {
+		if (this.#submitInFlight) return;
+		this.#submitInFlight = true;
+		let submission: unknown;
+		try {
+			submission = this.#onSubmit(this.#buildInput(this.#step === "force-confirm"));
+		} catch (error) {
+			this.#submitInFlight = false;
+			throw error;
+		}
+		if (!(submission instanceof Promise)) {
+			this.#submitInFlight = false;
+			return;
+		}
+		void submission.then(
+			() => {
+				this.#submitInFlight = false;
+			},
+			() => {
+				this.#submitInFlight = false;
+			},
+		);
+	}
+
 	#buildInput(force: boolean): CustomProviderWizardSubmit {
 		const input = {
 			compatibility: this.#state.compatibility,

package/src/modes/components/notifications-settings-editor.ts

@@ -30,6 +30,8 @@ export interface NotificationsEditorPreferences {
 	sessionScope: "all" | "primary";
 	richEnabled: boolean;
 	richDraftEnabled: boolean;
+	toolActivityEnabled: boolean;
+	streamingEnabled: boolean;
 }
 
 /** Secret-safe snapshot used to render the Notifications tab. */
@@ -50,6 +52,7 @@ export interface NotificationsEditorSetupInput {
 	chatId?: string;
 	richEnabled: boolean;
 	richDraftEnabled: boolean;
+	streamingEnabled: boolean;
 }
 
 /**
@@ -62,6 +65,7 @@ export interface PreparedTelegramConfiguration {
 	tokenFingerprint?: string;
 	richEnabled: boolean;
 	richDraftEnabled: boolean;
+	streamingEnabled: boolean;
 }
 
 export interface NotificationsPreflightResult {
@@ -155,7 +159,8 @@ type HomeActionId =
 	| "recover"
 	| "reconnect"
 	| "remove"
-	| "preferences";
+	| "preferences"
+	| "tool-activity";
 
 interface Action {
 	id: HomeActionId | "telegram" | "external" | "save" | "save-inactive" | "cancel" | "confirm";
@@ -190,6 +195,8 @@ function emptyState(): NotificationsEditorState {
 			sessionScope: "all",
 			richEnabled: true,
 			richDraftEnabled: false,
+			toolActivityEnabled: true,
+			streamingEnabled: true,
 		},
 	};
 }
@@ -549,6 +556,7 @@ export class NotificationsSettingsEditorComponent implements Component, Focusabl
 						chatId,
 						richEnabled: preferences.richEnabled,
 						richDraftEnabled: preferences.richDraftEnabled,
+						streamingEnabled: preferences.streamingEnabled,
 					},
 					signal,
 				),
@@ -928,6 +936,12 @@ export class NotificationsSettingsEditorComponent implements Component, Focusabl
 			case "refresh":
 				draft.richDraftEnabled = !draft.richDraftEnabled;
 				return;
+			case "tool-activity":
+				draft.toolActivityEnabled = !draft.toolActivityEnabled;
+				return;
+			case "test":
+				draft.streamingEnabled = !draft.streamingEnabled;
+				return;
 			default:
 				return;
 		}
@@ -1068,6 +1082,16 @@ export class NotificationsSettingsEditorComponent implements Component, Focusabl
 				label: `Telegram rich drafts: ${draft.richDraftEnabled ? "on" : "off"}`,
 				description: "Toggle the unsaved rich-draft preference.",
 			},
+			{
+				id: "tool-activity",
+				label: `Telegram tool activity: ${draft.toolActivityEnabled ? "on" : "off"}`,
+				description: "Toggle tool start and completion notifications.",
+			},
+			{
+				id: "test",
+				label: `Telegram streaming: ${draft.streamingEnabled ? "on" : "off"}`,
+				description: "Toggle the unsaved Telegram streaming preference.",
+			},
 			{ id: "save", label: "Save preferences", description: "Atomically persist this preference draft." },
 			{ id: "cancel", label: "Cancel and discard draft", description: "Leave saved preferences unchanged." },
 		];
@@ -1162,7 +1186,7 @@ export class NotificationsSettingsEditorComponent implements Component, Focusabl
 		);
 		lines.push(
 			this.#truncate(
-				`  Private chat: ${draft?.chatId ?? "(expired)"}  rich: ${draft?.richEnabled ? "on" : "off"}  drafts: ${draft?.richDraftEnabled ? "on" : "off"}`,
+				`  Private chat: ${draft?.chatId ?? "(expired)"}  rich: ${draft?.richEnabled ? "on" : "off"}  drafts: ${draft?.richDraftEnabled ? "on" : "off"}  streaming: ${draft?.streamingEnabled ? "on" : "off"}`,
 				width,
 			),
 		);