@gajae-code/coding-agent 0.8.2 → 0.9.1

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

@@ -116,6 +116,7 @@ export interface InteractiveModeContext {
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined;
 	locallySubmittedUserSignatures: Set<string>;
+	optimisticInjectedSignatures: Map<string, number>;
 	lastSigintTime: number;
 	lastEscapeTime: number;
 	lastComposerClearEscapeTime: number;
@@ -216,6 +217,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>;
@@ -243,6 +245,7 @@ export interface InteractiveModeContext {
 	showExtensionsDashboard(): void;
 	showAgentsDashboard(): void;
 	showModelSelector(options?: { temporaryOnly?: boolean }): void;
+	showEffortSelector(): void;
 	showProviderOnboarding(): void;
 	showPluginSelector(mode?: "install" | "uninstall"): void;
 	showUserMessageSelector(): void;

package/src/modes/utils/injected-user-submission.ts

@@ -0,0 +1,94 @@
+import type { ImageContent, TextContent } from "@gajae-code/ai";
+import type { InteractiveModeContext } from "../types";
+
+/**
+ * Normalize the content passed to an extension `sendUserMessage` call into a
+ * plain text string plus its image attachments. Mirrors the normalization in
+ * `AgentSession.sendUserMessage` (text parts joined with "\n") so the resulting
+ * text matches the eventual user `message_start` payload.
+ */
+export function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {
+	text: string;
+	images: ImageContent[];
+	imageCount: number;
+} {
+	if (typeof content === "string") {
+		return { text: content, images: [], imageCount: 0 };
+	}
+	const textParts: string[] = [];
+	const images: ImageContent[] = [];
+	for (const part of content) {
+		if (part.type === "text") textParts.push(part.text);
+		else images.push(part);
+	}
+	const text = textParts.join("\n");
+	return { text, images, imageCount: images.length };
+}
+
+/**
+ * Record a remotely/programmatically injected user message (e.g. Telegram
+ * inbound routed through the extension API) into the interactive TUI, so it is
+ * captured in prompt history and shown immediately instead of only appearing
+ * once the eventual `message_start` event lands.
+ *
+ * Local TUI submissions never reach this path (they go through
+ * `session.prompt(...)` / `startPendingSubmission`), so this cannot double-add
+ * local prompt history.
+ *
+ * - Always adds the injected text to editor prompt history.
+ * - Idle injections optimistically render the user message and record a pending
+ *   injected optimistic signature (a counting Map, so multiple idle injections
+ *   before the first `message_start` do not clobber each other); the later user
+ *   `message_start` consumes one count and skips both the duplicate chat add and
+ *   the defensive editor clear (so a locally typed draft is preserved).
+ * - Busy/queued injections refresh the pending-message display, which the
+ *   caller has already populated by invoking `session.sendUserMessage(...)`
+ *   before this helper.
+ *
+ * This helper never clears the editor text.
+ */
+export function applyInjectedUserSubmission(
+	ctx: InteractiveModeContext,
+	input: { content: string | (TextContent | ImageContent)[]; queued: boolean },
+): void {
+	const { text, images, imageCount } = normalizeInjectedUserContent(input.content);
+	ctx.editor.addToHistory(text);
+
+	if (input.queued) {
+		ctx.updatePendingMessagesDisplay();
+		ctx.ui.requestRender();
+		return;
+	}
+
+	incrementInjectedOptimisticSignature(ctx, `${text}\u0000${imageCount}`);
+	ctx.addMessageToChat({
+		role: "user",
+		content: [{ type: "text", text }, ...images],
+		attribution: "user",
+		timestamp: Date.now(),
+	});
+	ctx.ui.requestRender();
+}
+
+/**
+ * Record one pending optimistic render for an injected user message.
+ *
+ * Injected sends are fire-and-forget and multiple idle injections can be
+ * rendered before the first `message_start` arrives, so a counting Map (not a
+ * single slot) tracks how many optimistic renders are outstanding per signature.
+ */
+export function incrementInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): void {
+	ctx.optimisticInjectedSignatures.set(signature, (ctx.optimisticInjectedSignatures.get(signature) ?? 0) + 1);
+}
+
+/**
+ * Consume one pending injected optimistic render for `signature`. Decrements the
+ * count (deleting the key at zero) and returns whether one was outstanding.
+ */
+export function consumeInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): boolean {
+	const count = ctx.optimisticInjectedSignatures.get(signature) ?? 0;
+	if (count <= 0) return false;
+	if (count === 1) ctx.optimisticInjectedSignatures.delete(signature);
+	else ctx.optimisticInjectedSignatures.set(signature, count - 1);
+	return true;
+}

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-commands.ts

@@ -48,3 +48,23 @@ export function parseInThreadConfigCommand(text: string): ConfigCommandChange |
 			return undefined;
 	}
 }
+
+/**
+ * Parse a `/rich on|off` toggle. Returns `true`/`false` for a recognised
+ * on/off argument, or `undefined` otherwise (not a `/rich` command, or `/rich`
+ * with a missing/invalid argument). This is intentionally SEPARATE from
+ * `parseInThreadConfigCommand`: `/verbose`/`/redact` are producer/session config
+ * forwarded over the WS, whereas rich is Telegram-daemon delivery policy handled
+ * daemon-locally, so it never becomes a `config_command` frame or a user turn.
+ */
+export function parseRichToggleCommand(text: string): boolean | undefined {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith("/")) return undefined;
+	const [rawCommand, ...rest] = trimmed.slice(1).split(/\s+/);
+	// Accept the "/rich@botname" form Telegram appends in group chats.
+	if (rawCommand?.toLowerCase().split("@")[0] !== "rich") return undefined;
+	const arg = rest[0]?.toLowerCase();
+	if (arg === "on" || arg === "true" || arg === "1") return true;
+	if (arg === "off" || arg === "false" || arg === "0") return false;
+	return undefined;
+}

package/src/notifications/config.ts

@@ -16,6 +16,12 @@ export interface NotificationConfig {
 	redact: boolean;
 	verbosity: "lean" | "verbose";
 	idleTimeoutMs: number;
+	rich: {
+		enabled: boolean;
+	};
+	richDraft: {
+		enabled: boolean;
+	};
 }
 
 /** Read typed config from Settings. */
@@ -35,19 +41,50 @@ export function getNotificationConfig(settings: Settings): NotificationConfig {
 		redact: settings.get("notifications.redact"),
 		verbosity: settings.get("notifications.verbosity") === "verbose" ? "verbose" : "lean",
 		idleTimeoutMs: settings.get("notifications.daemon.idleTimeoutMs"),
+		rich: {
+			enabled: settings.get("notifications.telegram.rich.enabled"),
+		},
+		richDraft: {
+			enabled: settings.get("notifications.telegram.richDraft.enabled"),
+		},
 	};
 }
 
+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)))
 	);
 }
 
+/**
+ * Per-run opt-out for completion notifications, honored before settings lookups.
+ *
+ * `GJC_NOTIFY=off` (also `0` / `false`, case-insensitive) suppresses the
+ * completion notification surface for this process only. `config.yml` is
+ * untouched and child processes inherit the env var, which lets non-interactive
+ * fleet runs (`gjc -p --no-session`) stay silent even when a user-level/global
+ * completion notification configuration is enabled.
+ */
+export function completionNotifyDisabledByEnv(env: NodeJS.ProcessEnv): boolean {
+	const v = env.GJC_NOTIFY?.trim().toLowerCase();
+	return v === "off" || v === "0" || v === "false";
+}
+
 /** Resolve whether the notifications extension should be registered at SDK startup. */
 export function shouldRegisterNotificationsExtension(input: {
 	env: NodeJS.ProcessEnv;
@@ -60,6 +97,7 @@ export function shouldRegisterNotificationsExtension(input: {
 	currentAgentType?: string;
 }): boolean {
 	if ((input.taskDepth ?? 0) > 0 || input.parentTaskPrefix || input.currentAgentType) return false;
+	if (completionNotifyDisabledByEnv(input.env)) return false;
 	if (input.env.GJC_NOTIFICATIONS === "0") return false;
 	if (input.env.GJC_NOTIFICATIONS === "1" || input.env.GJC_NOTIFICATIONS_TOKEN) return true;
 	return input.cfg ? isGloballyConfigured(input.cfg) : false;
@@ -88,6 +126,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 +170,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;
 }

package/src/notifications/index.ts

@@ -33,8 +33,8 @@ import { registerAskAnswerSource } from "../tools/ask-answer-registry";
 import { registerTelegramFileSink } from "./attachment-registry";
 import {
 	getNotificationConfig,
-	isGloballyConfigured,
 	isSessionNotificationsEnabled,
+	isTelegramConfigured,
 	type NotificationConfig,
 	sessionTag,
 } from "./config";
@@ -90,6 +90,8 @@ export interface SessionCreateFrame {
 	target: SessionCreateTarget;
 	/** Reference to the daemon-written, once-consumed startup-prompt file. */
 	startupPromptRef?: string;
+	/** Model profile preset to activate for the spawned session (--mpreset). */
+	modelPreset?: string;
 }
 
 /** Close (hard-kill, history preserved) a session. */
@@ -350,6 +352,15 @@ interface SessionRuntime {
 	/** Assistant text already flushed before an ask this turn (turn-scoped dedupe
 	 * so turn_end does not re-emit the pre-ask lead-in). Reset each turn. */
 	preAskFlushedText?: string;
+	/** Live streaming: opt-in flag, monotonic per-turn ref, and emit throttle state. */
+	stream: boolean;
+	turnSeq?: number;
+	liveRef?: string;
+	lastLiveAt?: number;
+	lastLiveText?: string;
+	/** True between turn_end and the next turn_start: drops late async message_update
+	 * frames so a stale live edit can never be emitted after the finalized turn. */
+	turnClosed?: boolean;
 	/** Cancels the postmortem cleanup that emits `session_closed` on process teardown. */
 	cancelPostmortemCleanup: () => void;
 }
@@ -377,12 +388,41 @@ const defaultConfig: NotificationConfig = {
 	redact: false,
 	verbosity: "lean",
 	idleTimeoutMs: 60_000,
+	rich: { enabled: true },
+	richDraft: { enabled: false },
 };
 
 export function notificationsEnabled(): boolean {
 	return process.env.GJC_NOTIFICATIONS === "1" || Boolean(process.env.GJC_NOTIFICATIONS_TOKEN);
 }
 
+// Live streaming (opt-in): emit throttled non-finalized `turn_stream` frames as
+// the assistant message streams so remote clients can edit ONE message live. The
+// finalized frame (turn_end) carries the same messageRef and stays authoritative,
+// so a dropped live frame self-heals. Off unless GJC_NOTIFICATIONS_STREAM=1.
+function streamingEnabled(): boolean {
+	return process.env.GJC_NOTIFICATIONS_STREAM === "1";
+}
+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
+// 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;
+	return Math.min(TURN_TEXT_MAX_CEILING, Math.max(280, raw));
+}
 function resolveSettings(settingsOverride?: Settings): ResolvedSettings {
 	if (settingsOverride)
 		return { settings: settingsOverride, cfg: getNotificationConfig(settingsOverride), settingsAvailable: true };
@@ -708,6 +748,7 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 				cancelPostmortemCleanup: () => {},
 				redact,
 				verbosity,
+				stream: streamingEnabled(),
 				sessionTag: tag,
 				busy: false,
 				pendingInbound: new Set<number>(),
@@ -724,7 +765,7 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 			});
 			logger.info(`notifications: serving session ${id} at ${endpoint.url} (unattended=${unattended})`);
 
-			if (settingsAvailable && settings && isGloballyConfigured(cfg)) {
+			if (settingsAvailable && settings && isTelegramConfigured(cfg)) {
 				try {
 					await ensureTelegramDaemonRunning({ settings, cwd: ctx.cwd, sessionId: id });
 				} catch (e) {
@@ -963,7 +1004,10 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 	api.on("turn_start", (_event, ctx) => {
 		const id = sessionId(ctx);
 		const rt = runtimes.get(id);
-		if (!rt || rt.pendingInbound.size === 0) return;
+		if (!rt) return;
+		// A new turn is live: re-open the live-stream window (see turnClosed).
+		rt.turnClosed = false;
+		if (rt.pendingInbound.size === 0) return;
 		for (const updateId of rt.pendingInbound) {
 			try {
 				rt.server.pushFrame(JSON.stringify({ type: "inbound_ack", sessionId: id, updateId, state: "consumed" }));
@@ -1059,11 +1103,29 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 	// rate-limit pool before sending to Telegram.
 	// Push the in-flight turn's assistant text as a finalized turn_stream, deduped
 	// against what was already flushed for this turn (the pre-ask lead-in).
-	const flushTurnText = (rt: SessionRuntime, id: string, text: string | undefined): void => {
+	const flushTurnText = (rt: SessionRuntime, id: string, text: string | undefined, finalAnswer: boolean): void => {
 		if (!text || text === rt.preAskFlushedText) return;
 		rt.preAskFlushedText = text;
+		// Decision A: a stream-enabled turn must finalize as an in-place edit of ONE
+		// live message, never a fresh (rich-promotable) send. If live frames were
+		// async-queued and none landed before this flush, allocate the per-turn ref
+		// now so the finalized frame always carries a messageRef → the daemon keeps it
+		// editable (HTML edit) and never rich-promotes a streamed final.
+		if (finalAnswer && rt.stream && rt.liveRef === undefined) {
+			rt.turnSeq = (rt.turnSeq ?? 0) + 1;
+			rt.liveRef = String(rt.turnSeq);
+		}
 		try {
-			rt.server.pushFrame(JSON.stringify({ type: "turn_stream", sessionId: id, phase: "finalized", text }));
+			rt.server.pushFrame(
+				JSON.stringify({
+					type: "turn_stream",
+					sessionId: id,
+					phase: "finalized",
+					finalAnswer,
+					text,
+					...(rt.liveRef ? { messageRef: rt.liveRef } : {}),
+				}),
+			);
 		} catch (e) {
 			logger.warn(`notifications: pushFrame (turn) failed: ${String(e)}`);
 		}
@@ -1080,19 +1142,53 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 		const id = sessionId(ctx);
 		const rt = runtimes.get(id);
 		if (!rt || rt.redact) return;
-		flushTurnText(rt, id, rt.currentTurnText);
+		flushTurnText(rt, id, rt.currentTurnText, false);
 	});
 
 	api.on("turn_end", (event, ctx) => {
 		const id = sessionId(ctx);
 		const rt = runtimes.get(id);
 		if (!rt) return;
-		const text = rt.redact ? undefined : summaryFromMessage(event.message, 3500);
-		if (text) flushTurnText(rt, id, text);
+		const text = rt.redact ? undefined : summaryFromMessage(event.message, turnTextMax());
+		if (text) flushTurnText(rt, id, text, true);
 		// Reset per-turn streaming state so the next turn starts fresh and a later
 		// turn with identical text is not falsely deduped.
 		rt.currentTurnText = undefined;
 		rt.preAskFlushedText = undefined;
+		rt.liveRef = undefined;
+		// Close the live-stream window: any message_update queued after turn_end is
+		// dropped so it can never emit a stale live edit past the finalized turn.
+		rt.turnClosed = true;
+		rt.lastLiveAt = undefined;
+		rt.lastLiveText = undefined;
+	});
+
+	// Live streaming (opt-in): push throttled in-progress assistant text as
+	// non-finalized turn_stream frames so remote clients edit one message as the
+	// turn streams. The finalized frame (turn_end) carries the same messageRef and
+	// lands the authoritative text. Suppressed under redaction.
+	api.on("message_update", (event, ctx) => {
+		const id = sessionId(ctx);
+		const rt = runtimes.get(id);
+		if (!rt?.stream || rt.redact || rt.turnClosed) return;
+		if ((event.message as { role?: unknown }).role !== "assistant") return;
+		if (rt.liveRef === undefined) {
+			rt.turnSeq = (rt.turnSeq ?? 0) + 1;
+			rt.liveRef = String(rt.turnSeq);
+		}
+		const now = Date.now();
+		if (now - (rt.lastLiveAt ?? 0) < streamIntervalMs()) return;
+		const text = summaryFromMessage(event.message, 3500);
+		if (!text || text === rt.lastLiveText) return;
+		rt.lastLiveAt = now;
+		rt.lastLiveText = text;
+		try {
+			rt.server.pushFrame(
+				JSON.stringify({ type: "turn_stream", sessionId: id, phase: "live", text, messageRef: rt.liveRef }),
+			);
+		} catch (e) {
+			logger.warn(`notifications: pushFrame (live) failed: ${String(e)}`);
+		}
 	});
 
 	// Stream agent-produced images (computer/browser/tool screenshots) as
@@ -1106,7 +1202,7 @@ export function createNotificationsExtension(api: ExtensionAPI, options: { setti
 		// flush can emit it before the ask prompt. Role-scoped: message_end also
 		// fires for the user prompt, which must never be mirrored back as turn output.
 		if ((event.message as { role?: unknown }).role === "assistant") {
-			const turnText = summaryFromMessage(event.message, 3500);
+			const turnText = summaryFromMessage(event.message, turnTextMax());
 			if (turnText) rt.currentTurnText = turnText;
 		}
 		for (const img of imageAttachmentsFromMessage(event.message)) {

package/src/notifications/lifecycle-commands.ts

@@ -31,7 +31,7 @@ function normalizeLifecycleCommandToken(
 
 /** A parsed, validated lifecycle command (transport identity added by caller). */
 export type ParsedLifecycleCommand =
-	| { kind: "create"; target: SessionCreateTarget }
+	| { kind: "create"; target: SessionCreateTarget; modelPreset?: string }
 	| { kind: "close"; target: SessionCloseTarget }
 	| { kind: "resume"; target: SessionResumeTarget }
 	| { kind: "recent"; which: "create" | "resume" | "all" }
@@ -41,9 +41,9 @@ export type ParsedLifecycleCommand =
 
 const USAGE = [
 	"Session commands:",
-	"/session_create path <dir>",
-	"/session_create worktree <repo> <branch>",
-	"/session_create dir <newdir>",
+	"/session_create path <dir> [--mpreset <profile>]",
+	"/session_create worktree <repo> <branch> [--mpreset <profile>]",
+	"/session_create dir <newdir> [--mpreset <profile>]",
 	"/session_close <sessionId>",
 	"/session_resume <sessionId|prefix>",
 	"/session_recent [create|resume]",
@@ -69,6 +69,23 @@ export function isLifecycleCommandText(
 	return normalizeLifecycleCommandToken(rawCommand ?? "", ctx) !== undefined;
 }
 
+/** Extract `--mpreset <name>` (or `--mpreset=<name>`) from args, returning remaining positional args. */
+function extractModelPreset(args: string[]): { positional: string[]; modelPreset?: string } {
+	const positional: string[] = [];
+	let modelPreset: string | undefined;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i]!;
+		if (arg === "--mpreset" && i + 1 < args.length) {
+			modelPreset = args[++i]!;
+		} else if (arg.startsWith("--mpreset=")) {
+			modelPreset = arg.slice("--mpreset=".length);
+		} else {
+			positional.push(arg);
+		}
+	}
+	return { positional, modelPreset };
+}
+
 /**
  * Parse a paired-chat message into a lifecycle command. Returns `none` for
  * non-lifecycle text, `usage`/`reject` for malformed input (no side effect), or
@@ -121,29 +138,33 @@ export function parseLifecycleCommand(
 		return { kind: "resume", target: { sessionIdOrPrefix: idOrPrefix } };
 	}
 
-	// /session_create <kind> ...
-	const kind = args[0];
+	// /session_create <kind> ... [--mpreset <profile>]
+	const { positional, modelPreset } = extractModelPreset(args);
+	if (modelPreset !== undefined && !isSafeIdentifier(modelPreset)) {
+		return { kind: "reject", reason: "invalid_target", message: `Invalid model preset name.\n\n${USAGE}` };
+	}
+	const kind = positional[0];
 	if (kind === "path") {
-		if (args.length !== 2) return { kind: "usage", message: USAGE };
-		const p = normalizeLifecyclePath(args[1]!);
+		if (positional.length !== 2) return { kind: "usage", message: USAGE };
+		const p = normalizeLifecyclePath(positional[1]!);
 		if (!p) return { kind: "reject", reason: "invalid_target", message: `Invalid path.\n\n${USAGE}` };
-		return { kind: "create", target: { kind: "existing_path", path: p } };
+		return { kind: "create", target: { kind: "existing_path", path: p }, modelPreset };
 	}
 	if (kind === "dir") {
-		if (args.length !== 2) return { kind: "usage", message: USAGE };
-		const p = normalizeLifecyclePath(args[1]!);
+		if (positional.length !== 2) return { kind: "usage", message: USAGE };
+		const p = normalizeLifecyclePath(positional[1]!);
 		if (!p) return { kind: "reject", reason: "invalid_target", message: `Invalid dir.\n\n${USAGE}` };
-		return { kind: "create", target: { kind: "plain_dir", path: p } };
+		return { kind: "create", target: { kind: "plain_dir", path: p }, modelPreset };
 	}
 	if (kind === "worktree") {
-		if (args.length !== 3) return { kind: "usage", message: USAGE };
-		const repo = normalizeLifecyclePath(args[1]!);
-		const branch = args[2]!;
+		if (positional.length !== 3) return { kind: "usage", message: USAGE };
+		const repo = normalizeLifecyclePath(positional[1]!);
+		const branch = positional[2]!;
 		if (!repo) return { kind: "reject", reason: "invalid_target", message: `Invalid repo path.\n\n${USAGE}` };
 		if (!isSafeBranch(branch)) {
 			return { kind: "reject", reason: "invalid_target", message: `Invalid branch name.\n\n${USAGE}` };
 		}
-		return { kind: "create", target: { kind: "worktree", repo, branch } };
+		return { kind: "create", target: { kind: "worktree", repo, branch }, modelPreset };
 	}
 	return { kind: "usage", message: USAGE };
 }