@gajae-code/coding-agent 0.8.2 → 0.9.0

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

@@ -24,10 +24,20 @@ import type { ResolveToolDetails } from "../../tools/resolve";
 import { interruptHint } from "../shared";
 import { buildAbortDisplayMessage } from "../utils/abort-message";
 import { ringTerminalBell } from "../utils/terminal-bell";
+import { argsWithPartialJson } from "../utils/ui-helpers";
 
 type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
+
+/** Test-only performance counters for advisory baseline tests. */
+export const __eventControllerPerfCounters = {
+	messageUpdateContentVisits: 0,
+	reset(): void {
+		this.messageUpdateContentVisits = 0;
+	},
+};
+
 const COMPLETION_NOTIFY_COMMAND_TIMEOUT_MS = 10_000;
 
 interface CompletionNotifyPayload {
@@ -100,6 +110,8 @@ export class EventController {
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
 	#idleCompactionTimer?: NodeJS.Timeout;
 	#ircExpiryTimers = new Map<string, NodeJS.Timeout>();
+	#toolIntentCache = new Map<string, { args: unknown; intent: string | undefined }>();
+	#thinkingContentIndices = new Set<number>();
 	#handlers: AgentSessionEventHandlers;
 
 	constructor(private ctx: InteractiveModeContext) {
@@ -307,12 +319,14 @@ export class EventController {
 		} else if (event.message.role === "assistant") {
 			this.#lastThinkingCount = 0;
 			this.#resetReadGroup();
+			this.#toolIntentCache.clear();
+			this.#thinkingContentIndices.clear();
 			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
 				this.ctx.ui.requestRender(),
 			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
 			this.ctx.ui.requestRender();
 		}
 	}
@@ -375,46 +389,53 @@ export class EventController {
 	async #handleMessageUpdate(event: Extract<AgentSessionEvent, { type: "message_update" }>): Promise<void> {
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
-
-			const thinkingCount = this.ctx.streamingMessage.content.filter(
-				content => content.type === "thinking" && content.thinking.trim(),
-			).length;
-			if (thinkingCount > this.#lastThinkingCount) {
-				this.#resetReadGroup();
-				this.#lastThinkingCount = thinkingCount;
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
+			const contentIndex = event.assistantMessageEvent?.contentIndex;
+			const changedContent =
+				typeof contentIndex === "number" && contentIndex >= 0
+					? this.ctx.streamingMessage.content[contentIndex]
+					: undefined;
+			const contentsToProcess = changedContent ? [changedContent] : this.ctx.streamingMessage.content;
+
+			if (changedContent?.type === "thinking" && changedContent.thinking.trim()) {
+				if (typeof contentIndex === "number") this.#thinkingContentIndices.add(contentIndex);
+				const thinkingCount = this.#thinkingContentIndices.size;
+				if (thinkingCount > this.#lastThinkingCount) {
+					this.#resetReadGroup();
+					this.#lastThinkingCount = thinkingCount;
+				}
+			} else if (!changedContent) {
+				const thinkingCount = this.ctx.streamingMessage.content.filter(
+					content => content.type === "thinking" && content.thinking.trim(),
+				).length;
+				if (thinkingCount > this.#lastThinkingCount) {
+					this.#resetReadGroup();
+					this.#lastThinkingCount = thinkingCount;
+				}
 			}
 
-			for (const content of this.ctx.streamingMessage.content) {
+			for (const content of contentsToProcess) {
+				__eventControllerPerfCounters.messageUpdateContentVisits += 1;
 				if (content.type !== "toolCall") continue;
 				if (content.name === "read") {
-					if (!readArgsHaveTarget(content.arguments)) {
-						// Args still streaming — defer until path is parseable so we can route to the
-						// read group (regular files) vs ToolExecutionComponent (internal URLs).
-						// Creating either component now would lock the read into the wrong shape.
-						continue;
-					}
+					if (!readArgsHaveTarget(content.arguments)) continue;
 					if (!readArgsTargetInternalUrl(content.arguments)) {
 						this.#trackReadToolCall(content.id, content.arguments);
 						const component = this.ctx.pendingTools.get(content.id);
-						if (component) {
-							component.updateArgs(content.arguments, content.id);
-						} else {
+						if (component) component.updateArgs(content.arguments, content.id);
+						else {
 							const group = this.#getReadGroup();
 							group.updateArgs(content.arguments, content.id);
 							this.ctx.pendingTools.set(content.id, group);
 						}
 						continue;
 					}
-					// Internal URL read falls through to ToolExecutionComponent below.
 				}
 
-				// Preserve the raw partial JSON for renderers that need to surface fields before the JSON object closes.
-				// Bash uses this to show inline env assignments during streaming instead of popping them in at completion.
-				const renderArgs =
-					"partialJson" in content
-						? { ...content.arguments, __partialJson: content.partialJson }
-						: content.arguments;
+				const renderArgs = argsWithPartialJson(
+					content.arguments,
+					"partialJson" in content ? content.partialJson : undefined,
+				);
 				if (!this.ctx.pendingTools.has(content.id)) {
 					this.#resetReadGroup();
 					this.ctx.chatContainer.addChild(new Text("", 0, 0));
@@ -437,32 +458,30 @@ export class EventController {
 					this.ctx.chatContainer.addChild(component);
 					this.ctx.pendingTools.set(content.id, component);
 				} else {
-					const component = this.ctx.pendingTools.get(content.id);
-					if (component) {
-						component.updateArgs(renderArgs, content.id);
-					}
+					this.ctx.pendingTools.get(content.id)?.updateArgs(renderArgs, content.id);
 				}
-			}
 
-			// Update working message with intent from streamed tool arguments
-			for (const content of this.ctx.streamingMessage.content) {
-				if (content.type !== "toolCall") continue;
 				const args = content.arguments;
 				if (!args || typeof args !== "object") continue;
+				let intent: string | undefined;
 				if (INTENT_FIELD in args) {
-					this.#updateWorkingMessageFromIntent(args[INTENT_FIELD]);
-					continue;
-				}
-				const tool = this.ctx.session.getToolByName(content.name);
-				if (typeof tool?.intent !== "function") continue;
-				try {
-					const derived = tool.intent(args as never)?.trim();
-					if (derived) {
-						this.#updateWorkingMessageFromIntent(derived);
+					intent = String(args[INTENT_FIELD]);
+				} else {
+					const cached = this.#toolIntentCache.get(content.id);
+					if (cached?.args === args) intent = cached.intent;
+					else {
+						const tool = this.ctx.session.getToolByName(content.name);
+						if (typeof tool?.intent === "function") {
+							try {
+								intent = tool.intent(args as never)?.trim();
+							} catch {
+								// intent function must never break the UI
+							}
+						}
+						this.#toolIntentCache.set(content.id, { args, intent });
 					}
-				} catch {
-					// intent function must never break the UI
 				}
+				if (intent) this.#updateWorkingMessageFromIntent(intent);
 			}
 
 			this.ctx.ui.requestRender();
@@ -495,9 +514,9 @@ export class EventController {
 				// display only — does NOT mutate the persisted message's stopReason
 				// (the marker on errorMessage drives replay-side suppression).
 				const msgWithoutAbort = { ...this.ctx.streamingMessage, stopReason: "stop" as const };
-				this.ctx.streamingComponent.updateContent(msgWithoutAbort);
+				this.ctx.streamingComponent.updateContent(msgWithoutAbort, { streaming: false });
 			} else {
-				this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+				this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: false });
 			}
 
 			if (this.ctx.streamingMessage.stopReason !== "aborted" && this.ctx.streamingMessage.stopReason !== "error") {

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

@@ -1308,7 +1308,7 @@ export class InputController {
 		// If streaming, re-add the streaming component with updated visibility and re-render
 		if (this.ctx.streamingComponent && this.ctx.streamingMessage) {
 			this.ctx.streamingComponent.setHideThinkingBlock(this.ctx.hideThinkingBlock);
-			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage);
+			this.ctx.streamingComponent.updateContent(this.ctx.streamingMessage, { streaming: true });
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);
 		}
 

package/src/modes/interactive-mode.ts

@@ -118,7 +118,7 @@ import { UiHelpers } from "./utils/ui-helpers";
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
 const COMPOSER_NEWLINE_HINT = process.platform === "win32" ? "Alt+Enter/Ctrl+J" : "Shift+Enter/Ctrl+J";
-const DEFAULT_COMPOSER_PLACEHOLDER = `Type your message... ${COMPOSER_NEWLINE_HINT}: New line · Ctrl+C: Clear · Shift+Tab: Reasoning`;
+export const DEFAULT_COMPOSER_PLACEHOLDER = `Type your message... ${COMPOSER_NEWLINE_HINT}: New line · Ctrl+C: Clear · Ctrl+R: Search history · Shift+Tab: Reasoning`;
 const WELCOME_RESERVED_CONTAINER_CHILD_LIMIT = 8;
 const FRIENDLY_KEY_PARTS: Record<string, string> = {
 	alt: "Alt",
@@ -163,6 +163,7 @@ function configureDefaultComposerChrome(editor: CustomEditor): void {
 	editor.setInputPrefix(getDefaultInputPrefix());
 	editor.setPlaceholder(DEFAULT_COMPOSER_PLACEHOLDER);
 	editor.setPaddingX(1);
+	editor.setRightGutterWidth(1);
 	editor.setTopBorder(undefined);
 }
 
@@ -1715,6 +1716,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			planContent,
 			finalPlanFilePath: options.finalPlanFilePath,
 			contextPreserved: options.preserveContext === true,
+			tools: this.session.getActiveToolNames(),
 		});
 		await this.session.prompt(planModePrompt, { synthetic: true });
 	}
@@ -2206,6 +2208,7 @@ export class InteractiveMode implements InteractiveModeContext {
 				message => renderWorkingMessage(message, this.#getWorkingMessageAccent()),
 				this.#defaultWorkingMessage,
 				getSymbolTheme().spinnerFrames,
+				{ timeDependentColor: true },
 			);
 			this.statusContainer.addChild(this.loadingAnimation);
 		}
@@ -2363,6 +2366,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleClearCommand();
 	}
 
+	handleContextClearCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
+		return this.#commandController.handleContextClearCommand();
+	}
+
 	handleDropCommand(): Promise<void> {
 		this.#prepareSessionSwitch();
 		return this.#commandController.handleDropCommand();

package/src/modes/rpc/rpc-mode.ts

@@ -22,8 +22,13 @@ import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { initializeExtensions } from "../runtime-init";
 import { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
-import { AgentWireFrameSequencer, toAgentWireEventFrame } from "../shared/agent-wire/event-envelope";
-import { rpcError as error } from "../shared/agent-wire/responses";
+import {
+	AgentWireCompactEventEncoder,
+	AgentWireFrameSequencer,
+	toAgentWireCompactEventFrame,
+	toAgentWireEventFrame,
+} from "../shared/agent-wire/event-envelope";
+import { rpcError as error, rpcSuccess } from "../shared/agent-wire/responses";
 import { registerRpcSession, unregisterRpcSession } from "../shared/agent-wire/session-registry";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
 import { modelSupportsTokenCostMetrics, UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
@@ -297,6 +302,7 @@ export async function runRpcMode(
 		output({ type: "ready" });
 	}
 	const emitRpcTitles = shouldEmitRpcTitles();
+	const rpcCapabilities = { compactMessageUpdate: false };
 	const decodeError = (err: unknown): string => (err instanceof Error ? err.message : String(err));
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
@@ -636,8 +642,13 @@ export async function runRpcMode(
 	// Output all agent events as canonical agent-wire `event` frames (docs/rpc.md):
 	// { type:"event", protocol_version, session_id, seq, frame_id, payload:{ event_type, event } }.
 	const eventSequencer = new AgentWireFrameSequencer(session.sessionId);
+	const compactEventEncoder = new AgentWireCompactEventEncoder(eventSequencer);
 	session.subscribe(event => {
-		output(toAgentWireEventFrame(event, eventSequencer));
+		output(
+			rpcCapabilities.compactMessageUpdate
+				? toAgentWireCompactEventFrame(event, compactEventEncoder)
+				: toAgentWireEventFrame(event, eventSequencer),
+		);
 	});
 
 	// Handle a single command through the shared agent-wire dispatcher so RPC
@@ -710,6 +721,21 @@ export async function runRpcMode(
 				hostUriBridge.handleResult(parsed);
 				return;
 			}
+			if ((parsed as RpcCommand).type === "set_capabilities") {
+				// RPC has no startup handshake; clients negotiate optional event-shape capabilities
+				// with this explicit command. Defaults remain legacy/full-frame until accepted here.
+				const command = parsed as Extract<RpcCommand, { type: "set_capabilities" }>;
+				const requested = Array.isArray(command.capabilities) ? command.capabilities : [];
+				const acceptedCapabilities = requested.filter(capability => capability === "compact_message_update");
+				rpcCapabilities.compactMessageUpdate = acceptedCapabilities.includes("compact_message_update");
+				output(
+					rpcSuccess(command.id, "set_capabilities", {
+						acceptedCapabilities,
+						unsupported: requested.filter(capability => capability !== "compact_message_update"),
+					}),
+				);
+				return;
+			}
 			// Ordered commands run through a serial chain to preserve causal order; the
 			// reader never blocks, so cancellation commands stay responsive even while a
 			// long command is in flight (issue 13).

package/src/modes/rpc/rpc-types.ts

@@ -13,6 +13,7 @@ import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
 
 export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
+export type RpcCapability = "compact_message_update";
 
 // ============================================================================
 // RPC Commands (stdin)
@@ -33,6 +34,7 @@ export type RpcCommand =
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
 	| { id?: string; type: "get_pending_workflow_gates" }
+	| { id?: string; type: "set_capabilities"; capabilities: RpcCapability[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -140,6 +142,13 @@ export type RpcResponse =
 			success: true;
 			data: { gates: RpcWorkflowGate[] };
 	  }
+	| {
+			id?: string;
+			type: "response";
+			command: "set_capabilities";
+			success: true;
+			data: { acceptedCapabilities: RpcCapability[]; unsupported: string[] };
+	  }
 
 	// Model
 	| {

package/src/modes/shared/agent-wire/command-validation.ts

@@ -130,6 +130,10 @@ export function isRpcCommand(value: unknown): value is RpcCommand {
 			return Array.isArray(value.tools) && value.tools.every(hostToolDefinition);
 		case "set_host_uri_schemes":
 			return Array.isArray(value.schemes) && value.schemes.every(hostUriScheme);
+		case "set_capabilities":
+			return (
+				Array.isArray(value.capabilities) && value.capabilities.every(capability => typeof capability === "string")
+			);
 		case "set_model":
 			return stringField(value, "provider") && stringField(value, "modelId");
 		case "set_thinking_level":

package/src/modes/shared/agent-wire/event-contract.ts

@@ -13,6 +13,8 @@
  * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
  * conformance tests can assert fixture coverage equals the registry exactly.
  */
+
+import type { AssistantMessageEvent } from "@gajae-code/ai";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
@@ -68,6 +70,25 @@ export interface AgentWireEventPayload {
 	event_type: AgentWireEventType;
 	event: AgentSessionEvent;
 }
+export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent
+	? TEvent extends { type: string }
+		? Omit<TEvent, "partial" | "message" | "error">
+		: never
+	: never;
+
+export interface AgentWireCompactMessageUpdatePayload {
+	event_type: "message_update";
+	/** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+	compact: true;
+	message_id: string | null;
+	content_index: number | null;
+	assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
+	/** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
+	checkpoint_message?: Extract<AgentSessionEvent, { type: "message_update" }>["message"];
+	checkpoint_reason?: "periodic";
+}
+
+export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
 
 /**
  * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
@@ -146,3 +167,4 @@ export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = Agent
 
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
 export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
+export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

package/src/modes/shared/agent-wire/event-envelope.ts

@@ -12,6 +12,9 @@ import { randomUUID } from "node:crypto";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 import {
 	AGENT_WIRE_PROTOCOL_VERSION,
+	type AgentWireCompactAssistantMessageEvent,
+	type AgentWireCompactEventFrame,
+	type AgentWireCompactMessageUpdatePayload,
 	type AgentWireEventFrame,
 	type AgentWireEventPayload,
 	type AgentWireEventType,
@@ -19,6 +22,26 @@ import {
 	type AgentWireFrameType,
 } from "./event-contract";
 
+export const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
+
+function recordObject(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
+}
+
+function messageIdOf(message: unknown): string | null {
+	const id = recordObject(message)?.id;
+	return typeof id === "string" ? id : null;
+}
+
+function contentIndexOf(assistantMessageEvent: unknown): number | null {
+	const contentIndex = recordObject(assistantMessageEvent)?.contentIndex;
+	return typeof contentIndex === "number" && Number.isInteger(contentIndex) ? contentIndex : null;
+}
+
+function snapshotMessage<T>(message: T): T {
+	return structuredClone(message);
+}
+
 function assertNever(value: never): never {
 	throw new Error(`Unhandled AgentSessionEvent variant: ${JSON.stringify(value)}`);
 }
@@ -123,6 +146,65 @@ export function toAgentWireEventFrame(
 export function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload {
 	return { event_type: agentSessionEventType(event), event };
 }
+export function sanitizeAssistantMessageEventForCompact(
+	assistantMessageEvent: Extract<AgentSessionEvent, { type: "message_update" }>["assistantMessageEvent"],
+): AgentWireCompactAssistantMessageEvent {
+	const {
+		partial: _partial,
+		message: _message,
+		error: _error,
+		...deltaOnly
+	} = assistantMessageEvent as Record<string, unknown>;
+	return deltaOnly as AgentWireCompactAssistantMessageEvent;
+}
+
+export interface AgentWireCompactMessageUpdateOptions {
+	checkpointInterval?: number;
+}
+
+/**
+ * Stateful compact event serializer for opt-in RPC clients.
+ *
+ * Only `message_update` changes shape: it carries the immutable provider delta
+ * plus message/content identifiers, with periodic full-message checkpoints that
+ * are cloned synchronously before the caller returns to the event loop. All other
+ * event variants remain canonical full event frames so legacy bridge/RPC behavior
+ * and terminal `message_end` reconstruction are unchanged.
+ */
+export class AgentWireCompactEventEncoder {
+	readonly #sequencer: AgentWireFrameSequencer;
+	readonly #checkpointInterval: number;
+	#messageUpdateCount = 0;
+
+	constructor(sequencer: AgentWireFrameSequencer, options: AgentWireCompactMessageUpdateOptions = {}) {
+		this.#sequencer = sequencer;
+		this.#checkpointInterval = options.checkpointInterval ?? AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL;
+	}
+
+	frame(event: AgentSessionEvent): AgentWireCompactEventFrame {
+		if (event.type !== "message_update") return toAgentWireEventFrame(event, this.#sequencer);
+		this.#messageUpdateCount += 1;
+		const payload: AgentWireCompactMessageUpdatePayload = {
+			event_type: "message_update",
+			compact: true,
+			message_id: messageIdOf(event.message),
+			content_index: contentIndexOf(event.assistantMessageEvent),
+			assistantMessageEvent: sanitizeAssistantMessageEventForCompact(event.assistantMessageEvent),
+		};
+		if (this.#checkpointInterval > 0 && this.#messageUpdateCount % this.#checkpointInterval === 0) {
+			payload.checkpoint_message = snapshotMessage(event.message);
+			payload.checkpoint_reason = "periodic";
+		}
+		return this.#sequencer.next("event", payload);
+	}
+}
+
+export function toAgentWireCompactEventFrame(
+	event: AgentSessionEvent,
+	encoder: AgentWireCompactEventEncoder,
+): AgentWireCompactEventFrame {
+	return encoder.frame(event);
+}
 
 /** Back-compat alias for {@link toAgentWireEventFrame}. */
 export const toBridgeEventFrame = toAgentWireEventFrame;

package/src/modes/shared/agent-wire/scopes.ts

@@ -47,6 +47,7 @@ const RPC_COMMAND_SCOPE_REGISTRY: Record<RpcCommandType, BridgeCommandScope> = {
 	set_host_tools: "host_tools",
 	set_host_uri_schemes: "host_uri",
 	get_pending_workflow_gates: "message:read",
+	set_capabilities: "control",
 	set_model: "model",
 	cycle_model: "model",
 	get_available_models: "model",

package/src/modes/types.ts

@@ -216,6 +216,7 @@ export interface InteractiveModeContext {
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
+	handleContextClearCommand(): Promise<void>;
 	handleDropCommand(): Promise<void>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;

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

@@ -36,6 +36,19 @@ interface RenderInitialMessagesOptions {
 	preserveExistingChat?: boolean;
 }
 
+export function argsWithPartialJson(args: unknown, partialJson: unknown): unknown {
+	if (typeof partialJson !== "string" || !args || typeof args !== "object" || Array.isArray(args)) return args;
+	// Non-enumerable so the transient streaming buffer reaches renderers via direct
+	// property read but never serializes into persisted/wire message content.
+	Object.defineProperty(args, "__partialJson", {
+		value: partialJson,
+		enumerable: false,
+		configurable: true,
+		writable: true,
+	});
+	return args;
+}
+
 type QueuedMessages = {
 	steering: string[];
 	followUp: string[];
@@ -392,10 +405,10 @@ export class UiHelpers {
 
 					readGroup = null;
 					const tool = this.ctx.session.getToolByName(content.name);
-					const renderArgs =
-						"partialJson" in content
-							? { ...content.arguments, __partialJson: content.partialJson }
-							: content.arguments;
+					const renderArgs = argsWithPartialJson(
+						content.arguments,
+						"partialJson" in content ? content.partialJson : undefined,
+					);
 					const component = new ToolExecutionComponent(
 						content.name,
 						renderArgs,

package/src/notifications/config.ts

@@ -38,13 +38,24 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 	};
 }
 
+export function hasNonBlankValue(value: string | undefined): boolean {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+/** Is Telegram configured with usable non-blank boundary credentials? */
+export function isTelegramConfigured(
+	cfg: NotificationConfig,
+): cfg is NotificationConfig & { botToken: string; chatId: string } {
+	return cfg.enabled && hasNonBlankValue(cfg.botToken) && hasNonBlankValue(cfg.chatId);
+}
+
 /** 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)))
+		(isTelegramConfigured(cfg) ||
+			(hasNonBlankValue(cfg.discord.botToken) && hasNonBlankValue(cfg.discord.channelId)) ||
+			(hasNonBlankValue(cfg.slack.botToken) && hasNonBlankValue(cfg.slack.channelId)))
 	);
 }
 
@@ -88,6 +99,7 @@ export function isSessionNotificationsEnabled(input: {
 /** 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)";
+	if (token.length <= 4) return `…(len ${token.length})`;
 	return `${token.slice(0, 4)}…(len ${token.length})`;
 }
 
@@ -131,6 +143,6 @@ export function buildRedactedAction(
 	// Asks stay fully readable/answerable even under redaction.
 	if (action.kind === "ask") return action;
 
-	const { summary: _summary, question: _question, ...base } = action;
+	const { summary: _summary, question: _question, options: _options, ...base } = action;
 	return base;
 }