@oh-my-pi/pi-coding-agent 15.7.1 → 15.7.3

package/src/modes/gradient-highlight.ts

@@ -1,5 +1,11 @@
+import { maskNonProse } from "./markdown-prose";
 import { theme } from "./theme/theme";
 
+/** A gradient keyword highlighter. `resetTo` is the SGR foreground sequence
+ *  re-emitted after each painted keyword so surrounding text keeps its color;
+ *  it defaults to a plain foreground reset (editor / default-colored text). */
+export type KeywordHighlighter = (text: string, resetTo?: string) => string;
+
 const FG_RESET = "\x1b[39m";
 
 /** Declarative spec for {@link createGradientHighlighter}. */
@@ -25,7 +31,7 @@ export interface GradientHighlightSpec {
  * untouched when `probe` does not match. The palette is compiled lazily and
  * memoized per active color mode.
  */
-export function createGradientHighlighter(spec: GradientHighlightSpec): (text: string) => string {
+export function createGradientHighlighter(spec: GradientHighlightSpec): KeywordHighlighter {
 	const { probe, highlight, stops, hue, saturation = 90, lightness = 62 } = spec;
 
 	let cachedMode: string | undefined;
@@ -45,8 +51,8 @@ export function createGradientHighlighter(spec: GradientHighlightSpec): (text: s
 		return next;
 	};
 
-	/** Paint each character of `word` with the next gradient stop, resetting fg after. */
-	const paint = (word: string): string => {
+	/** Paint each character of `word` with the next gradient stop, restoring `resetTo` after. */
+	const paint = (word: string, resetTo: string): string => {
 		const stopsArr = palette();
 		const n = word.length;
 		let out = "";
@@ -60,11 +66,22 @@ export function createGradientHighlighter(spec: GradientHighlightSpec): (text: s
 			}
 			out += word[i];
 		}
-		return `${out}${FG_RESET}`;
+		return `${out}${resetTo}`;
 	};
 
-	return (text: string): string => {
+	return (text: string, resetTo: string = FG_RESET): string => {
 		if (!probe.test(text)) return text;
-		return text.replace(highlight, paint);
+		// Match against a code/markup-masked copy so keywords inside code spans,
+		// fenced blocks, or XML sections never paint; indices still address `text`.
+		const masked = maskNonProse(text);
+		let out = "";
+		let last = 0;
+		for (const m of masked.matchAll(highlight)) {
+			const start = m.index ?? 0;
+			const end = start + m[0].length;
+			out += text.slice(last, start) + paint(text.slice(start, end), resetTo);
+			last = end;
+		}
+		return out + text.slice(last);
 	};
 }

package/src/modes/interactive-mode.ts

@@ -62,6 +62,7 @@ import type { AgentSession, AgentSessionEvent, ResolvedRoleModel } from "../sess
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import { getRecentSessions } from "../session/session-manager";
+import type { ShakeMode } from "../session/shake-types";
 import { formatDuration } from "../slash-commands/helpers/format";
 import { STTController, type SttState } from "../stt";
 import type { LspStartupServerInfo } from "../tools";
@@ -91,6 +92,7 @@ import { EventController } from "./controllers/event-controller";
 import { ExtensionUiController } from "./controllers/extension-ui-controller";
 import { InputController } from "./controllers/input-controller";
 import { MCPCommandController } from "./controllers/mcp-command-controller";
+import { OmfgController } from "./controllers/omfg-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
@@ -236,6 +238,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	statusContainer: Container;
 	todoContainer: Container;
 	btwContainer: Container;
+	omfgContainer: Container;
 	editor: CustomEditor;
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
@@ -315,6 +318,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	readonly #toolUiContextSetter: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
 
 	readonly #btwController: BtwController;
+	readonly #omfgController: OmfgController;
 	readonly #commandController: CommandController;
 	readonly #todoCommandController: TodoCommandController;
 	readonly #eventController: EventController;
@@ -368,6 +372,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.statusContainer = new Container();
 		this.todoContainer = new Container();
 		this.btwContainer = new Container();
+		this.omfgContainer = new Container();
 		this.editor = new CustomEditor(getEditorTheme());
 		this.editor.setUseTerminalCursor(this.ui.getShowHardwareCursor());
 		this.editor.setAutocompleteMaxVisible(settings.get("autocompleteMaxVisible"));
@@ -429,6 +434,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		this.#uiHelpers = new UiHelpers(this);
 		this.#btwController = new BtwController(this);
+		this.#omfgController = new OmfgController(this);
 		this.#extensionUiController = new ExtensionUiController(this);
 		this.#eventController = new EventController(this);
 		this.#commandController = new CommandController(this);
@@ -526,6 +532,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.ui.addChild(this.statusContainer);
 		this.ui.addChild(this.todoContainer);
 		this.ui.addChild(this.btwContainer);
+		this.ui.addChild(this.omfgContainer);
 		this.ui.addChild(this.statusLine); // Only renders hook statuses (main status in editor border)
 		this.ui.addChild(this.hookWidgetContainerAbove);
 		this.ui.addChild(this.editorContainer);
@@ -2034,16 +2041,20 @@ export class InteractiveMode implements InteractiveModeContext {
 				: "Approve and keep context";
 
 		// Model-tier slider: let the operator pick which configured role model
-		// (smol/default/slow/…) executes the approved plan. Left/right move it from
-		// any list position. Hidden when fewer than two role models resolve — a lone
-		// tier is no choice. `selectedTierIndex` tracks the live slider position.
+		// (smol/default/slow/…) executes the approved plan. The slider always starts
+		// on the `default` tier so execution defaults to the default model no matter
+		// which model drove the planning conversation. Left/right move it from there;
+		// hidden when fewer than two role models resolve — a lone tier is no choice.
+		// `selectedTierIndex` tracks the live slider position.
 		const cycle = this.session.getRoleModelCycle(this.session.settings.get("cycleOrder"));
-		let selectedTierIndex = cycle?.currentIndex ?? 0;
+		const defaultTierIndex = cycle ? cycle.models.findIndex(entry => entry.role === "default") : -1;
+		const startTierIndex = defaultTierIndex >= 0 ? defaultTierIndex : (cycle?.currentIndex ?? 0);
+		let selectedTierIndex = startTierIndex;
 		const slider: HookSelectorSlider | undefined =
 			cycle && cycle.models.length > 1
 				? {
 						caption: "continue with",
-						index: cycle.currentIndex,
+						index: startTierIndex,
 						segments: cycle.models.map(entry => ({
 							label: entry.role,
 							color: MODEL_ROLES[entry.role as ModelRole]?.color,
@@ -2080,6 +2091,9 @@ export class InteractiveMode implements InteractiveModeContext {
 				// applying the slider choice any earlier would be silently reverted —
 				// the bug that made "continue with slow" keep executing on the default
 				// model. Deferred application also survives newSession()/compaction.
+				// `cycle.currentIndex` is exactly that restored model, so any chosen tier
+				// differing from it needs an explicit executionModel — this also covers
+				// leaving the slider on its `default` anchor while planning ran elsewhere.
 				const executionModel =
 					cycle && selectedTierIndex !== cycle.currentIndex ? cycle.models[selectedTierIndex] : undefined;
 				await this.#approvePlan(latestPlanContent, {
@@ -2211,6 +2225,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			logger.warn("Failed to save session draft", { error: String(err) });
 		}
 		this.#btwController.dispose();
+		this.#omfgController.dispose();
 
 		// Emit shutdown event to hooks
 		await this.session.dispose();
@@ -2532,6 +2547,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	#prepareSessionSwitch(): void {
 		this.#btwController.dispose();
+		this.#omfgController.dispose();
 		this.#extensionUiController.clearExtensionTerminalInputListeners();
 		this.#planReviewContainer = undefined;
 	}
@@ -2548,6 +2564,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	handleForkCommand(): Promise<void> {
 		this.#btwController.dispose();
+		this.#omfgController.dispose();
 		return this.#commandController.handleForkCommand();
 	}
 
@@ -2683,6 +2700,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleHandoffCommand(customInstructions);
 	}
 
+	handleShakeCommand(mode: ShakeMode): Promise<void> {
+		return this.#commandController.handleShakeCommand(mode);
+	}
+
 	executeCompaction(
 		customInstructionsOrOptions?: string | CompactOptions,
 		isAuto?: boolean,
@@ -2733,6 +2754,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 	handleResumeSession(sessionPath: string): Promise<void> {
 		this.#btwController.dispose();
+		this.#omfgController.dispose();
 		this.resetObserverRegistry();
 		return this.#selectorController.handleResumeSession(sessionPath);
 	}
@@ -2786,12 +2808,24 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#btwController.handleEscape();
 	}
 
+	handleOmfgCommand(complaint: string): Promise<void> {
+		return this.#omfgController.start(complaint);
+	}
+
+	hasActiveOmfg(): boolean {
+		return this.#omfgController.hasActiveRequest();
+	}
+
+	handleOmfgEscape(): boolean {
+		return this.#omfgController.handleEscape();
+	}
+
 	cycleThinkingLevel(): void {
 		this.#inputController.cycleThinkingLevel();
 	}
 
-	cycleRoleModel(options?: { temporary?: boolean }): Promise<void> {
-		return this.#inputController.cycleRoleModel(options);
+	cycleRoleModel(direction?: "forward" | "backward"): Promise<void> {
+		return this.#inputController.cycleRoleModel(direction);
 	}
 
 	toggleToolOutputExpansion(): void {

package/src/modes/magic-keywords.ts

@@ -0,0 +1,20 @@
+import { highlightOrchestrate } from "./orchestrate";
+import { highlightUltrathink } from "./ultrathink";
+import { highlightWorkflow } from "./workflow";
+
+/**
+ * Gradient-highlight every magic keyword ("ultrathink", "orchestrate",
+ * "workflow") that appears as standalone prose, skipping any occurrence inside a
+ * code block, inline code span, or XML/HTML section. Each highlighter paints its
+ * own keyword with its own gradient, so chaining is order-independent — the
+ * earlier passes only inject zero-width SGR escapes (no backticks or angle
+ * brackets), which never confuse the later passes' markdown masking.
+ *
+ * `resetTo` is the SGR foreground sequence restored after each painted keyword;
+ * pass the surrounding text color when decorating already-colored content (e.g.
+ * a themed message bubble) so the gradient does not bleed into the rest of the
+ * line. Defaults to a plain foreground reset for default-colored editor text.
+ */
+export function highlightMagicKeywords(text: string, resetTo?: string): string {
+	return highlightWorkflow(highlightOrchestrate(highlightUltrathink(text, resetTo), resetTo), resetTo);
+}

package/src/modes/markdown-prose.ts

@@ -0,0 +1,247 @@
+/**
+ * Markdown structure awareness for the magic-keyword affordances
+ * ("ultrathink"/"orchestrate"/"workflow").
+ *
+ * Keyword detection and editor/transcript highlighting must fire only on prose
+ * the user is actually addressing to the model — never on a word that happens to
+ * live inside a fenced code block, an inline code span, or an HTML/XML section.
+ * {@link maskNonProse} returns a length-preserving copy of the text where every
+ * such region is blanked to spaces, so a word-bounded match run against the mask
+ * never lands inside code/markup while its indices still address the original
+ * text for painting.
+ */
+
+// Tag/element name: HTML5/XML start char + name chars. Sticky so we can probe at
+// a precise offset without slicing.
+const TAG_NAME = /[A-Za-z][A-Za-z0-9-]*/y;
+
+// A line that opens or closes a fenced code block: up to 3 leading spaces then a
+// run of >=3 backticks or tildes.
+const FENCE = /^( {0,3})([`~]{3,})/;
+
+/** Index just past the run of backticks beginning at `i`. */
+function backtickRunEnd(text: string, i: number, n: number): number {
+	let j = i;
+	while (j < n && text[j] === "`") j++;
+	return j;
+}
+
+/**
+ * Find the closing backtick run that matches an opening run of `runLen`
+ * backticks, scanning from `from`. Returns the index just past the closing run,
+ * or -1 when no run of the exact length exists (an unmatched run is literal text,
+ * not a code span). Already-masked positions (fenced code) are skipped.
+ */
+function findBacktickClose(text: string, from: number, n: number, runLen: number, masked: Uint8Array): number {
+	let k = from;
+	while (k < n) {
+		if (masked[k]) {
+			k++;
+			continue;
+		}
+		if (text[k] === "`") {
+			const e = backtickRunEnd(text, k, n);
+			if (e - k === runLen) return e;
+			k = e;
+			continue;
+		}
+		k++;
+	}
+	return -1;
+}
+
+/**
+ * Index of the `>` that closes a tag whose attributes begin at `j`, honoring
+ * quoted attribute values. Returns -1 when the tag is malformed (a new `<`
+ * appears first, or there is no `>`), so callers can treat the `<` as literal.
+ */
+function findTagEnd(text: string, j: number, n: number): number {
+	let quote = "";
+	for (let k = j; k < n; k++) {
+		const ch = text[k];
+		if (quote) {
+			if (ch === quote) quote = "";
+			continue;
+		}
+		if (ch === '"' || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === ">") return k;
+		if (ch === "<") return -1;
+	}
+	return -1;
+}
+
+/**
+ * Locate the `</name>` that balances an opening `<name>` at `start`, counting
+ * nested same-name tags. Returns the index just past the matching close tag's
+ * `>`, or -1 when the section is never closed (so callers mask only the opening
+ * tag rather than swallowing the rest of the document).
+ */
+function findMatchingClose(text: string, start: number, n: number, name: string, masked: Uint8Array): number {
+	const lname = name.toLowerCase();
+	let depth = 1;
+	let k = start;
+	while (k < n) {
+		if (masked[k] || text[k] !== "<") {
+			k++;
+			continue;
+		}
+		let m = k + 1;
+		let isClose = false;
+		if (text[m] === "/") {
+			isClose = true;
+			m++;
+		}
+		TAG_NAME.lastIndex = m;
+		const nm = TAG_NAME.exec(text);
+		if (!nm) {
+			k++;
+			continue;
+		}
+		const gt = findTagEnd(text, TAG_NAME.lastIndex, n);
+		if (gt < 0) {
+			k++;
+			continue;
+		}
+		if (nm[0].toLowerCase() === lname) {
+			if (isClose) {
+				depth--;
+				if (depth === 0) return gt + 1;
+			} else if (text[gt - 1] !== "/") {
+				depth++;
+			}
+		}
+		k = gt + 1;
+	}
+	return -1;
+}
+
+/**
+ * Mask the HTML/XML construct beginning at `<` (index `i`): an HTML comment, a
+ * self-closing/closing tag (the tag alone), or an opening tag together with the
+ * content through its matching close tag. Returns the index just past the masked
+ * region, or `i` when the `<` does not begin a tag (e.g. a stray less-than).
+ */
+function maskTagAt(text: string, i: number, n: number, masked: Uint8Array): number {
+	if (text.startsWith("<!--", i)) {
+		const end = text.indexOf("-->", i + 4);
+		const stop = end < 0 ? n : end + 3;
+		for (let p = i; p < stop; p++) masked[p] = 1;
+		return stop;
+	}
+	let j = i + 1;
+	let closing = false;
+	if (text[j] === "/") {
+		closing = true;
+		j++;
+	}
+	TAG_NAME.lastIndex = j;
+	const nm = TAG_NAME.exec(text);
+	if (!nm) return i;
+	const gt = findTagEnd(text, TAG_NAME.lastIndex, n);
+	if (gt < 0) return i;
+	const tagEnd = gt + 1;
+	const selfClosing = text[gt - 1] === "/";
+	for (let p = i; p < tagEnd; p++) masked[p] = 1;
+	if (closing || selfClosing) return tagEnd;
+	const close = findMatchingClose(text, tagEnd, n, nm[0], masked);
+	if (close < 0) return tagEnd;
+	for (let p = tagEnd; p < close; p++) masked[p] = 1;
+	return close;
+}
+
+/**
+ * Return a copy of `text` with identical length (indices map 1:1) where every
+ * character inside a non-prose region is replaced by a space. Non-prose regions
+ * are markdown fenced code blocks, inline code spans, and HTML/XML tags together
+ * with the content they enclose. Newlines are preserved. Text with no construct
+ * that could open such a region is returned unchanged.
+ */
+export function maskNonProse(text: string): string {
+	if (!text.includes("`") && !text.includes("<") && !text.includes("~~~")) {
+		return text;
+	}
+	const n = text.length;
+	const masked = new Uint8Array(n);
+
+	// Phase 1: fenced code blocks, line by line.
+	let fenceChar = "";
+	let fenceLen = 0;
+	let lineStart = 0;
+	while (lineStart <= n) {
+		let nl = text.indexOf("\n", lineStart);
+		if (nl < 0) nl = n;
+		const line = text.slice(lineStart, nl);
+		const open = FENCE.exec(line);
+		if (fenceChar) {
+			for (let p = lineStart; p < nl; p++) masked[p] = 1;
+			// A closing fence is the same char, at least as long, with nothing else on the line.
+			if (
+				open &&
+				open[2]![0] === fenceChar &&
+				open[2]!.length >= fenceLen &&
+				line.slice(open[1]!.length + open[2]!.length).trim() === ""
+			) {
+				fenceChar = "";
+				fenceLen = 0;
+			}
+		} else if (open) {
+			const marker = open[2]!;
+			const ch = marker[0]!;
+			// A backtick fence's info string may not contain a backtick.
+			if (!(ch === "`" && line.slice(open[1]!.length + marker.length).includes("`"))) {
+				fenceChar = ch;
+				fenceLen = marker.length;
+				for (let p = lineStart; p < nl; p++) masked[p] = 1;
+			}
+		}
+		if (nl === n) break;
+		lineStart = nl + 1;
+	}
+
+	// Phase 2: inline code spans and HTML/XML, over not-yet-masked regions.
+	let i = 0;
+	while (i < n) {
+		if (masked[i]) {
+			i++;
+			continue;
+		}
+		const c = text[i];
+		if (c === "`") {
+			const runEnd = backtickRunEnd(text, i, n);
+			const close = findBacktickClose(text, runEnd, n, runEnd - i, masked);
+			if (close >= 0) {
+				for (let p = i; p < close; p++) masked[p] = 1;
+				i = close;
+			} else {
+				i = runEnd;
+			}
+			continue;
+		}
+		if (c === "<") {
+			const end = maskTagAt(text, i, n, masked);
+			i = end > i ? end : i + 1;
+			continue;
+		}
+		i++;
+	}
+
+	const arr = text.split("");
+	for (let p = 0; p < n; p++) {
+		if (masked[p] && arr[p] !== "\n") arr[p] = " ";
+	}
+	return arr.join("");
+}
+
+/**
+ * Whether `text` contains a standalone keyword match (per the non-global,
+ * word-bounded `word` regex) that lives in prose rather than inside a code
+ * block, inline code span, or HTML/XML section. `word` MUST be non-global so
+ * `.test` stays stateless.
+ */
+export function keywordInProse(text: string, word: RegExp): boolean {
+	if (!word.test(text)) return false;
+	return word.test(maskNonProse(text));
+}

package/src/modes/orchestrate.ts

@@ -1,5 +1,6 @@
 import orchestrateNotice from "../prompts/system/orchestrate-notice.md" with { type: "text" };
-import { createGradientHighlighter } from "./gradient-highlight";
+import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
+import { keywordInProse } from "./markdown-prose";
 
 /**
  * "orchestrate" keyword support.
@@ -7,20 +8,25 @@ import { createGradientHighlighter } from "./gradient-highlight";
  * Typing the standalone word in the input editor paints it with a cool
  * teal→violet gradient ({@link highlightOrchestrate}); submitting a message that
  * mentions it appends a hidden {@link ORCHESTRATE_NOTICE} that switches the model
- * into multi-agent orchestration mode. Matching is word-bounded and
- * case-insensitive, so "orchestrated"/"orchestrating" never trigger either
- * behavior. Replaces the former `/orchestrate` slash command.
+ * into multi-agent orchestration mode. Matching is whitespace-delimited and
+ * case-sensitive (lowercase only), so "orchestrated", "Orchestrate", or a path
+ * like "orchestrate.ts" never trigger either behavior. Replaces the former
+ * `/orchestrate` slash command.
  */
 
-// Detection: standalone keyword, any case. Non-global so `.test` stays stateless.
-const ORCHESTRATE_WORD = /\borchestrate\b/i;
+// Detection: lowercase keyword flanked by whitespace or a string edge. Non-global so `.test` stays stateless.
+const ORCHESTRATE_WORD = /(?<!\S)orchestrate(?!\S)/;
 
 /** Hidden system notice appended after a user message that mentions "orchestrate". */
 export const ORCHESTRATE_NOTICE: string = orchestrateNotice.trim();
 
-/** Whether `text` contains the standalone keyword "orchestrate" (any case). */
+/**
+ * Whether `text` contains the standalone keyword "orchestrate" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
 export function containsOrchestrate(text: string): boolean {
-	return ORCHESTRATE_WORD.test(text);
+	return keywordInProse(text, ORCHESTRATE_WORD);
 }
 
 /**
@@ -28,9 +34,9 @@ export function containsOrchestrate(text: string): boolean {
  * cool teal→violet gradient (hue 150..280), visually distinct from ultrathink's
  * full-spectrum rainbow.
  */
-export const highlightOrchestrate: (text: string) => string = createGradientHighlighter({
-	probe: /orchestrate/i,
-	highlight: /\borchestrate\b/gi,
+export const highlightOrchestrate: KeywordHighlighter = createGradientHighlighter({
+	probe: /orchestrate/,
+	highlight: /(?<!\S)orchestrate(?!\S)/g,
 	stops: 14,
 	hue: t => 150 + t * 130,
 });

package/src/modes/shared.ts

@@ -1,3 +1,4 @@
+import { stripVTControlCharacters } from "node:util";
 import type { TabBarTheme } from "@oh-my-pi/pi-tui";
 import { theme } from "./theme/theme";
 
@@ -5,18 +6,9 @@ import { theme } from "./theme/theme";
 // Text Sanitization
 // ═══════════════════════════════════════════════════════════════════════════
 
-const ANSI_OSC_RE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x9d[^\x07\x9c]*(?:\x07|\x9c)/g;
-const ANSI_STRING_RE = /\x1b(?:P|_|\^)[\s\S]*?\x1b\\|[\x90\x9e\x9f][\s\S]*?\x9c/g;
-const ANSI_CSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]|\x9b[0-?]*[ -/]*[@-~]/g;
-const ANSI_SINGLE_RE = /\x1b[@-Z\\-_]/g;
-
-/** Sanitize text for display in a single-line status. Strips ANSI escape sequences, C0/C1 control characters, collapses whitespace, trims. */
+/** Sanitize text for display in a single-line status. Strips ANSI/VT escape sequences, maps remaining C0/C1 control characters to spaces, collapses whitespace, trims. */
 export function sanitizeStatusText(text: string): string {
-	return text
-		.replace(ANSI_OSC_RE, "")
-		.replace(ANSI_STRING_RE, "")
-		.replace(ANSI_CSI_RE, "")
-		.replace(ANSI_SINGLE_RE, "")
+	return stripVTControlCharacters(text)
 		.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
 		.replace(/ +/g, " ")
 		.trim();

package/src/modes/theme/theme.ts

@@ -132,6 +132,7 @@ export type SymbolKey =
 	| "thinking.medium"
 	| "thinking.high"
 	| "thinking.xhigh"
+	| "thinking.autoPending"
 	// Checkboxes
 	| "checkbox.checked"
 	| "checkbox.unchecked"
@@ -297,6 +298,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"thinking.medium": "◒ med",
 	"thinking.high": "◕ high",
 	"thinking.xhigh": "◉ xhigh",
+	"thinking.autoPending": "▣?",
 	// Checkboxes
 	"checkbox.checked": "☑",
 	"checkbox.unchecked": "☐",
@@ -550,6 +552,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"thinking.high": "\u{F111} high",
 	// pick: 🧠 xhi | alt:  xhi  xhi
 	"thinking.xhigh": "\u{F06D} xhi",
+	// pick: 󰞋 (nf-md-help_box) | alt:  [?]
+	"thinking.autoPending": "\u{f078b}",
 	// Checkboxes
 	// pick:  | alt:  
 	"checkbox.checked": "\uf14a",
@@ -723,6 +727,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"thinking.medium": "[med]",
 	"thinking.high": "[high]",
 	"thinking.xhigh": "[xhi]",
+	"thinking.autoPending": "[?]",
 	// Checkboxes
 	"checkbox.checked": "[x]",
 	"checkbox.unchecked": "[ ]",
@@ -1518,6 +1523,7 @@ export class Theme {
 			medium: this.#symbols["thinking.medium"],
 			high: this.#symbols["thinking.high"],
 			xhigh: this.#symbols["thinking.xhigh"],
+			autoPending: this.#symbols["thinking.autoPending"],
 		};
 	}
 

package/src/modes/turn-budget.ts

@@ -0,0 +1,31 @@
+/**
+ * "+Nk" turn token-budget directive.
+ *
+ * A standalone `+<number>[k|m]` token in the user's message sets a per-turn
+ * output-token budget surfaced by the `eval` `budget` helper. By default it is
+ * ADVISORY — the model self-limits via `budget.remaining()`. Append `!`
+ * (`+500k!`) to make it a HARD ceiling: eval `agent()` refuses to spawn once the
+ * turn's spend reaches it. Matching is anchored to token boundaries so it does
+ * not fire on prices or version strings embedded in prose.
+ */
+
+// Number, optional k/m multiplier, optional `!` hard marker, bounded by whitespace/string edges.
+const TURN_BUDGET = /(?:^|\s)\+(\d+(?:\.\d+)?)([km])?(!)?(?=\s|$)/i;
+
+export interface TurnBudget {
+	/** Output-token ceiling for the turn. */
+	total: number;
+	/** Whether the ceiling is enforced (eval `agent()` throws past it) vs advisory. */
+	hard: boolean;
+}
+
+/** Parse a `+Nk`/`+N`/`+Nm`(`!`) turn-budget directive from `text`, or null when absent. */
+export function parseTurnBudget(text: string): TurnBudget | null {
+	const match = TURN_BUDGET.exec(text);
+	if (!match) return null;
+	const value = Number(match[1]);
+	if (!Number.isFinite(value) || value <= 0) return null;
+	const unit = match[2]?.toLowerCase();
+	const multiplier = unit === "k" ? 1_000 : unit === "m" ? 1_000_000 : 1;
+	return { total: Math.round(value * multiplier), hard: match[3] === "!" };
+}

package/src/modes/types.ts

@@ -16,6 +16,7 @@ import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { ShakeMode } from "../session/shake-types";
 import type { LspStartupServerInfo } from "../tools";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -70,6 +71,7 @@ export interface InteractiveModeContext {
 	statusContainer: Container;
 	todoContainer: Container;
 	btwContainer: Container;
+	omfgContainer: Container;
 	editor: CustomEditor;
 	editorContainer: Container;
 	hookWidgetContainerAbove: Container;
@@ -228,6 +230,7 @@ export interface InteractiveModeContext {
 	handleSSHCommand(text: string): Promise<void>;
 	handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
 	handleHandoffCommand(customInstructions?: string): Promise<void>;
+	handleShakeCommand(mode: ShakeMode): Promise<void>;
 	handleMoveCommand(targetPath: string): Promise<void>;
 	handleRenameCommand(title: string): Promise<void>;
 	handleMemoryCommand(text: string): Promise<void>;
@@ -267,8 +270,11 @@ export interface InteractiveModeContext {
 	handleBtwCommand(question: string): Promise<void>;
 	hasActiveBtw(): boolean;
 	handleBtwEscape(): boolean;
+	handleOmfgCommand(complaint: string): Promise<void>;
+	hasActiveOmfg(): boolean;
+	handleOmfgEscape(): boolean;
 	cycleThinkingLevel(): void;
-	cycleRoleModel(options?: { temporary?: boolean }): Promise<void>;
+	cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
 	toggleToolOutputExpansion(): void;
 	setToolsExpanded(expanded: boolean): void;
 	toggleThinkingBlockVisibility(): void;