@gajae-code/coding-agent 0.10.0 → 0.10.2

package/src/modes/components/status-line.ts

@@ -1,6 +1,5 @@
 import * as fs from "node:fs";
-import type { AgentMessage } from "@gajae-code/agent-core";
-import { estimateMessageTokensHeuristic } from "@gajae-code/agent-core/compaction";
+
 import { type Component, truncateToWidth, visibleWidth } from "@gajae-code/tui";
 import { formatCount, getProjectDir } from "@gajae-code/utils";
 import { $ } from "bun";
@@ -13,7 +12,6 @@ import * as git from "../../utils/git";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../../utils/session-color";
 import { EMPTY_JOBS_SNAPSHOT, type JobsSnapshot } from "../jobs-observer";
 import { sanitizeStatusText } from "../shared";
-import { computeNonMessageTokens } from "../utils/context-usage";
 import { renderSkillHudBar } from "./skill-hud/render";
 import {
 	canReuseCachedPr,
@@ -70,104 +68,6 @@ interface CollectedStatusSegments {
 	rightCapWidth: number;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Per-message token cache
-// ═══════════════════════════════════════════════════════════════════════════
-
-/**
- * Symbol-keyed sidecar tagged onto each `AgentMessage` to memoize its
- * `estimateMessageTokensHeuristic` result. Keyed by message identity (the object itself);
- * a cheap content fingerprint detects in-place mutations (post-hoc error
- * attachment, retry-truncated branch rebuild, etc.) and forces recompute.
- *
- * Cache lives on the message — multiple `StatusLineComponent` instances
- * share it for free, and entries collect with the message itself when the
- * conversation is replaced or compacted.
- */
-const kTokenCache = Symbol("statusLine.tokenCache");
-interface TaggedMessage {
-	[kTokenCache]?: { fingerprint: string; tokens: number };
-}
-
-/**
- * Cheap structural fingerprint mirroring `estimateMessageTokensHeuristic`'s content walk.
- * O(blocks) — only reads string `.length` and primitives, never copies or
- * serializes content. Any in-place mutation that alters total tokenized
- * content also alters one of the byte-length sums or block counts captured
- * here, forcing the cached heuristic token value to be recomputed.
- */
-function messageFingerprint(msg: AgentMessage): string {
-	const role = (msg as { role?: string }).role ?? "";
-	const ts = (msg as { timestamp?: number }).timestamp ?? 0;
-	let textLen = 0;
-	let blocks = 0;
-	let images = 0;
-	if (role === "bashExecution") {
-		const b = msg as { command?: unknown; output?: unknown };
-		if (typeof b.command === "string") textLen += b.command.length;
-		if (typeof b.output === "string") textLen += b.output.length;
-	} else if (role === "user") {
-		const content = (msg as { content?: unknown }).content;
-		if (typeof content === "string") {
-			textLen += content.length;
-		} else if (Array.isArray(content)) {
-			blocks = content.length;
-			for (const block of content) {
-				if (block?.type === "text" && typeof block.text === "string") textLen += block.text.length;
-			}
-		}
-	} else if (role === "assistant") {
-		const content = (msg as { content?: unknown }).content;
-		if (Array.isArray(content)) {
-			blocks = content.length;
-			for (const block of content) {
-				if (!block || typeof block !== "object") continue;
-				const b = block as { type?: string; text?: string; thinking?: string; name?: string; arguments?: unknown };
-				if (b.type === "text" && typeof b.text === "string") textLen += b.text.length;
-				else if (b.type === "thinking" && typeof b.thinking === "string") textLen += b.thinking.length;
-				else if (b.type === "toolCall") {
-					if (typeof b.name === "string") textLen += b.name.length;
-					// Argument bytes vary; a length proxy is enough to detect in-place edits.
-					textLen += b.arguments === undefined ? 0 : JSON.stringify(b.arguments).length;
-				}
-			}
-		}
-	} else if (role === "toolResult" || role === "hookMessage") {
-		const content = (msg as { content?: unknown }).content;
-		if (typeof content === "string") {
-			textLen += content.length;
-		} else if (Array.isArray(content)) {
-			blocks = content.length;
-			for (const block of content) {
-				if (!block || typeof block !== "object") continue;
-				const b = block as { type?: string; text?: string };
-				if (b.type === "text" && typeof b.text === "string") textLen += b.text.length;
-				else if (b.type === "image") images++;
-			}
-		}
-	} else if (role === "branchSummary" || role === "compactionSummary") {
-		const s = (msg as { summary?: unknown }).summary;
-		if (typeof s === "string") textLen += s.length;
-	}
-	return `${role}:${ts}:${textLen}:${blocks}:${images}`;
-}
-
-/**
- * Token count for a single message, using the per-message sidecar cache.
- * The caller MUST skip caching for the last message during streaming —
- * it may still be growing and its tokens belong recomputed each refresh.
- */
-function tokensForMessage(msg: AgentMessage): number {
-	const fp = messageFingerprint(msg);
-	const tagged = msg as TaggedMessage;
-	const cached = tagged[kTokenCache];
-	if (cached && cached.fingerprint === fp) return cached.tokens;
-	const tokens = estimateMessageTokensHeuristic(msg);
-	tagged[kTokenCache] = { fingerprint: fp, tokens };
-	return tokens;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
 // StatusLineComponent
 // ═══════════════════════════════════════════════════════════════════════════
 
@@ -217,20 +117,6 @@ export class StatusLineComponent implements Component {
 	#cachedUsage: SegmentContext["usage"] = null;
 	#usageFetchedAt = 0;
 	#usageInFlight = false;
-	// Context breakdown — incremental cache. Replaces the previous 2-second
-	// TTL design (which re-walked every message on each refresh and produced
-	// ~1.1 s sync freezes on 2,000+ message sessions because `updateEditorTopBorder`
-	// is called on every agent event in event-controller). The new scheme
-	// caches by message-object identity (a Symbol-keyed sidecar on each
-	// message) plus a cheap content fingerprint, so in-place mutations of
-	// an existing message (post-hoc error attachment, retry-truncated
-	// branch rebuild, replaceMessages with the same length) are detected
-	// and recomputed.
-	// Cached non-message total (system prompt + tools + skills). Invalidated
-	// when the inputs-identity fingerprint changes (model swap, skill toggle,
-	// tool registration).
-	#nonMessageTokensCache: number | undefined;
-	#nonMessageInputsKey: string | undefined;
 
 	constructor(
 		private readonly session: AgentSession,
@@ -618,57 +504,6 @@ export class StatusLineComponent implements Component {
 		return windows.length > 0 ? { windows } : null;
 	}
 
-	/**
-	 * Compute the (cached) used-tokens / context-window totals for the
-	 * status-line context% segment. Exposed (non-private) so unit tests can
-	 * verify the incremental-cache invariants; not part of any external
-	 * API.
-	 */
-	getCachedContextBreakdown(): { usedTokens: number; contextWindow: number } {
-		const messages = this.session.messages ?? [];
-		const contextWindow = this.session.model?.contextWindow ?? 0;
-
-		// 1) Non-message tokens (system prompt + tools + skills). Refresh only
-		//    when the inputs identity fingerprint changes — usually never
-		//    during a streaming turn. ~10-30 ms when it does refresh.
-		const inputsKey = this.#computeNonMessageInputsKey();
-		if (this.#nonMessageTokensCache === undefined || this.#nonMessageInputsKey !== inputsKey) {
-			this.#nonMessageTokensCache = computeNonMessageTokens(this.session);
-			this.#nonMessageInputsKey = inputsKey;
-		}
-
-		// 2) Message tokens — incremental. The sidecar cache lives on the
-		//    message object itself (Symbol-keyed), keyed by identity and
-		//    validated by a cheap content fingerprint. Mutations that
-		//    replace messages (replaceMessages, branch rebuild, compaction)
-		//    yield fresh objects → cache miss → recompute. In-place
-		//    mutations on the same object are caught by fingerprint
-		//    mismatch. The LAST message is always recomputed because it
-		//    may still be growing during streaming.
-		let messagesTokens = 0;
-		const lastIdx = messages.length - 1;
-		for (let i = 0; i < messages.length; i++) {
-			messagesTokens += i === lastIdx ? estimateMessageTokensHeuristic(messages[i]) : tokensForMessage(messages[i]);
-		}
-
-		const usedTokens = this.#nonMessageTokensCache + messagesTokens;
-		return { usedTokens, contextWindow };
-	}
-
-	/**
-	 * Build an identity fingerprint for the non-message inputs (system prompt,
-	 * tools, skills). When this changes, the non-message token cache must be
-	 * recomputed. Cheap: just lengths + first-string-length. Doesn't need to
-	 * be cryptographically unique — only stable for the same inputs.
-	 */
-	#computeNonMessageInputsKey(): string {
-		const sp = this.session.systemPrompt ?? [];
-		const tools = this.session.agent?.state?.tools ?? [];
-		const skills = this.session.skills ?? [];
-		const modelId = this.session.model?.id ?? "";
-		return `${modelId}|${sp.length}:${sp[0]?.length ?? 0}|${tools.length}|${skills.length}`;
-	}
-
 	#buildSegmentContext(
 		width: number,
 		effectiveSettings: Required<
@@ -695,11 +530,9 @@ export class StatusLineComponent implements Component {
 			tokensPerSecond: this.#getTokensPerSecond(),
 		};
 
-		// Context usage — aligned with /context command so both surfaces report the same value
-		const breakdown = this.getCachedContextBreakdown();
-		const contextTokens = breakdown.usedTokens;
-		const contextWindow = breakdown.contextWindow || state.model?.contextWindow || 0;
-		const contextPercent = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
+		const contextUsage = this.session.getContextUsage?.();
+		const contextWindow = contextUsage?.contextWindow ?? state.model?.contextWindow ?? 0;
+		const contextPercent = contextUsage?.percent ?? null;
 		// Suppress the inline model percentage when a standalone context_pct
 		// segment is also rendered, so the value is not shown twice.
 		const contextPctSegmentActive =

package/src/modes/controllers/extension-ui-controller.ts

@@ -50,6 +50,11 @@ export class ExtensionUiController {
 		overlay?.hide();
 	}
 
+	/** Re-mount the pet-aware composer after a transient hook UI closes. */
+	#restoreComposerEditor(): void {
+		this.ctx.restoreComposer();
+	}
+
 	/**
 	 * Initialize the hook system with TUI-based UI context.
 	 */
@@ -578,7 +583,7 @@ export class ExtensionUiController {
 						shutdown: () => {
 							// Signal shutdown request
 						},
-						getSystemPrompt: () => this.ctx.session.systemPrompt,
+						getSystemPrompt: () => [...this.ctx.session.systemPrompt],
 					});
 				} catch (err) {
 					this.showToolError(registeredTool.definition.name, err instanceof Error ? err.message : String(err));
@@ -723,8 +728,7 @@ export class ExtensionUiController {
 	 */
 	hideHookSelector(): void {
 		this.ctx.hookSelector?.dispose();
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.#restoreComposerEditor();
 		this.ctx.hookSelector = undefined;
 		this.ctx.ui.setFocus(this.ctx.editor);
 		this.ctx.ui.requestRender();
@@ -785,8 +789,7 @@ export class ExtensionUiController {
 	 */
 	hideHookInput(): void {
 		this.ctx.hookInput?.dispose();
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.#restoreComposerEditor();
 		this.ctx.hookInput = undefined;
 		this.ctx.ui.setFocus(this.ctx.editor);
 		this.ctx.ui.requestRender();
@@ -835,8 +838,7 @@ export class ExtensionUiController {
 	 * Hide the hook editor.
 	 */
 	hideHookEditor(): void {
-		this.ctx.editorContainer.clear();
-		this.ctx.editorContainer.addChild(this.ctx.editor);
+		this.#restoreComposerEditor();
 		this.ctx.hookEditor = undefined;
 		this.ctx.ui.setFocus(this.ctx.editor);
 		this.ctx.ui.requestRender();
@@ -879,8 +881,7 @@ export class ExtensionUiController {
 			closed = true;
 			this.#clearActiveHookCustom();
 			if (!options?.overlay) {
-				this.ctx.editorContainer.clear();
-				this.ctx.editorContainer.addChild(this.ctx.editor);
+				this.#restoreComposerEditor();
 				this.ctx.editor.setText(savedText);
 			}
 			this.ctx.ui.setFocus(this.ctx.editor);

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

@@ -434,13 +434,14 @@ export class InputController {
 			}
 
 			const runner = this.ctx.session.extensionRunner;
+			const pendingImages = this.ctx.pendingImages;
 			let inputImages = this.#visiblePendingImagesForText(text);
 
 			if (runner?.hasHandlers("input")) {
 				const result = await runner.emitInput(text, inputImages, "interactive");
 				if (result?.handled) {
 					this.ctx.editor.setText("");
-					this.ctx.pendingImages = [];
+					this.#clearPendingImagesIfOwnedBy(pendingImages);
 					return;
 				}
 				if (result?.text !== undefined) {
@@ -530,7 +531,7 @@ export class InputController {
 				this.ctx.editor.addToHistory(text);
 				this.ctx.editor.setText("");
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
+				this.#clearPendingImagesIfOwnedBy(pendingImages);
 				// Record the signature so the queued message's eventual delivery
 				// (a user-role `message_start` event) leaves any draft the user has
 				// typed since queuing intact. Same protection as #783, applied to
@@ -582,7 +583,7 @@ export class InputController {
 			if (this.ctx.onInputCallback) {
 				// Include any pending images from clipboard paste
 				const images = inputImages && inputImages.length > 0 ? [...inputImages] : undefined;
-				this.ctx.pendingImages = [];
+				this.#clearPendingImagesIfOwnedBy(pendingImages);
 
 				// Render user message immediately, then let session events catch up
 				const submission = this.ctx.startPendingSubmission({ text, images });
@@ -1104,11 +1105,14 @@ export class InputController {
 				return false;
 			}
 
-			this.ctx.pendingImages.push({
-				type: "image",
-				data: image.data,
-				mimeType: image.mimeType,
-			});
+			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();
@@ -1151,10 +1155,33 @@ export class InputController {
 		return images.length > 0 ? images : undefined;
 	}
 
+	#clearPendingImagesIfOwnedBy(pendingImages: InteractiveModeContext["pendingImages"]): void {
+		if (this.ctx.pendingImages === pendingImages) {
+			this.ctx.pendingImages = [];
+		}
+	}
+
 	#clearPendingImagesIfPlaceholdersRemoved(text: string): void {
 		if (this.ctx.pendingImages.length === 0 || IMAGE_PLACEHOLDER_PRESENT_PATTERN.test(text)) {
 			return;
 		}
+		// Editor submit resets the composer and emits onChange("") before onSubmit(result).
+		// Defer the empty-buffer clear so the submit handler can still resolve image
+		// placeholders against pendingImages, while manual clears still drop stale images.
+		if (text.length === 0) {
+			const pendingImages = this.ctx.pendingImages;
+			const pendingImageCount = pendingImages.length;
+			queueMicrotask(() => {
+				if (
+					this.ctx.pendingImages === pendingImages &&
+					pendingImages.length === pendingImageCount &&
+					this.ctx.editor.getText().length === 0
+				) {
+					this.ctx.pendingImages = [];
+				}
+			});
+			return;
+		}
 		this.ctx.pendingImages = [];
 	}
 
@@ -1185,11 +1212,14 @@ export class InputController {
 					}
 				}
 
-				this.ctx.pendingImages.push({
-					type: "image",
-					data: imageData.data,
-					mimeType: imageData.mimeType,
-				});
+				this.ctx.pendingImages = [
+					...this.ctx.pendingImages,
+					{
+						type: "image",
+						data: imageData.data,
+						mimeType: imageData.mimeType,
+					},
+				];
 				this.ctx.editor.insertText(`${this.#nextImagePlaceholder()} `);
 				this.ctx.ui.requestRender();
 				return true;

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

@@ -79,6 +79,7 @@ import { HistorySearchComponent } from "../components/history-search";
 import { JobsOverlayComponent } from "../components/jobs-overlay";
 import { ModelSelectorComponent } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
+import { isPetAvailable } from "../components/pet-capability";
 import { PetSelectorComponent } from "../components/pet-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import {
@@ -492,6 +493,7 @@ export class SelectorController {
 						availableThemes,
 						availableModelProfiles: [...this.ctx.session.modelRegistry.getModelProfiles().keys()],
 						cwd: getProjectDir(),
+						petAvailable: isPetAvailable(),
 					},
 					{
 						onChange: (id, value) => this.handleSettingChange(id, value),
@@ -514,6 +516,7 @@ export class SelectorController {
 						onPetPreview: mode => {
 							this.ctx.previewPetMode(mode as PetMode);
 						},
+						onPetCommit: mode => this.ctx.commitPetPreviewMode(mode as PetMode),
 						onStatusLinePreview: previewSettings => {
 							// Update status line with preview settings
 							this.ctx.statusLine.updateSettings({
@@ -591,6 +594,7 @@ export class SelectorController {
 	showPetSelector(): void {
 		const stored = settings.get("pet.mode");
 		const initial: PetMode = isPetMode(stored) ? stored : "off";
+		const available = isPetAvailable();
 		this.showSelector(done => {
 			// Live-preview via previewMode (no editor re-mount, so the overlay stays);
 			// Enter commits + persists, Esc restores the initial skin.
@@ -607,6 +611,7 @@ export class SelectorController {
 				mode => {
 					this.ctx.previewPetMode(mode);
 				},
+				available,
 			);
 			return { component: selector, focus: selector.getSelectList() };
 		});
@@ -762,12 +767,6 @@ export class SelectorController {
 				});
 				break;
 			}
-			case "pet.mode":
-				// The settings submenu already persisted the value; apply it to the live
-				// widget via previewMode (the settings overlay is still open, so a full
-				// re-mount would tear it down — restoreComposer re-mounts on close).
-				this.ctx.previewPetMode(value as PetMode);
-				break;
 			case "symbolPreset": {
 				setSymbolPreset(value as "unicode" | "nerd" | "ascii").then(() => {
 					this.ctx.statusLine.invalidate();
@@ -985,21 +984,14 @@ export class SelectorController {
 								assignments,
 							});
 							if (!materializedProfile) {
-								const overrides = this.ctx.settings.get("task.agentModelOverrides");
-								const nextOverrides = { ...overrides };
-								let writesOverrides = false;
 								for (const targetRole of targetRoles) {
 									const target = GJC_MODEL_ASSIGNMENT_TARGETS[targetRole];
 									if (target.settingsPath === "modelRoles") {
 										this.ctx.settings.setModelRole(targetRole, value);
 									} else {
-										nextOverrides[targetRole] = value;
-										writesOverrides = true;
+										this.ctx.settings.setAgentModelOverride(targetRole, value);
 									}
 								}
-								if (writesOverrides) {
-									this.ctx.settings.set("task.agentModelOverrides", nextOverrides);
-								}
 							}
 							modelSelector.refreshRoleAssignments({
 								currentModel: this.ctx.session.model,
@@ -1069,10 +1061,7 @@ export class SelectorController {
 								if (target.settingsPath === "modelRoles") {
 									this.ctx.settings.setModelRole(role, value);
 								} else {
-									this.ctx.settings.set("task.agentModelOverrides", {
-										...this.ctx.settings.get("task.agentModelOverrides"),
-										[role]: value,
-									});
+									this.ctx.settings.setAgentModelOverride(role, value);
 								}
 							}
 							modelSelector.refreshRoleAssignments({

package/src/modes/interactive-mode.ts

@@ -21,6 +21,7 @@ import {
 	getRenderCacheRetainedBytes,
 	Loader,
 	Markdown,
+	onImageProtocolChanged,
 	ProcessTerminal,
 	Spacer,
 	Text,
@@ -86,6 +87,12 @@ import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import { IrcSplitViewComponent } from "./components/irc-sidebar";
+import {
+	getPetUnavailableWarning,
+	isPetAvailable,
+	isPetCapabilityProbePending,
+	warnWhenPetCapabilitySettled,
+} from "./components/pet-capability";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import {
@@ -387,6 +394,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	#baseReservedSlashCommandNames: Set<string> = new Set();
 	#cleanupUnsubscribe?: () => void;
 	#subprocessTeardownUnsubscribe?: () => void;
+	#petProtocolUnsubscribe?: () => void;
+	/** Cancels a startup pet-unavailable warning still awaiting probe settlement. */
+	#petUnavailableWarningDisposer?: () => void;
 	readonly #version: string;
 	readonly #changelogMarkdown: string | undefined;
 	#planModePreviousTools: string[] | undefined;
@@ -615,8 +625,35 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.hookWidgetContainerBelow);
 		this.ui.setBottomPinnedComponent(this.statusLine);
 		this.ui.setFocus(this.editor);
+		this.petWidget?.dispose();
 		this.petWidget = this.#createPetWidget(this.editor);
-		this.petWidget.setMode(settings.get("pet.mode"));
+		const configuredPetMode = settings.get("pet.mode");
+		this.petWidget.setMode(configuredPetMode);
+		// The async sixel capability probe can enable graphics after the saved
+		// pet mode was applied and dropped (no protocol yet at startup).
+		// Re-apply the configured mode when capability arrives so the pet
+		// appears without the user re-running /pet.
+		this.#petProtocolUnsubscribe?.();
+		this.#petProtocolUnsubscribe = onImageProtocolChanged(protocol => {
+			if (!protocol) return;
+			const saved = settings.get("pet.mode");
+			if (saved !== "off" && this.petWidget && this.petWidget.mode === "off") {
+				this.petWidget.setMode(saved);
+			}
+		});
+		if (configuredPetMode !== "off" && !isPetAvailable()) {
+			// The async Sixel capability probe (started by TUI.start()) may still
+			// enable graphics; warn only once the capability question is settled
+			// so a supported terminal is never told it is incompatible.
+			this.#petUnavailableWarningDisposer?.();
+			this.#petUnavailableWarningDisposer = warnWhenPetCapabilitySettled({
+				probePending: isPetCapabilityProbePending(),
+				onUnavailable: () => {
+					this.showStatus(theme.fg("warning", getPetUnavailableWarning()), { dim: false });
+					this.ui.requestRender();
+				},
+			});
+		}
 
 		this.#inputController.setupKeyHandlers();
 		this.#inputController.setupEditorSubmitHandler();
@@ -1064,10 +1101,26 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.editor.setTopBorder(undefined);
 	}
 
-	setPetMode(mode: PetMode): void {
-		this.petWidget?.setMode(mode);
+	/**
+	 * Single result-returning pet commit policy shared by every entry path
+	 * (`/pet`, the pet selector, and the Settings submenu). Capability is
+	 * rechecked immediately before mutation, and the preference persists only
+	 * after the commit is accepted.
+	 */
+	#commitPetMode(mode: PetMode, apply: (mode: PetMode) => void): boolean {
+		if (mode !== "off" && !isPetAvailable()) {
+			this.showStatus(theme.fg("warning", getPetUnavailableWarning()), { dim: false });
+			this.ui.requestRender();
+			return false;
+		}
+		apply(mode);
 		settings.set("pet.mode", mode);
 		this.ui.requestRender();
+		return true;
+	}
+
+	setPetMode(mode: PetMode): boolean {
+		return this.#commitPetMode(mode, next => this.petWidget?.setMode(next));
 	}
 
 	previewPetMode(mode: PetMode): void {
@@ -1075,6 +1128,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.requestRender();
 	}
 
+	commitPetPreviewMode(mode: PetMode): boolean {
+		return this.#commitPetMode(mode, next => this.petWidget?.commitPreviewMode(next));
+	}
+
 	restoreComposer(): void {
 		if (this.petWidget) {
 			this.petWidget.remountComposer();
@@ -2074,6 +2131,10 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	stop(): void {
+		this.#petProtocolUnsubscribe?.();
+		this.#petProtocolUnsubscribe = undefined;
+		this.#petUnavailableWarningDisposer?.();
+		this.#petUnavailableWarningDisposer = undefined;
 		this.petWidget?.dispose();
 		this.petWidget = undefined;
 		if (this.loadingAnimation) {
@@ -2207,7 +2268,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		nextEditor.setText(previousText);
 		previousEditor.dispose();
 
-		const petMode = this.petWidget?.mode ?? settings.get("pet.mode");
+		const petMode = settings.get("pet.mode");
 		this.petWidget?.dispose();
 
 		this.editorContainer.clear();