@gajae-code/coding-agent 0.9.1 → 0.9.2

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

@@ -36,17 +36,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 = {
@@ -619,7 +629,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();
@@ -633,6 +647,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) {
@@ -675,6 +694,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,
@@ -683,7 +709,7 @@ export class UiHelpers {
 					details,
 					attribution: "user",
 				},
-				{ streamingBehavior: message.mode },
+				promptOptions,
 			);
 		}
 
@@ -703,7 +729,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),
 		);
 	}
 
@@ -794,14 +824,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

package/src/notifications/index.ts

@@ -24,11 +24,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { promisify } from "node:util";
+import { ThinkingLevel } from "@gajae-code/agent-core";
 import type { ImageContent, TextContent } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { logger, postmortem } from "@gajae-code/utils";
 import { Settings } from "../config/settings";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "../extensibility/extensions";
+import { parseThinkingLevel } from "../thinking";
 import { registerAskAnswerSource } from "../tools/ask-answer-registry";
 import { registerTelegramFileSink } from "./attachment-registry";
 import {
@@ -407,20 +409,18 @@ function streamIntervalMs(): number {
 	return Math.max(200, Number(process.env.GJC_NOTIFICATIONS_STREAM_INTERVAL_MS) || 500);
 }
 // Max chars of a turn's assistant text carried by the FINALIZED turn_stream (and
-// the pre-ask capture). Default 3500 keeps the mirror a glanceable per-turn
-// summary; a client that splits long messages (the Telegram daemon does so via
-// splitTelegramHtml, scheduling each chunk through the shared rate-limit pool so
-// the fan-out never bypasses the per-chat limit) can raise it with
-// GJC_NOTIFICATIONS_TURN_MAX to deliver full turns. The value is clamped to a
-// finite [280, TURN_TEXT_MAX_CEILING] range: a non-finite or non-positive env
-// (unset, NaN, Infinity, <= 0) falls back to the default, so the cap can never
-// be unbounded. Live frames are intentionally NOT raised — they stay one
+// the pre-ask capture). Finalized turns default to the bounded full-turn ceiling
+// because split-capable clients such as the Telegram daemon schedule each
+// splitTelegramHtml chunk through the shared rate-limit pool. Operators who want
+// glanceable summaries can lower this with GJC_NOTIFICATIONS_TURN_MAX. The value
+// is always clamped to a finite [280, TURN_TEXT_MAX_CEILING] range so the cap can
+// never be unbounded. Live frames are intentionally NOT raised — they stay one
 // editable preview message rather than fanning a long in-progress turn across
 // sends.
 const TURN_TEXT_MAX_CEILING = 40_000;
 function turnTextMax(): number {
 	const raw = Number(process.env.GJC_NOTIFICATIONS_TURN_MAX);
-	if (!Number.isFinite(raw) || raw <= 0) return 3500;
+	if (!Number.isFinite(raw) || raw <= 0) return TURN_TEXT_MAX_CEILING;
 	return Math.min(TURN_TEXT_MAX_CEILING, Math.max(280, raw));
 }
 function resolveSettings(settingsOverride?: Settings): ResolvedSettings {
@@ -487,6 +487,121 @@ function mapAnswerToGate(
 	return { selected: [] };
 }
 
+interface NotificationControlCommandPayload {
+	name?: unknown;
+	action?: unknown;
+	level?: unknown;
+	instructions?: unknown;
+}
+
+function parseControlCommandPayload(json: string | undefined): NotificationControlCommandPayload | undefined {
+	if (!json) return undefined;
+	try {
+		const parsed = JSON.parse(json) as unknown;
+		return parsed && typeof parsed === "object" ? (parsed as NotificationControlCommandPayload) : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatCompactTokenCount(value: number | null | undefined): string {
+	if (value == null) return "unknown";
+	if (value >= 1_000_000) return `${Number((value / 1_000_000).toFixed(value % 1_000_000 === 0 ? 0 : 1))}m`;
+	if (value >= 1_000) return `${Number((value / 1_000).toFixed(value % 1_000 === 0 ? 0 : 1))}k`;
+	return value.toLocaleString();
+}
+
+function formatContextUsageLine(ctx: ExtensionContext): string {
+	const usage = ctx.getContextUsage();
+	if (!usage) return "Context usage unavailable.";
+	const tokens = formatCompactTokenCount(usage.tokens);
+	const window = formatCompactTokenCount(usage.contextWindow);
+	const pct = usage.percent == null ? "unknown" : `${usage.percent.toFixed(1)}%`;
+	return `Context: ${tokens}/${window} ${pct}`;
+}
+
+function formatLocalUsage(ctx: ExtensionContext): string {
+	const stats = ctx.sessionManager.getUsageStatistics();
+	return [
+		"Usage",
+		`Input tokens: ${stats.input}`,
+		`Output tokens: ${stats.output}`,
+		`Cache read tokens: ${stats.cacheRead}`,
+		`Cache write tokens: ${stats.cacheWrite}`,
+		`Premium requests: ${stats.premiumRequests}`,
+		`Cost: $${stats.cost.toFixed(6)}`,
+	].join("\n");
+}
+
+function cycleTelegramThinking(api: ExtensionAPI): ThinkingLevel | undefined {
+	const levels = [
+		ThinkingLevel.Off,
+		ThinkingLevel.Minimal,
+		ThinkingLevel.Low,
+		ThinkingLevel.Medium,
+		ThinkingLevel.High,
+		ThinkingLevel.XHigh,
+		ThinkingLevel.Max,
+	];
+	const current = api.getThinkingLevel() ?? ThinkingLevel.Off;
+	const currentIndex = levels.indexOf(current as (typeof levels)[number]);
+	const next = levels[(currentIndex + 1) % levels.length];
+	if (!next) return undefined;
+	api.setThinkingLevel(next);
+	return api.getThinkingLevel() ?? next;
+}
+
+export async function executeNotificationControlCommand(
+	command: NotificationControlCommandPayload | undefined,
+	ctx: ExtensionContext,
+	api: ExtensionAPI,
+): Promise<{ status: "ok" | "error" | "unavailable"; message: string }> {
+	if (!command || typeof command.name !== "string") return { status: "error", message: "Invalid control command." };
+	switch (command.name) {
+		case "reasoning": {
+			const current = api.getThinkingLevel() ?? ThinkingLevel.Off;
+			if (command.action === "status") return { status: "ok", message: `Reasoning effort: ${current}` };
+			if (command.action === "cycle") {
+				const next = cycleTelegramThinking(api);
+				return next
+					? { status: "ok", message: `Reasoning effort set to ${next}.` }
+					: { status: "unavailable", message: "Reasoning effort unavailable for this session." };
+			}
+			if (command.action === "set" && typeof command.level === "string") {
+				const parsed = parseThinkingLevel(command.level);
+				if (!parsed) return { status: "error", message: "Invalid reasoning effort." };
+				api.setThinkingLevel(parsed);
+				return { status: "ok", message: `Reasoning effort set to ${api.getThinkingLevel() ?? ThinkingLevel.Off}.` };
+			}
+			return { status: "error", message: "Invalid reasoning command." };
+		}
+		case "usage":
+			return { status: "ok", message: formatLocalUsage(ctx) };
+		case "context":
+			return { status: "ok", message: formatContextUsageLine(ctx) };
+		case "compact": {
+			const before = ctx.getContextUsage()?.tokens;
+			try {
+				await ctx.compact(typeof command.instructions === "string" ? command.instructions : undefined);
+			} catch (err) {
+				return {
+					status: "error",
+					message: `Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+				};
+			}
+			const after = ctx.getContextUsage()?.tokens;
+			if (before != null && after != null)
+				return {
+					status: "ok",
+					message: `Compaction complete. Tokens: ${before} -> ${after} (saved ${before - after}).`,
+				};
+			return { status: "ok", message: "Compaction complete." };
+		}
+		default:
+			return { status: "error", message: "Unknown control command." };
+	}
+}
+
 /** Register the interactive `ask` answer source for a session (the ask tool
  * races the local UI against a remote reply). Returns the deregister disposer. */
 function registerInteractiveAnswerSource(
@@ -703,6 +818,38 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 					}
 				}
 			}
+			if (inbound.kind === "control_command") {
+				if (!runtime || !inbound.requestId) return;
+				void executeNotificationControlCommand(parseControlCommandPayload(inbound.commandJson), ctx, api)
+					.then(result => {
+						runtime?.server.pushFrame(
+							JSON.stringify({
+								type: "control_command_result",
+								sessionId: id,
+								requestId: inbound.requestId,
+								updateId: inbound.updateId,
+								status: result.status,
+								message: result.message,
+							}),
+						);
+					})
+					.catch(err => {
+						try {
+							runtime?.server.pushFrame(
+								JSON.stringify({
+									type: "control_command_result",
+									sessionId: id,
+									requestId: inbound.requestId,
+									updateId: inbound.updateId,
+									status: "error",
+									message: `Control command failed: ${err instanceof Error ? err.message : String(err)}`,
+								}),
+							);
+						} catch (pushErr) {
+							logger.warn(`notifications: control_command_result failed: ${String(pushErr)}`);
+						}
+					});
+			}
 		});
 
 		try {

package/src/notifications/rich-render.ts

@@ -49,6 +49,7 @@ export function shouldPromoteRich(input: { enabled?: boolean; send: ThreadedSend
 		send.editable !== true &&
 		typeof send.richMarkdown === "string" &&
 		send.richMarkdown.trim().length > 0 &&
+		send.richMarkdown.length <= RICH_MESSAGE_LIMIT &&
 		typeof send.text === "string" &&
 		send.text.length > 0
 	);

package/src/notifications/telegram-daemon-cli.ts

@@ -15,7 +15,9 @@ type TelegramDaemonRunner = {
 type TelegramDaemonConstructor = new (opts: TelegramDaemonOptions) => TelegramDaemonRunner;
 
 export interface RunDaemonInternalDeps {
-	SettingsImpl?: { init: (options?: { agentDir?: string }) => Promise<Pick<Settings, "get" | "getAgentDir" | "set">> };
+	SettingsImpl?: {
+		init: (options?: { agentDir?: string }) => Promise<Pick<Settings, "get" | "getAgentDir" | "set" | "flush">>;
+	};
 	DaemonImpl?: TelegramDaemonConstructor;
 	processPid?: number;
 	pidAlive?: (pid: number) => boolean;
@@ -61,7 +63,7 @@ function asIdleTimeoutMs(value: unknown): number {
 export function createLightweightDaemonSettings(input: {
 	agentDir: string;
 	rawConfig?: unknown;
-}): Pick<Settings, "get" | "getAgentDir" | "set"> {
+}): Pick<Settings, "get" | "getAgentDir" | "set" | "flush"> {
 	const rawConfig = input.rawConfig && typeof input.rawConfig === "object" ? input.rawConfig : {};
 	return {
 		get(pathName: string): unknown {
@@ -120,12 +122,18 @@ export function createLightweightDaemonSettings(input: {
 			});
 			setByPath(rawConfig as Record<string, unknown>, segments, value);
 		},
-	} as Pick<Settings, "get" | "getAgentDir" | "set">;
+		async flush(): Promise<void> {
+			// The set() above is synchronously durable (it awaits the atomic tmp+rename
+			// write under the shared file lock), so there is never a pending save to
+			// flush. Present so the daemon can await flush() uniformly regardless of
+			// which Settings implementation is injected.
+		},
+	} as Pick<Settings, "get" | "getAgentDir" | "set" | "flush">;
 }
 
 export async function loadLightweightDaemonSettings(
 	agentDir: string,
-): Promise<Pick<Settings, "get" | "getAgentDir" | "set">> {
+): Promise<Pick<Settings, "get" | "getAgentDir" | "set" | "flush">> {
 	const configPath = path.join(agentDir, "config.yml");
 	let rawConfig: unknown = {};
 	try {
@@ -139,7 +147,7 @@ export async function loadLightweightDaemonSettings(
 async function resolveDaemonSettings(
 	agentDir: string,
 	deps: RunDaemonInternalDeps,
-): Promise<Pick<Settings, "get" | "getAgentDir" | "set">> {
+): Promise<Pick<Settings, "get" | "getAgentDir" | "set" | "flush">> {
 	if (deps.SettingsImpl) return await deps.SettingsImpl.init({ agentDir });
 	return await loadLightweightDaemonSettings(agentDir);
 }

package/src/notifications/telegram-daemon.ts

@@ -9,7 +9,7 @@ import type { Settings } from "../config/settings";
 import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { resolveGjcRuntimeSpawnInfo } from "../daemon/runtime";
 import { getNotificationConfig, isTelegramConfigured, tokenFingerprint } from "./config";
-import { parseInThreadConfigCommand, parseRichToggleCommand } from "./config-commands";
+import { parseInThreadConfigCommand, parseRichToggleCommand, parseTelegramControlCommand } from "./config-commands";
 import { daemonPaths } from "./daemon-paths";
 import {
 	buildCompactChoiceGrid,
@@ -111,6 +111,21 @@ export const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 export const NOTIFICATION_PROTOCOL_VERSION = 2;
 
 const nodeFs: TelegramDaemonFs = fs.promises as unknown as TelegramDaemonFs;
+
+/**
+ * Durably persist a `/rich` toggle. A real {@link Settings} exposes
+ * `flushOrThrow()`, which rejects on a failed config.yml write (its `set()` is a
+ * fire-and-forget whose background save swallows errors). The lightweight daemon
+ * settings has no `flushOrThrow` — its `set()` already wrote durably and throws
+ * on failure — so its plain `flush()` no-op drain is sufficient.
+ */
+async function flushRichToggleSettings(settings: Settings): Promise<void> {
+	if (typeof settings.flushOrThrow === "function") {
+		await settings.flushOrThrow();
+		return;
+	}
+	await settings.flush();
+}
 const RATE_LIMIT_FLUSH_INTERVAL_MS = 1_000;
 // How often the daemon rescans for newly-started sessions. This MUST run
 // independently of the Telegram getUpdates long-poll (up to 25s): otherwise a
@@ -1550,6 +1565,7 @@ export class TelegramNotificationDaemon {
 		"image_attachment",
 		"file_attachment",
 		"config_update",
+		"control_command_result",
 	]);
 
 	private topicNameFor(sessionId: string, msg: { title?: unknown; repo?: unknown; branch?: unknown }): string {
@@ -1913,7 +1929,7 @@ export class TelegramNotificationDaemon {
 					// upstream edit/send path, so off behavior is byte-identical.
 					if (
 						shouldPromoteRich({
-							enabled: this.opts.rich?.enabled === false ? false : true,
+							enabled: this.opts.rich?.enabled !== false,
 							send,
 						})
 					) {
@@ -2219,16 +2235,22 @@ export class TelegramNotificationDaemon {
 				// Rename the topic if the title changed (e.g. the session title was
 				// auto-generated after the topic was first created). This runs on
 				// every identity frame, but does NOT re-send the bulleted message.
+				// Only commit the new registry name after Telegram accepts the edit:
+				// a transient editForumTopic failure must remain retryable on the
+				// next identity re-assert instead of leaving the remote topic stuck
+				// at the provisional "GJC <id>" name forever.
 				const name = this.topicNameFor(session.sessionId, msg);
-				if (this.topics.applyName(session.sessionId, name)) {
+				if (this.topics.needsRename(session.sessionId, name)) {
 					try {
 						await this.botApi.call("editForumTopic", {
 							chat_id: this.opts.chatId,
 							message_thread_id: Number(topicId),
 							name,
 						});
+						this.topics.markNameApplied(session.sessionId, name);
 					} catch {
-						// Best-effort rename; never block delivery.
+						// Best-effort rename; never block delivery. Leave the old
+						// registry name intact so a later identity frame retries.
 					}
 				}
 				// Send the full bulleted identity header EXACTLY ONCE per topic.
@@ -2415,6 +2437,15 @@ export class TelegramNotificationDaemon {
 				}
 				try {
 					await this.opts.settings.set("notifications.telegram.rich.enabled", desired);
+					// Confirm success only after a DURABLE write. The real Settings.set is
+					// a synchronous fire-and-forget whose queued save (Settings.#saveNow)
+					// swallows write errors, and Settings.flush() inherits that — neither
+					// rejects on a failed config.yml write. flushOrThrow() rethrows the
+					// durable-write failure so it lands in the catch below (in-memory
+					// isolated Settings short-circuit and never throw). The lightweight
+					// daemon settings has no flushOrThrow: its set() already wrote durably
+					// (and throws on failure), so its flush() is only a no-op drain.
+					await flushRichToggleSettings(this.opts.settings);
 				} catch (err) {
 					logger.warn(
 						`notifications: /rich settings write failed (${err instanceof Error ? err.message : String(err)}); runtime unchanged`,
@@ -2468,6 +2499,45 @@ export class TelegramNotificationDaemon {
 					const injectedText = repliedOriginal
 						? `> replied-to message:\n${repliedOriginal}\n\n${baseInjectedText}`
 						: baseInjectedText;
+					const control = hasMedia
+						? { kind: "none" as const }
+						: parseTelegramControlCommand(inbound.text, this.botUsername);
+					if (control.kind !== "none") {
+						await this.rememberSeenUpdateId(inbound.updateId);
+						const sendControlNotice = async (body: string): Promise<void> => {
+							try {
+								await this.botApi.call("sendMessage", {
+									chat_id: this.opts.chatId,
+									message_thread_id: Number(inbound.threadId),
+									text: body,
+									parse_mode: TELEGRAM_PARSE_MODE,
+								});
+							} catch {
+								// Best-effort control feedback; never convert to user input.
+							}
+						};
+						if (control.kind === "ignored") return;
+						if (control.kind === "invalid") {
+							await sendControlNotice(control.usage);
+							return;
+						}
+						if (session?.ws.readyState !== WebSocket.OPEN) {
+							await sendControlNotice("Session control unavailable: session is disconnected.");
+							return;
+						}
+						session.ws.send(
+							JSON.stringify({
+								type: "control_command",
+								sessionId: inbound.sessionId,
+								token: session.token,
+								requestId: `tg:${inbound.updateId}`,
+								updateId: inbound.updateId,
+								threadId: inbound.threadId,
+								command: control.command,
+							}),
+						);
+						return;
+					}
 					const cfg = hasMedia ? undefined : parseInThreadConfigCommand(inbound.text);
 					// A plain (non-config) message while an ask is pending for this session
 					// answers that ask as free-input — instead of starting a new user turn.
@@ -2484,6 +2554,15 @@ export class TelegramNotificationDaemon {
 							}),
 						);
 						await this.rememberSeenUpdateId(inbound.updateId);
+						await this.botApi
+							.call("sendMessage", {
+								chat_id: this.opts.chatId,
+								message_thread_id: Number(inbound.threadId),
+								text: "Received as an answer to the pending ask.",
+							})
+							.catch(error => {
+								logger.warn(`telegram: failed to acknowledge pending ask reply: ${String(error)}`);
+							});
 						if (inbound.messageId !== undefined) await this.setReaction(inbound.messageId, QUEUED_REACTION);
 						return;
 					}
@@ -2548,6 +2627,10 @@ export class TelegramNotificationDaemon {
 					{ command: "lean", description: "Mirror assistant text + tool names only (default)" },
 					{ command: "redact", description: "Toggle redaction of streamed content: /redact <on|off>" },
 					{ command: "rich", description: "Toggle rich Telegram delivery: /rich <on|off>" },
+					{ command: "reasoning", description: "Show or change reasoning effort in this session" },
+					{ command: "usage", description: "Show provider/local usage for this session" },
+					{ command: "context", description: "Show current context usage for this session" },
+					{ command: "compact", description: "Compact this session: /compact [instructions]" },
 					{ command: "session_create", description: "Create a GJC session: path, worktree, or dir [--mpreset]" },
 					{ command: "session_recent", description: "List recent GJC sessions" },
 					{ command: "session_close", description: "Close a GJC-managed session" },

package/src/notifications/threaded-render.ts

@@ -77,6 +77,9 @@ interface ThreadedFrame {
 	// config_update
 	verbosity?: unknown;
 	redact?: unknown;
+	// control_command_result
+	status?: unknown;
+	message?: unknown;
 }
 
 function str(v: unknown): string | undefined {
@@ -218,6 +221,17 @@ export function renderThreadedFrame(frame: ThreadedFrame): ThreadedSend | undefi
 					}
 				: undefined;
 		}
+		case "control_command_result": {
+			const message = str(frame.message);
+			if (!message) return undefined;
+			const status = str(frame.status);
+			const prefix = status === "ok" ? "✅" : status === "unavailable" ? "⚠️" : "❌";
+			return {
+				method: "sendMessage",
+				lane: "idle",
+				text: finalizeTelegramHtml(`${prefix} ${escapeHtml(truncate(message, 1200))}`),
+			};
+		}
 		default:
 			return undefined;
 	}

package/src/notifications/topic-registry.ts

@@ -120,15 +120,16 @@ export class TopicRegistry {
 		return record ? !record.identitySent : true;
 	}
 
-	/**
-	 * Record the topic's applied title. Returns `true` when it changed (so the
-	 * caller should `editForumTopic`), `false` when already current or unknown.
-	 */
-	applyName(sessionId: string, name: string): boolean {
+	/** Whether a known session topic's applied title differs from `name`. */
+	needsRename(sessionId: string, name: string): boolean {
 		const record = this.topics.get(sessionId);
-		if (!record || record.name === name) return false;
-		record.name = name;
-		return true;
+		return record !== undefined && record.name !== name;
+	}
+
+	/** Commit a successfully-applied Telegram topic title. */
+	markNameApplied(sessionId: string, name: string): void {
+		const record = this.topics.get(sessionId);
+		if (record) record.name = name;
 	}
 
 	/** Remove a session topic record after Telegram deletes the topic. */