@gajae-code/coding-agent 0.11.3 → 0.11.5

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

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { type AgentMessage, ThinkingLevel } from "@gajae-code/agent-core";
 import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@gajae-code/tui";
-import { $env, sanitizeText } from "@gajae-code/utils";
+import { $env, logger, sanitizeText } from "@gajae-code/utils";
 import { type AppKeybinding, KEYBINDINGS } from "../../config/keybindings";
 import { isSettingsInitialized, settings } from "../../config/settings";
 import { resolveSubskillActivationForSkillInvocation } from "../../extensibility/gjc-plugins";
@@ -22,12 +22,14 @@ import { getUserMessageViewportAnchorIds } from "../../session/session-manager";
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
-import { ensureSupportedImageInput, ImageInputTooLargeError, loadImageInput } from "../../utils/image-loading";
+import { ensureSupportedImageInput, ImageInputTooLargeError } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
-import { formatPastedImageReference, resolvePastedImagePath } from "../../utils/pasted-image-path";
+import { loadPastedImageBatch, PastedImageBatchError } from "../../utils/pasted-image-loading";
+import { formatPastedImageReference, parsePastedImagePaths } from "../../utils/pasted-image-path";
 import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 import { ActionRegistry, APP_ACTION_METADATA } from "../action-registry";
 import { CommandPalette, type CommandPaletteAction, type CommandPaletteEntry } from "../components/command-palette";
+import type { PasteTextContext } from "../components/custom-editor";
 import { QueuePaneComponent } from "../components/queue-pane";
 import { type QueuedMessageMoveDirection, QueuedMessageSelectorComponent } from "../components/queued-message-selector";
 
@@ -44,14 +46,23 @@ const EMPTY_EDITOR_DOUBLE_ESCAPE_WINDOW_MS = 500;
 const IMAGE_PLACEHOLDER_PATTERN = /\[image ([1-9]\d*)\]/g;
 const IMAGE_PLACEHOLDER_PRESENT_PATTERN = /\[image [1-9]\d*\]/;
 
+interface InputControllerDependencies {
+	loadPastedImageBatch?: typeof loadPastedImageBatch;
+}
+
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
 }
 
 export class InputController {
 	readonly actionRegistry: ActionRegistry<void>;
+	readonly #loadPastedImageBatch: typeof loadPastedImageBatch;
 
-	constructor(private ctx: InteractiveModeContext) {
+	constructor(
+		private ctx: InteractiveModeContext,
+		dependencies: InputControllerDependencies = {},
+	) {
+		this.#loadPastedImageBatch = dependencies.loadPastedImageBatch ?? loadPastedImageBatch;
 		this.actionRegistry = new ActionRegistry({
 			context: undefined,
 			showError: actionId => this.ctx.showError(actionId),
@@ -585,11 +596,11 @@ export class InputController {
 		);
 		this.ctx.editor.onCopyPrompt = () => this.#executeAction("app.clipboard.copyPrompt");
 		this.#registerCommandPaletteAction("app.clipboard.copyPrompt", copyPrompt);
-		this.ctx.editor.onPasteText = text => this.handleTextPaste(text);
-		this.ctx.editor.onPastePendingInputCleared = (reason, droppedInputCount) => {
+		this.ctx.editor.onPasteText = (text, context) => this.handleTextPaste(text, context);
+		this.ctx.editor.onPastePendingInputCleared = (reason, restoredInputCount) => {
 			const reasonText = reason === "timeout" ? "timed out" : "exceeded the input queue limit";
 			this.ctx.showWarning(
-				`Paste handling ${reasonText}; discarded ${droppedInputCount} buffered input event${droppedInputCount === 1 ? "" : "s"}.`,
+				`Paste handling ${reasonText}; restored the original paste and ${restoredInputCount} buffered input event${restoredInputCount === 1 ? "" : "s"}.`,
 			);
 		};
 		const expandTools = () => this.toggleToolOutputExpansion();
@@ -1522,46 +1533,96 @@ export class InputController {
 		return true;
 	}
 
-	handleTextPaste(text: string): boolean | Promise<boolean> {
-		const imagePath = resolvePastedImagePath(text, { cwd: this.ctx.sessionManager.getCwd() });
-		return imagePath ? this.#attachPastedImagePath(imagePath) : false;
+	handleTextPaste(text: string, context: PasteTextContext): boolean | Promise<boolean> {
+		if (this.ctx.isBashMode || this.ctx.isPythonMode) return false;
+		const parsed = parsePastedImagePaths(text, { cwd: this.ctx.sessionManager.getCwd() });
+		if (!parsed) return false;
+		if (parsed.kind === "too-many") {
+			this.ctx.showStatus(`Cannot attach more than ${parsed.maxCandidates} pasted images.`);
+			return false;
+		}
+		return this.#attachPastedImagePaths(parsed.paths, parsed.requiresConfirmation, context);
 	}
 
-	/**
-	 * Returns `false` on every failure path so the editor replays the original
-	 * bracketed paste — the raw path text must never be lost when attachment
-	 * is impossible (unsupported content, oversized image, load error).
-	 */
-	async #attachPastedImagePath(imagePath: string): Promise<boolean> {
+	/** Return false on every failure so CustomEditor restores the exact paste. */
+	async #attachPastedImagePaths(
+		imagePaths: readonly string[],
+		requiresConfirmation: boolean,
+		context: PasteTextContext,
+	): Promise<boolean> {
+		const signal = context.signal;
+		const editor = this.ctx.editor;
+		const editorText = editor.getText();
+		const pendingImages = this.ctx.pendingImages;
+		const pendingImageCount = pendingImages.length;
 		try {
-			const image = await loadImageInput({
-				path: imagePath,
-				cwd: this.ctx.sessionManager.getCwd(),
+			if (requiresConfirmation) {
+				const selection = await this.ctx.showHookSelector(
+					`Attach ${imagePaths.length} pasted images?\nOnly attach files you intend to send to the model.`,
+					["Attach images", "Paste paths literally"],
+					{ signal, helpText: "Enter: choose · Esc: paste paths literally" },
+				);
+				signal.throwIfAborted();
+				if (selection !== "Attach images") return false;
+			}
+
+			const loaded = await this.#loadPastedImageBatch({
+				paths: imagePaths,
 				autoResize: this.ctx.settings.get("images.autoResize"),
+				sourcePolicy: requiresConfirmation ? "confirmed" : "automatic-temp",
+				signal,
 			});
-			if (!image) {
-				this.ctx.showStatus("Unsupported pasted image file");
-				return false;
-			}
+			signal.throwIfAborted();
+			return context.commit(() => {
+				if (
+					this.ctx.editor !== editor ||
+					editor.getText() !== editorText ||
+					this.ctx.pendingImages !== pendingImages ||
+					pendingImages.length !== pendingImageCount
+				) {
+					return false;
+				}
 
-			this.ctx.pendingImages = [
-				...this.ctx.pendingImages,
-				{
-					type: "image",
-					data: image.data,
-					mimeType: image.mimeType,
-				},
-			];
-			this.ctx.editor.insertText(`${formatPastedImageReference(this.#nextImagePlaceholder(), image.resolvedPath)} `);
-			this.ctx.showStatus(`Attached image: ${path.basename(image.resolvedPath)}`, { dim: true });
-			this.ctx.ui.requestRender();
-			return true;
+				const firstImageNumber = pendingImages.length + 1;
+				const references = loaded.sourcePaths.map((sourcePath, index) =>
+					formatPastedImageReference(`[image ${firstImageNumber + index}]`, sourcePath),
+				);
+				try {
+					editor.insertText(`${references.join(" ")} `);
+					this.ctx.pendingImages = [...pendingImages, ...loaded.images];
+				} catch (error) {
+					try {
+						editor.setText(editorText);
+					} catch {
+						// Preserve the original mutation error when rollback itself fails.
+					} finally {
+						this.ctx.pendingImages = pendingImages;
+					}
+					throw error;
+				}
+
+				try {
+					this.ctx.showStatus(
+						loaded.images.length === 1
+							? `Attached image: ${path.basename(loaded.sourcePaths[0] ?? "")}`
+							: `Attached ${loaded.images.length} images`,
+						{ dim: true },
+					);
+					this.ctx.ui.requestRender();
+				} catch (error) {
+					logger.warn("Pasted images attached but status rendering failed", { error: String(error) });
+				}
+				return true;
+			});
 		} catch (error) {
-			if (error instanceof ImageInputTooLargeError) {
+			if (signal.aborted) return false;
+			if (error instanceof ImageInputTooLargeError || error instanceof PastedImageBatchError) {
 				this.ctx.showStatus(error.message);
 				return false;
 			}
-			this.ctx.showStatus("Failed to attach pasted image");
+			this.ctx.showStatus(
+				imagePaths.length === 1 ? "Failed to attach pasted image" : "Failed to attach pasted images",
+			);
 			return false;
 		}
 	}

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) {
@@ -1060,7 +1122,7 @@ export class SelectorController {
 			};
 			wizard = new CustomProviderWizardComponent(
 				input => {
-					void submit(input);
+					return submit(input);
 				},
 				() => {
 					done();

package/src/modes/interactive-mode.ts

@@ -62,6 +62,7 @@ import {
 } from "./components/pet-capability";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { StatusLineComponent } from "./components/tool-status-header";
+import { composeToolText } from "./components/tool-transcript-format";
 import {
 	WelcomeComponent,
 	type WelcomeLogoMode,
@@ -1817,17 +1818,28 @@ export class InteractiveMode implements InteractiveModeContext {
 						result?.content
 							.filter(part => part.type === "text")
 							.map(part => part.text)
-							.join("\n") ?? "";
+							.join("\n")
+							.trim() ?? "";
 					items.push({
 						kind: "tool",
 						source: { toolCallId: content.id, content, result },
 						getPayload: () => ({
-							text: resultText || JSON.stringify(content.arguments, null, 2),
+							text: composeToolText({
+								name: content.name,
+								args: content.arguments,
+								intent: content.intent,
+								resultText,
+								isError: result?.isError ?? false,
+								hasResult: toolResults.has(content.id),
+							}),
 							metadata: {
 								name: content.name,
 								arguments: content.arguments,
 								intent: content.intent,
 								isError: result?.isError ?? false,
+								resultText,
+								hasResult: toolResults.has(content.id),
+								detailsData: result?.details,
 							},
 							source: { content, result },
 						}),

package/src/modes/shared/agent-wire/deep-interview-gate.ts

@@ -10,6 +10,11 @@
  * This is the pure mapping primitive used by SDK-native workflow gate emitters.
  */
 
+import { isDeepInterviewAskQuestion } from "../../../deep-interview/render-middleware";
+import {
+	assertDeepInterviewInputWithinLimit,
+	MAX_USER_RESPONSE_LENGTH,
+} from "../../../gjc-runtime/deep-interview-state";
 import type { OpenGateInput } from "./workflow-gate-broker";
 import {
 	type AskGateDeepInterviewState,
@@ -134,7 +139,17 @@ export function buildAskGateStageState(question: AskGateQuestion, labels: string
 /** Build the `workflow_gate` open-input for one ask question. */
 export function questionToGate(question: AskGateQuestion): OpenGateInput {
 	const labels = question.options.map(o => o.label);
-	const schema = buildAskGateAnswerSchema(question, labels);
+	const schema = buildAskGateAnswerSchema(
+		{
+			multi: question.multi,
+			allowEmpty: question.allowEmpty,
+			customMaxLength:
+				question.deepInterview || isDeepInterviewAskQuestion(question.question)
+					? MAX_USER_RESPONSE_LENGTH
+					: undefined,
+		},
+		labels,
+	);
 	return {
 		stage: question.workflowGate?.stage ?? "deep-interview",
 		kind: question.workflowGate?.kind ?? "question",
@@ -229,6 +244,12 @@ export function gateAnswerToResult(question: AskGateQuestion, answer: unknown):
 	if (other && (answer.custom === undefined || answer.custom.trim() === "")) {
 		throw new DeepInterviewGateError("missing_custom", "custom text is required when `other` is true");
 	}
+	if (
+		other &&
+		(question.deepInterview || isDeepInterviewAskQuestion(question.question)) &&
+		answer.custom !== undefined
+	)
+		assertDeepInterviewInputWithinLimit(answer.custom, MAX_USER_RESPONSE_LENGTH, "user_response");
 	return {
 		id: question.id,
 		question: question.question,
@@ -261,6 +282,15 @@ export function classifyAskGateDisposition(
 		multi: (state as Record<string, unknown>).multi === true,
 		allowEmpty: (state as Record<string, unknown>).allow_empty === true,
 	};
+	if (
+		(state as Record<string, unknown>).deep_interview_metadata === true &&
+		typeof (answer as Record<string, unknown>)?.custom === "string"
+	)
+		assertDeepInterviewInputWithinLimit(
+			(answer as Record<string, unknown>).custom as string,
+			MAX_USER_RESPONSE_LENGTH,
+			"user_response",
+		);
 	if (typeof answer === "object" && answer !== null && (answer as Record<string, unknown>).action === "clarify") {
 		gateAnswerToResult(question, answer);
 		return "resolve_without_commit";

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -76,6 +76,13 @@ export interface NotificationGateResolutionOptions {
 	closeClaimInvalid(reason: string): void;
 }
 
+export class NotificationGatePolicyChangedError extends Error {
+	constructor() {
+		super("Notification policy changed while resolving the workflow gate");
+		this.name = "NotificationGatePolicyChangedError";
+	}
+}
+
 export interface AskSelectedAckRecoveryParticipant {
 	requestRecoveredAskSelectedAck(input: {
 		sessionId: string;
@@ -361,7 +368,8 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 								daemonDeadlineAt: Date.now() + 8_000,
 								hostTimeoutMs: 10_000,
 							});
-						} catch {
+						} catch (error) {
+							if (error instanceof NotificationGatePolicyChangedError) throw error;
 							outcome = { status: "unknown", reason: "host_timeout" };
 						}
 						this.#broker.updateAckPolicy(response.gate_id, {
@@ -378,6 +386,14 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 			else closeClaimInvalid(resolution.error?.code ?? "invalid_answer");
 			return resolution;
 		} catch (error) {
+			if (error instanceof NotificationGatePolicyChangedError) {
+				try {
+					closeClaimInvalid(error.message);
+				} finally {
+					this.quarantineGate(response.gate_id);
+				}
+				throw error;
+			}
 			closeClaimInvalid(error instanceof Error ? error.message : "invalid_answer");
 			this.#scheduleRecovery();
 			throw error;

package/src/modes/shared/agent-wire/workflow-gate-schema.ts

@@ -12,6 +12,7 @@
  * swapped in later without changing callers.
  */
 import { createHash } from "node:crypto";
+import { deepInterviewCharacterCount } from "../../../gjc-runtime/deep-interview-state";
 import type { JsonSchema, WorkflowGateValidationError } from "./workflow-gate-types";
 
 /** Keywords this wrapper understands. Any other keyword is rejected. */
@@ -238,7 +239,8 @@ function validateValue(schema: JsonSchema, value: unknown, path: string, errors:
 		if (!ok) errors.push({ path, keyword: "enum", message: "value not in enum", expected: schema.enum });
 	}
 	if (typeof value === "string") {
-		if (schema.minLength !== undefined && value.length < schema.minLength) {
+		const characterCount = deepInterviewCharacterCount(value);
+		if (schema.minLength !== undefined && characterCount < schema.minLength) {
 			errors.push({
 				path,
 				keyword: "minLength",
@@ -246,7 +248,7 @@ function validateValue(schema: JsonSchema, value: unknown, path: string, errors:
 				expected: schema.minLength,
 			});
 		}
-		if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+		if (schema.maxLength !== undefined && characterCount > schema.maxLength) {
 			errors.push({
 				path,
 				keyword: "maxLength",