@gajae-code/coding-agent 0.11.4 → 0.11.6

package/src/modes/components/tool-transcript-format.ts

@@ -1,5 +1,326 @@
+import { wrapTextWithAnsi } from "@gajae-code/tui";
+import { sanitizeText } from "@gajae-code/utils";
+import { renderJsonTreeLines } from "../../tools/json-tree";
+import { renderStatusLine } from "../../tui";
+import type { Theme } from "../theme/theme";
+import { validateDisplayLine } from "./ansi-display-validator";
+import { renderDiff } from "./diff";
+
 export const MAX_TOOL_ARGS_CHARS = 500;
 export const TOOL_RESULT_MAX_EXPANDED_LINES = 100;
+export const INPUT_MAX_SOURCE_BYTES = 1_048_576;
+export const INPUT_MAX_SOURCE_LINES = 50_000;
+export const INPUT_MAX_SCALAR_LEN = 8_192;
+export const INPUT_MAX_JSON_DEPTH = 32;
+export const INPUT_MAX_JSON_NODES = 20_000;
+
+export type ToolDisplaySections = {
+	callLines: string[];
+	statusLines: string[];
+	resultText: string;
+};
+
+/**
+ * Produces final, terminal-safe rich display lines for an expanded tool entry.
+ * It owns validation, width-aware wrapping, and the result-only visible cap.
+ */
+export function renderToolDisplayLines(
+	descriptor: ToolTranscriptRenderDescriptor,
+	contentWidth: number,
+	theme: Theme,
+): string[] {
+	const bounded =
+		descriptor.inputTruncated || exceedsInputBudget(descriptor) ? truncatedDescriptor(descriptor) : descriptor;
+	const sections = bounded.inputTruncated ? truncatedPlainSections(bounded) : richSections(bounded, theme);
+	const wrap = (lines: string[]) =>
+		balanceWrappedSgr(lines.flatMap(line => wrapTextWithAnsi(validateDisplayLine(line), Math.max(1, contentWidth))));
+	const result = cappedResultLines(sections.resultText);
+	const resultLines = wrap(result.lines);
+	const shown = resultLines.slice(0, TOOL_RESULT_MAX_EXPANDED_LINES);
+	if (result.omittedLineCount > 0) shown.push(`... ${result.omittedLineCount} more lines`);
+	else if (resultLines.length > TOOL_RESULT_MAX_EXPANDED_LINES)
+		shown.push(`... ${resultLines.length - TOOL_RESULT_MAX_EXPANDED_LINES} more lines`);
+	return [...wrap(sections.callLines), ...wrap(sections.statusLines), ...shown];
+}
+
+function truncatedPlainSections(descriptor: ToolTranscriptRenderDescriptor): ToolDisplaySections {
+	return {
+		callLines: [descriptor.name, ...composeToolCall(descriptor).split("\n").filter(Boolean)],
+		statusLines: [!descriptor.hasResult ? "⏳ pending" : descriptor.isError ? "✗ Error" : "✓ done"],
+		resultText: `... input truncated for rendering (press r for raw)\n${boundedPlainResult(descriptor.resultContent)}`,
+	};
+}
+
+function truncatedDescriptor(descriptor: ToolTranscriptRenderDescriptor): ToolTranscriptRenderDescriptor {
+	return {
+		...descriptor,
+		name: descriptor.name.slice(0, 256),
+		args: exceedsStructuredInputBudget(descriptor.args) ? {} : descriptor.args,
+		intent: exceedsScalarInputBudget(descriptor.intent) ? undefined : descriptor.intent,
+		resultContent: boundedPlainResult(descriptor.resultContent),
+		details: undefined,
+		detailsData: undefined,
+		inputTruncated: true,
+	};
+}
+
+function balanceWrappedSgr(lines: string[]): string[] {
+	let active: string[] = [];
+	return lines.map(line => {
+		const prefix = active.join("");
+		const matches = [...line.matchAll(/\x1b\[([0-9;]*)m/g)];
+		for (const match of matches) {
+			if (
+				match[1]!
+					.split(";")
+					.some(parameter => ["0", "22", "23", "24", "25", "27", "28", "29", "39", "49"].includes(parameter))
+			)
+				active = [];
+			else active = [match[0]];
+		}
+		const last = matches.at(-1);
+		return `${prefix}${line}${prefix || (last && !last[1]!.split(";").includes("0")) ? "\x1b[0m" : ""}`;
+	});
+}
+
+function plainSections(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): ToolDisplaySections {
+	return {
+		callLines: [theme.fg("accent", descriptor.name), ...composeToolCall(descriptor).split("\n").filter(Boolean)],
+		statusLines: [statusLine(descriptor, theme)],
+		resultText: boundedPlainResult(descriptor.resultContent),
+	};
+}
+
+function richSections(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): ToolDisplaySections {
+	const sections = plainSections(descriptor, theme);
+	const diff = extractDiff(descriptor.detailsData) ?? descriptor.details;
+	if ((descriptor.name === "edit" || descriptor.name === "write" || descriptor.name === "apply_patch") && diff) {
+		sections.resultText = renderDiff(diff, { filePath: extractPath(descriptor.detailsData) });
+	} else if (descriptor.detailsData && typeof descriptor.detailsData === "object") {
+		sections.resultText = renderJsonTreeLines(
+			descriptor.detailsData,
+			theme,
+			INPUT_MAX_JSON_DEPTH,
+			TOOL_RESULT_MAX_EXPANDED_LINES * 2,
+			INPUT_MAX_SCALAR_LEN,
+		).lines.join("\n");
+	}
+	return sections;
+}
+
+function statusLine(descriptor: ToolTranscriptRenderDescriptor, theme: Theme): string {
+	const status = !descriptor.hasResult
+		? "⏳ pending"
+		: descriptor.isError
+			? `✗ ${descriptor.resultContent.split("\n", 1)[0]?.trim() || "Error"}`
+			: "✓ done";
+	return renderStatusLine(
+		{ title: status, titleColor: descriptor.isError ? "error" : descriptor.hasResult ? "success" : "warning" },
+		theme,
+	);
+}
+
+function boundedPlainResult(text: string): string {
+	const boundedBytes =
+		Buffer.byteLength(text) > INPUT_MAX_SOURCE_BYTES
+			? Buffer.from(text).subarray(0, INPUT_MAX_SOURCE_BYTES).toString()
+			: text;
+	let end = boundedBytes.length;
+	let lineCount = 1;
+	for (let index = 0; index < boundedBytes.length; index++) {
+		if (boundedBytes[index] !== "\n") continue;
+		if (lineCount === INPUT_MAX_SOURCE_LINES) {
+			end = index;
+			break;
+		}
+		lineCount += 1;
+	}
+	return boundedBytes.slice(0, end);
+}
+
+function cappedResultLines(result: string): { lines: string[]; omittedLineCount: number } {
+	let lineCount = 1;
+	let prefixEnd = result.length;
+	for (let index = 0; index < result.length; index++) {
+		if (result[index] !== "\n") continue;
+		if (lineCount === TOOL_RESULT_MAX_EXPANDED_LINES) prefixEnd = index;
+		lineCount += 1;
+	}
+	return {
+		lines: result.slice(0, prefixEnd).split("\n"),
+		omittedLineCount: Math.max(0, lineCount - TOOL_RESULT_MAX_EXPANDED_LINES),
+	};
+}
+
+function extractDiff(value: unknown): string | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const record = value as Record<string, unknown>;
+	if (typeof record.diff === "string") return record.diff;
+	if (Array.isArray(record.perFileResults))
+		return record.perFileResults
+			.map(item =>
+				item && typeof item === "object" && typeof (item as Record<string, unknown>).diff === "string"
+					? (item as Record<string, unknown>).diff
+					: "",
+			)
+			.filter(Boolean)
+			.join("\n");
+	return undefined;
+}
+
+function extractPath(value: unknown): string | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const record = value as Record<string, unknown>;
+	return typeof record.path === "string" ? record.path : undefined;
+}
+
+/**
+ * Field-specific input budgets:
+ * - resultContent is bounded by total bytes and lines.
+ * - args and detailsData are bounded by cumulative bytes, per-scalar length, depth, and nodes.
+ * - intent and details are bounded by per-scalar length.
+ */
+function exceedsInputBudget(descriptor: ToolTranscriptRenderDescriptor): boolean {
+	return (
+		exceedsResultContentBudget(descriptor.resultContent) ||
+		exceedsStructuredInputBudget(descriptor.args) ||
+		exceedsScalarInputBudget(descriptor.intent) ||
+		exceedsScalarInputBudget(descriptor.details) ||
+		exceedsStructuredInputBudget(descriptor.detailsData)
+	);
+}
+
+function exceedsResultContentBudget(value: string): boolean {
+	return Buffer.byteLength(value) > INPUT_MAX_SOURCE_BYTES || value.split("\n").length - 1 > INPUT_MAX_SOURCE_LINES;
+}
+
+function exceedsScalarInputBudget(value: unknown): boolean {
+	return typeof value === "string" && value.length > INPUT_MAX_SCALAR_LEN;
+}
+
+function exceedsStructuredInputBudget(value: unknown): boolean {
+	let nodes = 0;
+	let bytes = 0;
+	let exceeded = false;
+	const visit = (item: unknown, depth: number): void => {
+		if (exceeded) return;
+		nodes++;
+		if (nodes > INPUT_MAX_JSON_NODES || depth > INPUT_MAX_JSON_DEPTH) {
+			exceeded = true;
+			return;
+		}
+		if (typeof item === "string") {
+			bytes += Buffer.byteLength(item);
+			if (item.length > INPUT_MAX_SCALAR_LEN || bytes > INPUT_MAX_SOURCE_BYTES) exceeded = true;
+			return;
+		}
+		if (Array.isArray(item)) for (const child of item) visit(child, depth + 1);
+		else if (item && typeof item === "object") for (const child of Object.values(item)) visit(child, depth + 1);
+	};
+	visit(value, 0);
+	return exceeded;
+}
+
+export type ToolTranscriptRenderDescriptor = Readonly<{
+	name: string;
+	args: Record<string, unknown>;
+	intent?: string;
+	resultContent: string;
+	details?: string;
+	detailsData?: unknown;
+	isError: boolean;
+	isPartial: boolean;
+	hasResult: boolean;
+	inputTruncated: boolean;
+}>;
+
+export type BuildToolTranscriptEntryInput = {
+	canonicalPayload: import("../transcript-item-registry").TranscriptSourcePayload;
+	renderDescriptor: ToolTranscriptRenderDescriptor;
+	capabilities: import("../transcript-item-registry").TranscriptItemCapabilities;
+	identity: { id: string; label: string; display?: "full" };
+};
+
+/**
+ * Shared tool projection for the main transcript and session observer.
+ * `payload` is canonical/copyable source; display is derived only from the
+ * sanitized, frozen descriptor. The observer's whole-entry 100-line cap and
+ * the main view's tool-only result cap intentionally remain surface-specific.
+ */
+export function buildToolTranscriptEntry(
+	input: BuildToolTranscriptEntryInput,
+): import("./transcript-viewer-overlay").TranscriptViewerEntry {
+	const { canonicalPayload: payload, renderDescriptor, capabilities, identity } = input;
+	const fields: ToolTranscriptFields = {
+		name: renderDescriptor.name,
+		args: renderDescriptor.args,
+		intent: renderDescriptor.intent,
+		resultText: renderDescriptor.resultContent,
+		isError: renderDescriptor.isError,
+		hasResult: renderDescriptor.hasResult,
+	};
+	return {
+		id: identity.id,
+		kind: "tool",
+		label: identity.label,
+		payload,
+		renderDescriptor,
+		...capabilities,
+		richRenderEligible: identity.display !== "full",
+		getDisplayText: expanded =>
+			identity.display === "full" ? composeToolText(fields) : toolDisplayText(fields, expanded),
+	};
+}
+
+/** Sanitizes and freezes all display-only values before tool formatting. */
+export function createToolTranscriptRenderDescriptor(input: {
+	name: unknown;
+	args: unknown;
+	intent?: unknown;
+	resultContent: unknown;
+	details?: unknown;
+	detailsData?: unknown;
+	isError?: unknown;
+	isPartial?: unknown;
+	hasResult?: unknown;
+	inputTruncated?: unknown;
+}): ToolTranscriptRenderDescriptor {
+	const argsTruncated = exceedsStructuredInputBudget(input.args);
+	const detailsDataTruncated = exceedsStructuredInputBudget(input.detailsData);
+	return freezeDisplayValue({
+		name: sanitizeString(input.name),
+		args: argsTruncated ? {} : ((sanitizeDisplayValue(input.args) ?? {}) as Record<string, unknown>),
+		intent: typeof input.intent === "string" ? sanitizeString(input.intent) : undefined,
+		resultContent: sanitizeString(input.resultContent),
+		details: typeof input.details === "string" ? sanitizeString(input.details) : undefined,
+		detailsData: detailsDataTruncated ? undefined : sanitizeDisplayValue(input.detailsData),
+		isError: Boolean(input.isError),
+		isPartial: Boolean(input.isPartial),
+		hasResult: Boolean(input.hasResult),
+		inputTruncated: Boolean(input.inputTruncated) || argsTruncated || detailsDataTruncated,
+	});
+}
+
+function sanitizeString(value: unknown): string {
+	return typeof value === "string" ? sanitizeText(value) : "";
+}
+
+function sanitizeDisplayValue(value: unknown): unknown {
+	if (typeof value === "string") return sanitizeText(value);
+	if (Array.isArray(value)) return value.map(sanitizeDisplayValue);
+	if (!value || typeof value !== "object") return value;
+	return Object.fromEntries(
+		Object.entries(value).map(([key, item]) => [sanitizeText(key), sanitizeDisplayValue(item)]),
+	);
+}
+
+function freezeDisplayValue<T>(value: T): T {
+	if (value && typeof value === "object") {
+		for (const item of Object.values(value)) freezeDisplayValue(item);
+		Object.freeze(value);
+	}
+	return value;
+}
 
 type ToolCallFields = {
 	name: string;

package/src/modes/components/transcript-viewer-overlay.ts

@@ -11,7 +11,12 @@ import { sanitizeText } from "@gajae-code/utils";
 import { getMarkdownTheme, theme } from "../theme/theme";
 import type { TranscriptItemRegistry, TranscriptSourcePayload } from "../transcript-item-registry";
 import { DynamicBorder } from "./dynamic-border";
-import { toolDisplayText } from "./tool-transcript-format";
+import {
+	buildToolTranscriptEntry,
+	createToolTranscriptRenderDescriptor,
+	renderToolDisplayLines,
+	type ToolTranscriptRenderDescriptor,
+} from "./tool-transcript-format";
 
 const INDENT = "    ";
 const PAGE_SIZE = 15;
@@ -26,6 +31,8 @@ export type TranscriptViewerEntry = {
 	foldable?: boolean;
 	rawViewable?: boolean;
 	getDisplayText?: (expanded: boolean) => string;
+	renderDescriptor?: ToolTranscriptRenderDescriptor;
+	richRenderEligible?: boolean;
 };
 
 export type TranscriptViewerOverlayOptions = {
@@ -333,6 +340,19 @@ export class TranscriptViewerOverlay extends Container {
 			lines.push(
 				`${selected ? theme.fg("accent", "▶") : " "} ${theme.fg("muted", `[${sanitizeText(entry.label ?? entry.kind)}]`)}`,
 			);
+			if (
+				!raw &&
+				expanded &&
+				selected &&
+				entry.kind === "tool" &&
+				entry.richRenderEligible === true &&
+				entry.renderDescriptor
+			) {
+				for (const line of renderToolDisplayLines(entry.renderDescriptor, contentWidth, theme))
+					lines.push(`${INDENT}${line}`);
+				this.#renderedEntries.push({ lineStart: start, lineCount: lines.length - start });
+				continue;
+			}
 			const text = sanitizeText(
 				(raw
 					? entry.payload.text
@@ -404,21 +424,23 @@ export function transcriptViewerEntries(registry: TranscriptItemRegistry): Trans
 							? "User"
 							: item.kind;
 		const toolMetadata = hasToolTranscriptMetadata(payload.metadata) ? payload.metadata : undefined;
-		const getDisplayText =
-			item.kind === "tool" && toolMetadata
-				? (expanded: boolean) =>
-						toolDisplayText(
-							{
-								name: toolMetadata.name,
-								args: toolMetadata.arguments,
-								intent: typeof toolMetadata.intent === "string" ? toolMetadata.intent : undefined,
-								resultText: toolMetadata.resultText,
-								isError: toolMetadata.isError,
-								hasResult: toolMetadata.hasResult,
-							},
-							expanded,
-						)
-				: undefined;
-		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities, getDisplayText }];
+		if (item.kind === "tool" && toolMetadata)
+			return [
+				buildToolTranscriptEntry({
+					canonicalPayload: payload,
+					renderDescriptor: createToolTranscriptRenderDescriptor({
+						name: toolMetadata.name,
+						args: toolMetadata.arguments,
+						intent: toolMetadata.intent,
+						resultContent: toolMetadata.resultText,
+						detailsData: payload.metadata.detailsData,
+						isError: toolMetadata.isError,
+						hasResult: toolMetadata.hasResult,
+					}),
+					capabilities: capabilities ?? { copyable: true, foldable: true, rawViewable: true },
+					identity: { id: item.id, label },
+				}),
+			];
+		return [{ id: item.id, kind: item.kind, label, payload, ...capabilities }];
 	});
 }

package/src/modes/controllers/command-controller.ts

@@ -1260,6 +1260,10 @@ export class CommandController {
 	}
 
 	async handleHandoffCommand(customInstructions?: string): Promise<void> {
+		if (this.ctx.session.isStreaming) {
+			this.ctx.showWarning("Wait for the current response to finish or abort it before handing off.");
+			return;
+		}
 		const entries = this.ctx.sessionManager.getEntries();
 		const messageCount = entries.filter(e => e.type === "message").length;
 
@@ -1321,6 +1325,17 @@ export class CommandController {
 			} else {
 				this.ctx.showError(`Handoff failed: ${message}`);
 			}
+			// The failure is non-destructive: the current session is unchanged. If the
+			// document was already generated, preserve it on the clipboard for retry.
+			const retainedDocument =
+				error &&
+				typeof error === "object" &&
+				typeof (error as { handoffDocument?: unknown }).handoffDocument === "string"
+					? (error as { handoffDocument: string }).handoffDocument
+					: undefined;
+			if (retainedDocument) {
+				this.#doCopy(retainedDocument, "Handoff document preserved on clipboard; current session is unchanged.");
+			}
 		} finally {
 			handoffLoader.stop();
 			this.ctx.statusContainer.clear();

package/src/modes/controllers/extension-ui-controller.ts

@@ -214,13 +214,25 @@ export class ExtensionUiController {
 				try {
 					return {
 						handoff: await session.handoff(
-							typeof input.instructions === "string" ? input.instructions : undefined,
+							typeof input.target === "string"
+								? input.target
+								: typeof input.instructions === "string"
+									? input.instructions
+									: undefined,
 						),
 					};
 				} catch (error) {
+					const typed = error as { code?: unknown; handoffDocument?: unknown };
+					const handoffDocument =
+						typeof typed?.handoffDocument === "string" ? { handoffDocument: typed.handoffDocument } : undefined;
+					// Preserve a safe typed code (e.g. transient `busy`) so clients keep
+					// correct retry/backoff semantics; only synthesize invalid_request for
+					// otherwise-untyped failures.
+					const code = typed?.code === "busy" ? "busy" : "invalid_request";
 					throw Object.assign(
 						new Error(error instanceof Error ? error.message : "Handoff is unavailable for the current state."),
-						{ code: "invalid_request" },
+						{ code },
+						handoffDocument,
 					);
 				}
 			case "session.export_html":

package/src/modes/controllers/goal-mode-controller.ts

@@ -227,19 +227,37 @@ export class GoalModeController {
 		this.scheduleContinuation();
 	}
 
-	async restoreFromSession(sessionContext: SessionContext): Promise<boolean> {
+	/**
+	 * Restore durable goal state. Recovery hydration deliberately performs only
+	 * in-memory restoration: it neither consumes a pending request nor repairs
+	 * invalid persisted state by writing a fallback mode entry.
+	 */
+	async restoreFromSession(
+		sessionContext: SessionContext,
+		options?: { recoveryHydration?: boolean },
+	): Promise<boolean> {
+		const recoveryHydration = options?.recoveryHydration === true;
 		const goalEnabled = this.ctx.session.settings.get("goal.enabled");
 		if (!goalEnabled && (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused")) {
+			if (recoveryHydration) return false;
 			this.ctx.sessionManager.appendModeChange("none");
 			return true;
 		}
 		if (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused") {
 			const goal = normalizeGoal(sessionContext.modeData?.goal) ?? undefined;
 			if (!goal) {
+				if (recoveryHydration) throw new Error("Recovery hydration rejected an invalid persisted goal state.");
 				this.ctx.sessionManager.appendModeChange("none");
 				return true;
 			}
 			this.ctx.session.setGoalModeState({ enabled: sessionContext.mode === "goal", mode: "active", goal });
+			if (recoveryHydration) {
+				this.#enabled = sessionContext.mode === "goal";
+				this.#paused = sessionContext.mode === "goal_paused";
+				if (this.#enabled || this.#paused) this.ctx.modeGate.enter("goal");
+				this.#updateStatus();
+				return true;
+			}
 			const restored = await this.ctx.session.goalRuntime.onThreadResumed();
 			this.#enabled = restored?.enabled === true;
 			this.#paused = restored?.enabled !== true && restored?.goal.status === "paused";
@@ -251,6 +269,7 @@ export class GoalModeController {
 			this.#updateStatus();
 			return true;
 		}
+		if (recoveryHydration) return false;
 		const pendingGoal = goalEnabled
 			? await consumePendingGoalModeRequest(this.ctx.sessionManager.getCwd(), this.ctx.sessionManager.getSessionId())
 			: null;

package/src/modes/controllers/plan-mode-controller.ts

@@ -334,6 +334,7 @@ export class PlanModeController {
 		return planFilePath.startsWith("local:")
 			? resolveLocalUrlToPath(normalizeLocalScheme(planFilePath), {
 					getArtifactsDir: () => this.ctx.sessionManager.getArtifactsDir(),
+					isManagedDestination: () => this.ctx.sessionManager.isManagedDestination(),
 					getSessionId: () => this.ctx.sessionManager.getSessionId(),
 				})
 			: path.resolve(this.ctx.sessionManager.getCwd(), planFilePath);
@@ -448,6 +449,7 @@ export class PlanModeController {
 					await Bun.write(
 						resolveLocalUrlToPath(options.finalPlanFilePath, {
 							getArtifactsDir: () => this.ctx.sessionManager.getArtifactsDir(),
+							isManagedDestination: () => this.ctx.sessionManager.isManagedDestination(),
 							getSessionId: () => this.ctx.sessionManager.getSessionId(),
 						}),
 						planContent,

package/src/modes/controllers/runtime-mcp-command-controller.ts

@@ -1450,6 +1450,9 @@ export class MCPCommandController {
 		if (!this.ctx.mcpManager) {
 			return;
 		}
+		if (this.ctx.mcpManager.isConnectionSetSealed()) {
+			throw new Error("This session's plugin-bundle MCP connections are fixed for its lifetime.");
+		}
 
 		// Disconnect all existing servers
 		await this.ctx.mcpManager.disconnectAll();

package/src/modes/controllers/selector-controller.ts

@@ -43,7 +43,7 @@ import {
 	theme,
 } from "../../modes/theme/theme";
 import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/types";
-import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
+import { getNotificationConfig, isTelegramConfigured, maskToken } from "../../sdk/bus/config";
 import {
 	clearTelegramActivationMarker,
 	createTelegramActivationMarker,
@@ -228,6 +228,13 @@ export interface NotificationsEditorOperationDependencies {
 	saveTelegramInactive: typeof saveTelegramInactive;
 	removeTelegramConfiguration: typeof removeTelegramConfiguration;
 	unregisterNotificationRoot: typeof unregisterNotificationRoot;
+	reloadTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
+	restartTelegramDaemon(settings: Settings): Promise<{ ok: boolean; message: string }>;
+	stopTelegramDaemon(settings: Settings): Promise<{
+		ok: boolean;
+		message: string;
+		before?: { health?: string };
+	}>;
 }
 
 const notificationEditorOperationDependencies: NotificationsEditorOperationDependencies = {
@@ -245,6 +252,11 @@ const notificationEditorOperationDependencies: NotificationsEditorOperationDepen
 	saveTelegramInactive,
 	removeTelegramConfiguration,
 	unregisterNotificationRoot,
+	reloadTelegramDaemon: async settings =>
+		await new TelegramDaemonController(settings).reload({ spawnIfStopped: false }),
+	restartTelegramDaemon: async settings =>
+		await new TelegramDaemonController(settings).reload({ spawnIfStopped: true }),
+	stopTelegramDaemon: async settings => await new TelegramDaemonController(settings).stop(),
 };
 
 function unavailableNotificationSessionStatus(): NotificationSessionStatus {
@@ -333,6 +345,8 @@ export function createNotificationsEditorOperations(
 					sessionScope: config.sessionScope,
 					richEnabled: config.rich.enabled,
 					richDraftEnabled: config.richDraft.enabled,
+					toolActivityEnabled: config.toolActivity.enabled,
+					streamingEnabled: config.streaming.enabled,
 				},
 			};
 		},
@@ -470,6 +484,7 @@ export function createNotificationsEditorOperations(
 					tokenFingerprint: setup.tokenFingerprint,
 					richEnabled: input.richEnabled,
 					richDraftEnabled: input.richDraftEnabled,
+					streamingEnabled: input.streamingEnabled,
 				};
 				drafts.set(draft, token);
 				const pairingMessage =
@@ -513,6 +528,7 @@ export function createNotificationsEditorOperations(
 					{ path: "notifications.telegram.chatId", op: "set", value: draft.chatId },
 					{ path: "notifications.telegram.rich.enabled", op: "set", value: draft.richEnabled },
 					{ path: "notifications.telegram.richDraft.enabled", op: "set", value: draft.richDraftEnabled },
+					{ path: "notifications.telegram.streaming.enabled", op: "set", value: draft.streamingEnabled },
 				]);
 				drafts.delete(draft);
 				const activationMarker = createTelegramActivationMarker({
@@ -676,14 +692,60 @@ export function createNotificationsEditorOperations(
 		},
 
 		commitPreferences: async preferences => {
+			let daemonWasRunningForDisable = false;
 			try {
-				const receipt = await ctx.settings.commitAtomicBatch([
-					{ path: "notifications.redact", op: "set", value: preferences.redact },
-					{ path: "notifications.verbosity", op: "set", value: preferences.verbosity },
-					{ path: "notifications.sessionScope", op: "set", value: preferences.sessionScope },
-					{ path: "notifications.telegram.rich.enabled", op: "set", value: preferences.richEnabled },
-					{ path: "notifications.telegram.richDraft.enabled", op: "set", value: preferences.richDraftEnabled },
-				]);
+				const before = services.getNotificationConfig(ctx.settings);
+				const disablingToolActivity =
+					isTelegramConfigured(before) && before.toolActivity.enabled && !preferences.toolActivityEnabled;
+				if (disablingToolActivity) {
+					const stopped = await services.stopTelegramDaemon(ctx.settings);
+					if (!stopped.ok)
+						throw new Error(
+							`Notification preferences were not saved because daemon stop failed: ${stopped.message}`,
+						);
+					daemonWasRunningForDisable = stopped.before?.health === "running";
+				}
+
+				let receipt: Awaited<ReturnType<typeof ctx.settings.commitAtomicBatch>>;
+				try {
+					receipt = await ctx.settings.commitAtomicBatch([
+						{ path: "notifications.redact", op: "set", value: preferences.redact },
+						{ path: "notifications.verbosity", op: "set", value: preferences.verbosity },
+						{ path: "notifications.sessionScope", op: "set", value: preferences.sessionScope },
+						{ path: "notifications.telegram.rich.enabled", op: "set", value: preferences.richEnabled },
+						{ path: "notifications.telegram.richDraft.enabled", op: "set", value: preferences.richDraftEnabled },
+						{ path: "notifications.telegram.streaming.enabled", op: "set", value: preferences.streamingEnabled },
+						{
+							path: "notifications.telegram.toolActivity.enabled",
+							op: "set",
+							value: preferences.toolActivityEnabled,
+						},
+					]);
+				} catch (error) {
+					if (daemonWasRunningForDisable) {
+						try {
+							const restarted = await services.restartTelegramDaemon(ctx.settings);
+							if (!restarted.ok) throw new Error(restarted.message);
+						} catch (restartError) {
+							const commitMessage = error instanceof Error ? error.message : String(error);
+							const restartMessage = restartError instanceof Error ? restartError.message : String(restartError);
+							throw new Error(
+								`Notification preference commit failed (${commitMessage}) and daemon restart failed (${restartMessage}).`,
+								{ cause: new AggregateError([error, restartError]) },
+							);
+						}
+					}
+					throw error;
+				}
+
+				const config = services.getNotificationConfig(ctx.settings);
+				if (isTelegramConfigured(config)) {
+					const reload = daemonWasRunningForDisable
+						? await services.restartTelegramDaemon(ctx.settings)
+						: await services.reloadTelegramDaemon(ctx.settings);
+					if (!reload.ok)
+						throw new Error(`Notification preferences were saved, but daemon reload failed: ${reload.message}`);
+				}
 				await notifyAfterDurableCommit();
 				return { receipt, message: "Notification preferences saved atomically." };
 			} catch (error) {

package/src/modes/interactive-mode.ts

@@ -1839,6 +1839,7 @@ export class InteractiveMode implements InteractiveModeContext {
 								isError: result?.isError ?? false,
 								resultText,
 								hasResult: toolResults.has(content.id),
+								detailsData: result?.details,
 							},
 							source: { content, result },
 						}),