@sayknow-cli/coding-agent 0.3.9 → 0.3.11

package/src/modes/components/thinking-selector.ts

@@ -1,53 +1,114 @@
 import { ThinkingLevel, type ThinkingLevel as ThinkingLevelValue } from "@sayknow-cli/agent-core";
-import { Container, type SelectItem, SelectList } from "@sayknow-cli/tui";
-import { getSelectListTheme } from "../../modes/theme/theme";
+import { Container, type SelectItem, SelectList, Text } from "@sayknow-cli/tui";
+import { getSelectListTheme, theme } from "../../modes/theme/theme";
 import { getThinkingLevelMetadata, type ThinkingLevelValue as ThinkingMetadataValue } from "../../thinking-metadata";
 import { DynamicBorder } from "./dynamic-border";
 
+const SCOPE_ITEMS = [
+	{
+		value: "session",
+		label: "Apply for this session",
+		description: "Use this effort until the session changes it again",
+	},
+	{
+		value: "default",
+		label: "Set as default",
+		description: "Save this effort for future sessions",
+	},
+] as const satisfies readonly SelectItem[];
+
+export interface ThinkingSelectorSelection {
+	level: ThinkingLevelValue;
+	persistDefault: boolean;
+}
+
 /**
  * Component that renders a thinking level selector with borders
  */
 export class ThinkingSelectorComponent extends Container {
 	#selectList: SelectList;
+	#levelList: SelectList;
+	#selectedLevel: ThinkingLevelValue | undefined;
+	readonly #onSelect: (selection: ThinkingSelectorSelection) => void;
+	readonly #onCancel: () => void;
 
 	constructor(
 		currentLevel: ThinkingLevelValue | undefined,
 		availableLevels: ThinkingLevelValue[],
-		onSelect: (level: ThinkingLevelValue) => void,
+		onSelect: (selection: ThinkingSelectorSelection) => void,
 		onCancel: () => void,
 	) {
 		super();
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(level =>
-			getThinkingLevelMetadata(level as ThinkingMetadataValue),
-		);
+		this.#onSelect = onSelect;
+		this.#onCancel = onCancel;
 
-		// Add top border
-		this.addChild(new DynamicBorder());
+		const currentValue = currentLevel ?? ThinkingLevel.Off;
+		const thinkingLevels: SelectItem[] = availableLevels.map(level => {
+			const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+			return level === currentValue
+				? { ...metadata, label: metadata.label + theme.fg("muted", " (current)") }
+				: metadata;
+		});
 
-		// Create selector
-		this.#selectList = new SelectList(thinkingLevels, thinkingLevels.length, getSelectListTheme());
+		this.#levelList = new SelectList(thinkingLevels, thinkingLevels.length, getSelectListTheme());
+		this.#selectList = this.#levelList;
 
 		// Preselect current level
-		const currentIndex = thinkingLevels.findIndex(item => item.value === (currentLevel ?? ThinkingLevel.Off));
+		const currentIndex = thinkingLevels.findIndex(item => item.value === currentValue);
 		if (currentIndex !== -1) {
-			this.#selectList.setSelectedIndex(currentIndex);
+			this.#levelList.setSelectedIndex(currentIndex);
 		}
 
-		this.#selectList.onSelect = item => {
-			onSelect(item.value as ThinkingLevelValue);
+		this.#levelList.onSelect = item => {
+			this.#selectedLevel = item.value as ThinkingLevelValue;
+			this.#renderScopeList();
 		};
 
-		this.#selectList.onCancel = () => {
-			onCancel();
+		this.#levelList.onCancel = () => {
+			this.#onCancel();
 		};
 
-		this.addChild(this.#selectList);
+		this.#renderLevelList();
+	}
+
+	#renderLevelList(): void {
+		this.detachAll();
+		this.#selectedLevel = undefined;
+		this.#selectList = this.#levelList;
+		this.addChild(new DynamicBorder());
+		this.addChild(this.#levelList);
+		this.addChild(new DynamicBorder());
+	}
+
+	#renderScopeList(): void {
+		const level = this.#selectedLevel;
+		if (!level) return;
+
+		const scopeList = new SelectList(SCOPE_ITEMS, SCOPE_ITEMS.length, getSelectListTheme());
+		scopeList.onSelect = item => {
+			this.#onSelect({
+				level,
+				persistDefault: item.value === "default",
+			});
+		};
+		scopeList.onCancel = () => {
+			this.#renderLevelList();
+		};
 
-		// Add bottom border
+		const metadata = getThinkingLevelMetadata(level as ThinkingMetadataValue);
+		this.detachAll();
+		this.#selectList = scopeList;
+		this.addChild(new DynamicBorder());
+		this.addChild(new Text(theme.fg("muted", `  Reasoning effort: ${metadata.label}`), 0, 0));
+		this.addChild(scopeList);
 		this.addChild(new DynamicBorder());
 	}
 
+	handleInput(data: string): void {
+		this.#selectList.handleInput(data);
+	}
+
 	getSelectList(): SelectList {
 		return this.#selectList;
 	}

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

@@ -27,6 +27,8 @@ interface Expandable {
 }
 
 const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5_000;
+const IMAGE_PLACEHOLDER_PATTERN = /\[image ([1-9]\d*)\]/g;
+const IMAGE_PLACEHOLDER_PRESENT_PATTERN = /\[image [1-9]\d*\]/;
 
 function isExpandable(obj: unknown): obj is Expandable {
 	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -383,6 +385,7 @@ export class InputController {
 			this.ctx.isBashMode = trimmed.startsWith("!");
 			this.ctx.isBashNoContext = trimmed.startsWith("!!");
 			this.ctx.isPythonMode = trimmed.startsWith("$") && !trimmed.startsWith("${");
+			this.#clearPendingImagesIfPlaceholdersRemoved(text);
 			if (
 				wasBashMode !== this.ctx.isBashMode ||
 				wasBashNoContext !== this.ctx.isBashNoContext ||
@@ -418,7 +421,7 @@ export class InputController {
 			}
 
 			const runner = this.ctx.session.extensionRunner;
-			let inputImages = this.ctx.pendingImages.length > 0 ? [...this.ctx.pendingImages] : undefined;
+			let inputImages = this.#visiblePendingImagesForText(text);
 
 			if (runner?.hasHandlers("input")) {
 				const result = await runner.emitInput(text, inputImages, "interactive");
@@ -498,7 +501,7 @@ export class InputController {
 
 			// Queue input during compaction
 			if (this.ctx.session.isCompacting) {
-				if (this.ctx.pendingImages.length > 0) {
+				if ((inputImages?.length ?? 0) > 0) {
 					this.ctx.showStatus("Compaction in progress. Retry after it completes to send images.");
 					return;
 				}
@@ -520,11 +523,13 @@ export class InputController {
 				// typed since queuing intact. Same protection as #783, applied to
 				// the streaming/queue path.
 				const streamingBehavior = this.#busyStreamingBehavior();
-				await this.ctx.withLocalSubmission(
-					text,
-					() => this.ctx.session.prompt(text, { streamingBehavior, images }),
-					{ imageCount: images?.length ?? 0 },
-				);
+				const promptOptions =
+					streamingBehavior === "followUp"
+						? { streamingBehavior, images, followUpQueuePolicy: "sequential" as const }
+						: { streamingBehavior, images };
+				await this.ctx.withLocalSubmission(text, () => this.ctx.session.prompt(text, promptOptions), {
+					imageCount: images?.length ?? 0,
+				});
 				this.ctx.updatePendingMessagesDisplay();
 				this.ctx.ui.requestRender();
 				return;
@@ -869,7 +874,9 @@ export class InputController {
 						details,
 						attribution: "user",
 					},
-					{ streamingBehavior },
+					streamingBehavior === "followUp"
+						? { streamingBehavior, followUpQueuePolicy: "sequential" }
+						: { streamingBehavior },
 				);
 			}
 			if (this.ctx.session.isStreaming) {
@@ -911,7 +918,10 @@ export class InputController {
 			this.ctx.editor.addToHistory(text);
 			this.ctx.editor.setText("");
 			await this.ctx.withLocalSubmission(text, () =>
-				this.ctx.session.prompt(text, { streamingBehavior: "followUp" }),
+				this.ctx.session.prompt(text, {
+					streamingBehavior: "followUp",
+					followUpQueuePolicy: "sequential",
+				}),
 			);
 			this.ctx.updatePendingMessagesDisplay();
 			this.ctx.ui.requestRender();
@@ -1104,6 +1114,37 @@ export class InputController {
 		return `[image ${this.ctx.pendingImages.length}]`;
 	}
 
+	#visiblePendingImagesForText(text: string): InteractiveModeContext["pendingImages"] | undefined {
+		if (this.ctx.pendingImages.length === 0) {
+			return undefined;
+		}
+
+		const images: InteractiveModeContext["pendingImages"] = [];
+		const seenImageIndexes = new Set<number>();
+		for (const match of text.matchAll(IMAGE_PLACEHOLDER_PATTERN)) {
+			const placeholderNumberText = match[1];
+			if (!placeholderNumberText) continue;
+			const placeholderNumber = Number.parseInt(placeholderNumberText, 10);
+			const imageIndex = placeholderNumber - 1;
+			if (imageIndex < 0 || imageIndex >= this.ctx.pendingImages.length || seenImageIndexes.has(imageIndex)) {
+				continue;
+			}
+			const image = this.ctx.pendingImages[imageIndex];
+			if (!image) continue;
+			images.push(image);
+			seenImageIndexes.add(imageIndex);
+		}
+
+		return images.length > 0 ? images : undefined;
+	}
+
+	#clearPendingImagesIfPlaceholdersRemoved(text: string): void {
+		if (this.ctx.pendingImages.length === 0 || IMAGE_PLACEHOLDER_PRESENT_PATTERN.test(text)) {
+			return;
+		}
+		this.ctx.pendingImages = [];
+	}
+
 	async handleImagePaste(): Promise<boolean> {
 		try {
 			const image = await readImageFromClipboard();

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

@@ -340,12 +340,13 @@ export class SelectorController {
 			const selector = new ThinkingSelectorComponent(
 				this.ctx.session.thinkingLevel,
 				availableLevels,
-				level => {
+				selection => {
 					done();
 
+					const { level, persistDefault } = selection;
 					const configuredDefault = this.ctx.settings.get("defaultThinkingLevel");
 					const levelToApply = level === ThinkingLevel.Inherit ? configuredDefault : level;
-					this.ctx.session.setThinkingLevel(levelToApply, false);
+					this.ctx.session.setThinkingLevel(levelToApply, persistDefault);
 					const effectiveLevel = this.ctx.session.thinkingLevel ?? ThinkingLevel.Off;
 					const requestedLabel =
 						level === ThinkingLevel.Inherit ? `${level} (configured default: ${configuredDefault})` : level;
@@ -355,9 +356,11 @@ export class SelectorController {
 					this.ctx.statusLine.invalidate();
 					this.ctx.updateEditorBorderColor();
 					this.ctx.updateEditorTopBorder();
+					if (persistDefault) void this.ctx.notifyConfigChanged?.();
 					this.ctx.ui.requestRender();
+					const scopeLabel = persistDefault ? "Default reasoning effort" : "Reasoning effort";
 					this.ctx.showStatus(
-						`Reasoning effort set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+						`${scopeLabel} set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
 					);
 				},
 				() => {
@@ -365,10 +368,9 @@ export class SelectorController {
 					this.ctx.ui.requestRender();
 				},
 			);
-			return { component: selector, focus: selector.getSelectList() };
+			return { component: selector, focus: selector };
 		});
 	}
-
 	showSettingsSelector(): void {
 		getAvailableThemes().then(availableThemes => {
 			this.showSelector(done => {

package/src/modes/types.ts

@@ -34,6 +34,7 @@ import type { Theme } from "./theme/theme";
 export type CompactionQueuedMessage = {
 	text: string;
 	mode: "steer" | "followUp";
+	followUpQueuePolicy?: "sequential";
 };
 
 export type SubmittedUserInput = {

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

@@ -37,17 +37,27 @@ interface RenderInitialMessagesOptions {
 	preserveExistingChat?: boolean;
 }
 
+function cloneRenderArgs(args: Record<string, unknown>): Record<string, unknown> {
+	try {
+		return structuredClone(args);
+	} catch {
+		return { ...args };
+	}
+}
+
 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", {
+	// Keep the transient streaming buffer on a renderer-only snapshot. The live
+	// assistant message args are later validated/executed, so UI-only metadata or
+	// renderer mutations must never share that object reference.
+	const renderArgs = cloneRenderArgs(args as Record<string, unknown>);
+	Object.defineProperty(renderArgs, "__partialJson", {
 		value: partialJson,
 		enumerable: false,
 		configurable: true,
 		writable: true,
 	});
-	return args;
+	return renderArgs;
 }
 
 type QueuedMessages = {
@@ -625,7 +635,11 @@ export class UiHelpers {
 	}
 
 	queueCompactionMessage(text: string, mode: "steer" | "followUp"): void {
-		this.ctx.compactionQueuedMessages.push({ text, mode } as CompactionQueuedMessage);
+		const entry: CompactionQueuedMessage = { text, mode };
+		if (mode === "followUp") {
+			entry.followUpQueuePolicy = "sequential";
+		}
+		this.ctx.compactionQueuedMessages.push(entry);
 		this.ctx.editor.addToHistory(text);
 		this.ctx.editor.setText("");
 		this.ctx.updatePendingMessagesDisplay();
@@ -639,6 +653,11 @@ export class UiHelpers {
 		return this.#hasSkillInvocations(text) || this.isKnownSlashCommand(text);
 	}
 
+	#compactionFollowUpQueuePolicy(message: CompactionQueuedMessage): "sequential" | undefined {
+		if (message.mode !== "followUp") return undefined;
+		return message.followUpQueuePolicy ?? "sequential";
+	}
+
 	async #deliverQueuedSkillMessage(message: CompactionQueuedMessage): Promise<boolean> {
 		const invocations = parseSkillInvocations(message.text, this.ctx.skillCommands ?? new Map());
 		if (invocations.length === 0) {
@@ -681,6 +700,13 @@ export class UiHelpers {
 				continue;
 			}
 
+			const promptOptions =
+				message.mode === "followUp"
+					? {
+							streamingBehavior: message.mode,
+							followUpQueuePolicy: this.#compactionFollowUpQueuePolicy(message),
+						}
+					: { streamingBehavior: message.mode };
 			await this.ctx.session.promptCustomMessage(
 				{
 					customType: SKILL_PROMPT_MESSAGE_TYPE,
@@ -689,7 +715,7 @@ export class UiHelpers {
 					details,
 					attribution: "user",
 				},
-				{ streamingBehavior: message.mode },
+				promptOptions,
 			);
 		}
 
@@ -709,7 +735,11 @@ export class UiHelpers {
 			return;
 		}
 		await this.ctx.withLocalSubmission(message.text, () =>
-			message.mode === "followUp" ? this.ctx.session.followUp(message.text) : this.ctx.session.steer(message.text),
+			message.mode === "followUp"
+				? this.ctx.session.followUp(message.text, undefined, {
+						followUpQueuePolicy: this.#compactionFollowUpQueuePolicy(message),
+					})
+				: this.ctx.session.steer(message.text),
 		);
 	}
 
@@ -800,14 +830,17 @@ export class UiHelpers {
 			// `restoreQueue` rather than rethrown, so we use the primitive
 			// recordLocalSubmission and dispose manually in the catch.
 			const disposeFirstPrompt = this.ctx.recordLocalSubmission(firstPrompt.text);
-			const promptPromise = this.ctx.session
-				.prompt(firstPrompt.text, {
-					streamingBehavior: firstPrompt.mode === "followUp" ? "followUp" : "steer",
-				})
-				.catch((error: unknown) => {
-					disposeFirstPrompt();
-					restoreQueue(error);
-				});
+			const firstPromptOptions =
+				firstPrompt.mode === "followUp"
+					? {
+							streamingBehavior: "followUp" as const,
+							followUpQueuePolicy: this.#compactionFollowUpQueuePolicy(firstPrompt),
+						}
+					: { streamingBehavior: "steer" as const };
+			const promptPromise = this.ctx.session.prompt(firstPrompt.text, firstPromptOptions).catch((error: unknown) => {
+				disposeFirstPrompt();
+				restoreQueue(error);
+			});
 
 			for (const message of rest) {
 				await this.#deliverQueuedMessage(message);

package/src/notifications/config-commands.ts

@@ -20,6 +20,76 @@ export interface ConfigCommandChange {
 	redact?: boolean;
 }
 
+export type TelegramControlCommandName = "reasoning" | "usage" | "context" | "compact";
+
+export type TelegramControlCommand =
+	| { name: "reasoning"; action: "cycle" | "status" | "set"; level?: string }
+	| { name: "usage" }
+	| { name: "context" }
+	| { name: "compact"; instructions?: string };
+
+export type TelegramControlCommandParseResult =
+	| { kind: "none" }
+	| { kind: "ignored"; commandName: TelegramControlCommandName }
+	| { kind: "command"; command: TelegramControlCommand }
+	| { kind: "invalid"; commandName: TelegramControlCommandName; usage: string };
+
+const TELEGRAM_CONTROL_COMMANDS = new Set<TelegramControlCommandName>(["reasoning", "usage", "context", "compact"]);
+const TELEGRAM_REASONING_LEVELS = new Set(["inherit", "off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+
+function splitTelegramBotSuffix(rawCommand: string): { name: string; suffix?: string } {
+	const [name, suffix] = rawCommand.toLowerCase().split("@", 2);
+	return suffix ? { name, suffix } : { name };
+}
+
+export function telegramControlCommandUsage(commandName: TelegramControlCommandName): string {
+	switch (commandName) {
+		case "reasoning":
+			return "Usage: /reasoning [cycle|inherit|off|minimal|low|medium|high|xhigh|max]";
+		case "usage":
+			return "Usage: /usage";
+		case "context":
+			return "Usage: /context";
+		case "compact":
+			return "Usage: /compact [instructions]";
+	}
+}
+
+/** Parse deterministic Telegram session-control commands. Recognised roots fail closed. */
+export function parseTelegramControlCommand(text: string, botUsername?: string): TelegramControlCommandParseResult {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("/")) return { kind: "none" };
+	const [rawRoot, ...rest] = trimmed.slice(1).split(/\s+/);
+	if (!rawRoot) return { kind: "none" };
+	const { name: root, suffix } = splitTelegramBotSuffix(rawRoot);
+	if (!TELEGRAM_CONTROL_COMMANDS.has(root as TelegramControlCommandName)) return { kind: "none" };
+	const commandName = root as TelegramControlCommandName;
+	if (suffix && (!botUsername || suffix !== botUsername.toLowerCase())) return { kind: "ignored", commandName };
+	const usage = telegramControlCommandUsage(commandName);
+
+	switch (commandName) {
+		case "usage":
+		case "context":
+			return rest.length === 0
+				? { kind: "command", command: { name: commandName } }
+				: { kind: "invalid", commandName, usage };
+		case "compact": {
+			const instructions = trimmed.slice(rawRoot.length + 1).trim();
+			return { kind: "command", command: instructions ? { name: "compact", instructions } : { name: "compact" } };
+		}
+		case "reasoning": {
+			if (rest.length === 0) return { kind: "command", command: { name: "reasoning", action: "status" } };
+			if (rest.length !== 1) return { kind: "invalid", commandName, usage };
+			const levelOrAction = rest[0]!.toLowerCase();
+			if (levelOrAction === "cycle") return { kind: "command", command: { name: "reasoning", action: "cycle" } };
+			if (TELEGRAM_REASONING_LEVELS.has(levelOrAction)) {
+				return { kind: "command", command: { name: "reasoning", action: "set", level: levelOrAction } };
+			}
+			return { kind: "invalid", commandName, usage };
+		}
+	}
+}
+
 /**
  * Parse an in-thread config command. Returns the requested change, or
  * `undefined` when the text is not a recognised config command (so the daemon