@oh-my-pi/pi-coding-agent 15.5.15 → 15.6.0

package/src/modes/interactive-mode.ts

@@ -35,6 +35,7 @@ import {
 import { APP_NAME, adjustHsv, getProjectDir, hsvToRgb, isEnoent, logger, postmortem, prompt } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { KeybindingsManager } from "../config/keybindings";
+import { MODEL_ROLES, type ModelRole } from "../config/model-registry";
 import { isSettingsInitialized, Settings, settings } from "../config/settings";
 import type {
 	ExtensionUIContext,
@@ -57,7 +58,7 @@ import planModeApprovedPrompt from "../prompts/system/plan-mode-approved.md" wit
 import planModeCompactInstructionsPrompt from "../prompts/system/plan-mode-compact-instructions.md" with {
 	type: "text",
 };
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+import type { AgentSession, AgentSessionEvent, ResolvedRoleModel } from "../session/agent-session";
 import { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import { getRecentSessions } from "../session/session-manager";
@@ -80,7 +81,7 @@ import { DynamicBorder } from "./components/dynamic-border";
 import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
-import type { HookSelectorComponent } from "./components/hook-selector";
+import type { HookSelectorComponent, HookSelectorSlider } from "./components/hook-selector";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { WelcomeComponent, type LspServerInfo as WelcomeLspServerInfo } from "./components/welcome";
@@ -324,8 +325,6 @@ export class InteractiveMode implements InteractiveModeContext {
 	#eventBus?: EventBus;
 	#eventBusUnsubscribers: Array<() => void> = [];
 	#welcomeComponent?: WelcomeComponent;
-	#todoClosingTimeout?: NodeJS.Timeout;
-	#todoClosingState: "idle" | "playing" | "done" = "idle";
 
 	constructor(
 		session: AgentSession,
@@ -1035,28 +1034,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#renderTodoList(): void {
 		this.todoContainer.clear();
 		const phases = this.todoPhases.filter(phase => phase.tasks.length > 0);
-		if (phases.length === 0) {
-			this.#stopTodoClosingAnimation();
-			this.#todoClosingState = "idle";
-			return;
-		}
-
-		// When every visible task is completed or abandoned, fold the panel
-		// away with a brief celebratory animation (see
-		// #startTodoClosingAnimation). State machine guards against replaying
-		// on every re-render once the animation has finished.
-		const allClosed = phases.every(phase =>
-			phase.tasks.every(t => t.status === "completed" || t.status === "abandoned"),
-		);
-		if (allClosed) {
-			if (this.#todoClosingState === "done") return;
-			if (this.#todoClosingState === "idle") this.#startTodoClosingAnimation(phases);
-			return;
-		}
-		// Any open task here means the close animation is no longer applicable.
-		this.#stopTodoClosingAnimation();
-		this.#todoClosingState = "idle";
-
+		if (phases.length === 0) return;
 		const indent = "  ";
 		const hook = theme.tree.hook;
 		const lines = ["", indent + theme.bold(theme.fg("accent", "Todos"))];
@@ -1098,87 +1076,6 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.todoContainer.addChild(new Text(lines.join("\n"), 1, 0));
 	}
 
-	/**
-	 * Play a short "all done" close animation: a celebratory bright frame,
-	 * a brief dim transition, then a row-by-row vertical collapse until the
-	 * panel is empty. Triggered from #renderTodoList exactly once per
-	 * open-to-all-closed transition; #todoClosingState gates re-entry.
-	 *
-	 * While playing, the animator owns the panel container; #renderTodoList
-	 * returns early. Subsequent renders with state === "done" keep the
-	 * panel hidden until a fresh open task flips state back to "idle".
-	 */
-	#startTodoClosingAnimation(phases: TodoPhase[]): void {
-		this.#stopTodoClosingAnimation();
-		this.#todoClosingState = "playing";
-
-		const indent = "  ";
-		const hook = theme.tree.hook;
-		const snapshot: string[] = ["", `${indent}Todos ${theme.status.success}`];
-		for (let i = 0; i < phases.length; i++) {
-			const phase = phases[i];
-			snapshot.push(`${indent}${hook} ${formatPhaseDisplayName(phase.name, i + 1)}`);
-			for (let j = 0; j < phase.tasks.length; j++) {
-				const task = phase.tasks[j];
-				const mark = task.status === "abandoned" ? theme.status.aborted : theme.status.success;
-				const prefix = `${indent}${j === 0 ? hook : " "} `;
-				snapshot.push(`${prefix}${mark} ${task.content}`);
-			}
-		}
-
-		// Frame schedule (tint, drop-from-bottom, hold-ms). Frame 0 holds long
-		// enough for the user to actually read the final checkmarks before the
-		// fade starts; later frames fade and progressively drop rows from the
-		// bottom for the collapse effect. Total runtime ≈ 1.4s.
-		const frames = [
-			{ tint: "success" as const, drop: 0, holdMs: 900 },
-			{ tint: "success" as const, drop: 0, holdMs: 150 },
-			{ tint: "muted" as const, drop: 1, holdMs: 90 },
-			{ tint: "muted" as const, drop: 2, holdMs: 90 },
-			{ tint: "dim" as const, drop: 3, holdMs: 80 },
-			{ tint: "dim" as const, drop: 4, holdMs: 80 },
-		];
-
-		let frameIdx = 0;
-		const tick = (): void => {
-			if (this.#todoClosingState !== "playing") return;
-			if (frameIdx >= frames.length) {
-				this.todoContainer.clear();
-				this.#stopTodoClosingAnimation();
-				this.#todoClosingState = "done";
-				this.ui.requestRender();
-				return;
-			}
-			const { tint, drop, holdMs } = frames[frameIdx];
-			const visibleCount = Math.max(0, snapshot.length - drop);
-			this.todoContainer.clear();
-			if (visibleCount > 0) {
-				const visible = snapshot.slice(0, visibleCount);
-				const painted = visible.map((line, idx) => {
-					if (idx === 1) {
-						// Header row gets a bold flourish on the opening tick.
-						const colored = theme.fg(tint, line);
-						return frameIdx === 0 ? theme.bold(colored) : colored;
-					}
-					return theme.fg(tint, line);
-				});
-				this.todoContainer.addChild(new Text(painted.join("\n"), 1, 0));
-			}
-			this.ui.requestRender();
-			frameIdx++;
-			this.#todoClosingTimeout = setTimeout(tick, holdMs);
-		};
-
-		tick();
-	}
-
-	#stopTodoClosingAnimation(): void {
-		if (this.#todoClosingTimeout) {
-			clearTimeout(this.#todoClosingTimeout);
-			this.#todoClosingTimeout = undefined;
-		}
-	}
-
 	async #loadTodoList(): Promise<void> {
 		this.todoPhases = this.session.getTodoPhases();
 		this.#renderTodoList();
@@ -1702,6 +1599,20 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
+	async #applyPlanExecutionModel(entry: ResolvedRoleModel | undefined): Promise<void> {
+		if (!entry) return;
+		try {
+			await this.session.applyRoleModel(entry);
+			this.statusLine.invalidate();
+			this.updateEditorBorderColor();
+			this.showStatus(`Continuing with ${entry.role}: ${entry.model.name || entry.model.id}`);
+		} catch (error) {
+			this.showWarning(
+				`Could not switch to the ${entry.role} model: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	async #approvePlan(
 		planContent: string,
 		options: {
@@ -1710,6 +1621,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			title: string;
 			preserveContext?: boolean;
 			compactBeforeExecute?: boolean;
+			executionModel?: ResolvedRoleModel;
 		},
 	): Promise<void> {
 		await renameApprovedPlanFile({
@@ -1791,6 +1703,8 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 
+		await this.#applyPlanExecutionModel(options.executionModel);
+
 		// Approved plans land in a fresh (or compacted) session whose first user-visible
 		// turn is the synthetic plan-approved prompt — that path bypasses the
 		// input-controller's title generation. Seed an auto-name from the plan title
@@ -2106,13 +2020,38 @@ export class InteractiveMode implements InteractiveModeContext {
 			contextUsage?.percent != null
 				? `Approve and keep context (${contextUsage.percent.toFixed(1)}%)`
 				: "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.
+		const cycle = this.session.getRoleModelCycle(this.session.settings.get("cycleOrder"));
+		let selectedTierIndex = cycle?.currentIndex ?? 0;
+		const slider: HookSelectorSlider | undefined =
+			cycle && cycle.models.length > 1
+				? {
+						caption: "continue with",
+						index: cycle.currentIndex,
+						segments: cycle.models.map(entry => ({
+							label: entry.role,
+							color: MODEL_ROLES[entry.role as ModelRole]?.color,
+							detail: entry.model.name || entry.model.id,
+						})),
+						onChange: index => {
+							selectedTierIndex = index;
+						},
+					}
+				: undefined;
+		const helpText = slider ? `${this.#getPlanReviewHelpText()}  ◂/▸ model` : this.#getPlanReviewHelpText();
+
 		const choice = await this.showHookSelector(
 			"Plan mode - next step",
 			["Approve and execute", "Approve and compact context", keepContextLabel, "Refine plan"],
 			{
-				helpText: this.#getPlanReviewHelpText(),
+				helpText,
 				onExternalEditor: () => void this.#openPlanInExternalEditor(planFilePath),
 			},
+			{ slider },
 		);
 
 		if (choice === "Approve and execute" || choice === "Approve and compact context" || choice === keepContextLabel) {
@@ -2123,12 +2062,21 @@ export class InteractiveMode implements InteractiveModeContext {
 					this.showError(`Plan file not found at ${planFilePath}`);
 					return;
 				}
+				// Capture the operator's tier choice and hand it to #approvePlan, which
+				// applies it AFTER #exitPlanMode. #exitPlanMode restores
+				// #planModePreviousModelState (the model from before plan mode), so
+				// 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.
+				const executionModel =
+					cycle && selectedTierIndex !== cycle.currentIndex ? cycle.models[selectedTierIndex] : undefined;
 				await this.#approvePlan(latestPlanContent, {
 					planFilePath,
 					finalPlanFilePath,
 					title: details.title,
 					preserveContext: choice !== "Approve and execute",
 					compactBeforeExecute: choice === "Approve and compact context",
+					executionModel,
 				});
 			} catch (error) {
 				this.showError(
@@ -2904,8 +2852,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		title: string,
 		options: string[],
 		dialogOptions?: ExtensionUIDialogOptions,
+		extra?: { slider?: HookSelectorSlider },
 	): Promise<string | undefined> {
-		return this.#extensionUiController.showHookSelector(title, options, dialogOptions);
+		return this.#extensionUiController.showHookSelector(title, options, dialogOptions, extra);
 	}
 
 	hideHookSelector(): void {

package/src/modes/internal-url-autocomplete.ts

@@ -0,0 +1,143 @@
+/**
+ * Autocomplete for internal-url schemes (skill://, rule://, omp://, local://,
+ * memory://, agent://, artifact://) while composing a prompt.
+ *
+ * Detection here MUST stay in sync with the generic URL-scheme trigger in the
+ * TUI editor (`packages/tui/src/components/editor.ts`); the editor fires the
+ * popup, this module decides whether there are candidates to show.
+ */
+import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
+import { InternalUrlRouter } from "../internal-urls/router";
+
+/** Upper bound on candidates surfaced in the dropdown. */
+const MAX_URL_SUGGESTIONS = 25;
+
+/**
+ * A URL token ending at the cursor: a known internal scheme followed by one or
+ * two slashes and the partially typed host/path. The boundary/rest character
+ * classes mirror the editor trigger so both agree on what counts as a token.
+ */
+const URL_TOKEN_RE = /(?:^|[\s"'`(<=])([a-z][a-z0-9+.-]*:\/{1,2}[^\s"'`()<>]*)$/i;
+const SCHEME_SPLIT_RE = /^([a-z][a-z0-9+.-]*):\/{1,2}(.*)$/i;
+
+export interface InternalUrlContext {
+	/** Lowercased scheme (e.g. `local`). */
+	scheme: string;
+	/** Text typed after the slashes so far (host + path); may be empty. */
+	query: string;
+	/** Exact buffer token from its boundary to the cursor (the completion prefix). */
+	token: string;
+}
+
+// Subsequence fuzzy match: `hum` matches `humanizer`, `lp` matches `local-plan`.
+function fuzzyMatch(query: string, target: string): boolean {
+	if (query.length === 0) return true;
+	if (query.length > target.length) return false;
+	let q = 0;
+	for (let t = 0; t < target.length && q < query.length; t += 1) {
+		if (query[q] === target[t]) q += 1;
+	}
+	return q === query.length;
+}
+
+// Higher is better: exact > prefix > substring > scattered subsequence.
+function fuzzyScore(query: string, target: string): number {
+	if (query.length === 0) return 1;
+	if (target === query) return 100;
+	if (target.startsWith(query)) return 80;
+	if (target.includes(query)) return 60;
+	let q = 0;
+	let gaps = 0;
+	let last = -1;
+	for (let t = 0; t < target.length && q < query.length; t += 1) {
+		if (query[q] === target[t]) {
+			if (last >= 0 && t - last > 1) gaps += 1;
+			last = t;
+			q += 1;
+		}
+	}
+	if (q !== query.length) return 0;
+	return Math.max(1, 40 - gaps * 5);
+}
+
+/**
+ * Detect a completable internal-url token immediately before the cursor.
+ * Returns `null` when the text is not a `scheme://` token whose scheme is
+ * registered with a completion-capable handler.
+ */
+export function extractInternalUrlContext(textBeforeCursor: string): InternalUrlContext | null {
+	const tokenMatch = URL_TOKEN_RE.exec(textBeforeCursor);
+	if (!tokenMatch) return null;
+	const token = tokenMatch[1]!;
+	const parts = SCHEME_SPLIT_RE.exec(token);
+	if (!parts) return null;
+	const scheme = parts[1]!.toLowerCase();
+	if (!InternalUrlRouter.instance().completionSchemes().includes(scheme)) return null;
+	return { scheme, query: parts[2] ?? "", token };
+}
+
+/**
+ * Suggestions for the internal-url token ending at the cursor, or `null` when
+ * the text is not such a token or no candidate matches the typed query.
+ */
+export async function getInternalUrlSuggestions(
+	textBeforeCursor: string,
+): Promise<{ items: AutocompleteItem[]; prefix: string } | null> {
+	const ctx = extractInternalUrlContext(textBeforeCursor);
+	if (!ctx) return null;
+
+	const candidates = await InternalUrlRouter.instance().complete(ctx.scheme, ctx.query);
+	if (!candidates || candidates.length === 0) return null;
+
+	const query = ctx.query.toLowerCase();
+	const scored: Array<{ item: AutocompleteItem; score: number }> = [];
+	for (const candidate of candidates) {
+		const target = candidate.value.toLowerCase();
+		if (!fuzzyMatch(query, target)) continue;
+		scored.push({
+			item: {
+				value: `${ctx.scheme}://${candidate.value}`,
+				label: candidate.label ?? candidate.value,
+				...(candidate.description ? { description: candidate.description } : {}),
+			},
+			score: fuzzyScore(query, target),
+		});
+	}
+	if (scored.length === 0) return null;
+
+	scored.sort((a, b) => b.score - a.score);
+	return {
+		items: scored.slice(0, MAX_URL_SUGGESTIONS).map(entry => entry.item),
+		prefix: ctx.token,
+	};
+}
+
+/** Whether `prefix` (the token a completion was offered for) is an internal-url token. */
+export function isInternalUrlPrefix(prefix: string): boolean {
+	return extractInternalUrlContext(prefix) !== null;
+}
+
+/**
+ * Replace the internal-url token with the selected candidate, appending a
+ * trailing space (matching `@` file-reference behavior) so the user can keep
+ * typing.
+ */
+export function applyInternalUrlCompletion(
+	lines: string[],
+	cursorLine: number,
+	cursorCol: number,
+	item: AutocompleteItem,
+	prefix: string,
+): { lines: string[]; cursorLine: number; cursorCol: number } {
+	const currentLine = lines[cursorLine] || "";
+	const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+	const afterCursor = currentLine.slice(cursorCol);
+	const insert = `${item.value} `;
+	const newLines = [...lines];
+	newLines[cursorLine] = beforePrefix + insert + afterCursor;
+	return {
+		lines: newLines,
+		cursorLine,
+		cursorCol: beforePrefix.length + insert.length,
+	};
+}

package/src/modes/orchestrate.ts

@@ -0,0 +1,36 @@
+import orchestrateNotice from "../prompts/system/orchestrate-notice.md" with { type: "text" };
+import { createGradientHighlighter } from "./gradient-highlight";
+
+/**
+ * "orchestrate" keyword support.
+ *
+ * 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.
+ */
+
+// Detection: standalone keyword, any case. Non-global so `.test` stays stateless.
+const ORCHESTRATE_WORD = /\borchestrate\b/i;
+
+/** 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). */
+export function containsOrchestrate(text: string): boolean {
+	return ORCHESTRATE_WORD.test(text);
+}
+
+/**
+ * Highlight every standalone "orchestrate" in `text` for editor display with a
+ * 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,
+	stops: 14,
+	hue: t => 150 + t * 130,
+});

package/src/modes/prompt-action-autocomplete.ts

@@ -8,6 +8,11 @@ import {
 import { formatKeyHints, type KeybindingsManager } from "../config/keybindings";
 import { isSettingsInitialized, settings } from "../config/settings";
 import { applyEmojiCompletion, getEmojiSuggestions, isEmojiPrefix, tryEmojiInlineReplace } from "./emoji-autocomplete";
+import {
+	applyInternalUrlCompletion,
+	getInternalUrlSuggestions,
+	isInternalUrlPrefix,
+} from "./internal-url-autocomplete";
 
 interface PromptActionDefinition {
 	id: string;
@@ -128,6 +133,9 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			}
 		}
 
+		const urlSuggestions = await getInternalUrlSuggestions(textBeforeCursor);
+		if (urlSuggestions) return urlSuggestions;
+
 		if (!isSettingsInitialized() || settings.get("emojiAutocomplete")) {
 			const emojiSuggestions = getEmojiSuggestions(textBeforeCursor);
 			if (emojiSuggestions) return emojiSuggestions;
@@ -170,6 +178,10 @@ export class PromptActionAutocompleteProvider implements AutocompleteProvider {
 			};
 		}
 
+		if (isInternalUrlPrefix(prefix)) {
+			return applyInternalUrlCompletion(lines, cursorLine, cursorCol, item, prefix);
+		}
+
 		if (isEmojiPrefix(prefix)) {
 			return applyEmojiCompletion(lines, cursorLine, cursorCol, item, prefix);
 		}

package/src/modes/ultrathink.ts

@@ -1,5 +1,5 @@
 import ultrathinkNotice from "../prompts/system/ultrathink-notice.md" with { type: "text" };
-import { theme } from "./theme/theme";
+import { createGradientHighlighter } from "./gradient-highlight";
 
 /**
  * "ultrathink" keyword support, mirroring Claude Code's affordance.
@@ -11,12 +11,8 @@ import { theme } from "./theme/theme";
  * "ultrathinking"/"ultrathinks" never trigger either behavior.
  */
 
-// Cheap, stateless presence probe used to skip the boundary regex on most lines.
-const ULTRATHINK_PROBE = /ultrathink/i;
 // Detection: standalone keyword, any case. Non-global so `.test` stays stateless.
 const ULTRATHINK_WORD = /\bultrathink\b/i;
-// Highlight: global so `.replace` walks every occurrence.
-const ULTRATHINK_HIGHLIGHT = /\bultrathink\b/gi;
 
 /** Hidden system notice appended after a user message that mentions "ultrathink". */
 export const ULTRATHINK_NOTICE: string = ultrathinkNotice.trim();
@@ -26,54 +22,14 @@ export function containsUltrathink(text: string): boolean {
 	return ULTRATHINK_WORD.test(text);
 }
 
-const FG_RESET = "\x1b[39m";
-// Hue stops swept across the visible spectrum. More stops than the keyword has
-// letters so the gradient resolves smoothly regardless of casing/match length.
-const RAINBOW_STOPS = 14;
-
-let cachedMode: string | undefined;
-let cachedPalette: readonly string[] | undefined;
-
-/** Rainbow foreground escapes for the active color mode, compiled once per mode. */
-function rainbowPalette(): readonly string[] {
-	const mode = theme.getColorMode();
-	if (cachedPalette && cachedMode === mode) return cachedPalette;
-	const format = mode === "truecolor" ? "ansi-16m" : "ansi-256";
-	const palette: string[] = [];
-	for (let i = 0; i < RAINBOW_STOPS; i++) {
-		// Sweep red→violet (0..330°), stopping short of the wrap back to red.
-		const hue = Math.round((i / RAINBOW_STOPS) * 330);
-		palette.push(Bun.color(`hsl(${hue}, 90%, 62%)`, format) ?? "");
-	}
-	cachedMode = mode;
-	cachedPalette = palette;
-	return palette;
-}
-
-/** Paint each character of `word` with the next rainbow stop, resetting fg after. */
-function rainbow(word: string): string {
-	const palette = rainbowPalette();
-	const n = word.length;
-	let out = "";
-	let prev = "";
-	for (let i = 0; i < n; i++) {
-		const color = palette[Math.floor((i / n) * palette.length)] ?? palette[0] ?? "";
-		// Coalesce consecutive characters that resolve to the same stop.
-		if (color !== prev) {
-			out += color;
-			prev = color;
-		}
-		out += word[i];
-	}
-	return `${out}${FG_RESET}`;
-}
-
 /**
  * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
- * Adds only zero-width SGR escapes — the visible width is unchanged — and returns
- * the input untouched when the keyword is absent.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
  */
-export function highlightUltrathink(text: string): string {
-	if (!ULTRATHINK_PROBE.test(text)) return text;
-	return text.replace(ULTRATHINK_HIGHLIGHT, rainbow);
-}
+export const highlightUltrathink: (text: string) => string = createGradientHighlighter({
+	probe: /ultrathink/i,
+	highlight: /\bultrathink\b/gi,
+	stops: 14,
+	hue: t => t * 330,
+});

package/src/modes/utils/keybinding-matchers.ts

@@ -16,10 +16,21 @@ export function matchesAppInterrupt(data: string): boolean {
 	return matchesKey(data, "escape") || matchesKey(data, "esc");
 }
 
+/** Match the generic selector cancel keybinding. */
 export function matchesSelectCancel(data: string): boolean {
 	return getKeybindings().matches(data, "tui.select.cancel");
 }
 
+/** Match the generic selector up-navigation keybinding. */
+export function matchesSelectUp(data: string): boolean {
+	return getKeybindings().matches(data, "tui.select.up");
+}
+
+/** Match the generic selector down-navigation keybinding. */
+export function matchesSelectDown(data: string): boolean {
+	return getKeybindings().matches(data, "tui.select.down");
+}
+
 export function matchesAppExternalEditor(data: string): boolean {
 	const keybindings = getKeybindings();
 	const externalEditorKeys = keybindings.getKeys("app.editor.external");

package/src/prompts/system/memory-consolidation-system.md

@@ -0,0 +1,8 @@
+Summarize the memories below into 1-3 concise sentences.
+
+Preserve every fact, name, number, version, date, and decision exactly. Merge duplicates and near-duplicates; never repeat the same point. When memories conflict, state only the most recent as current. Do not invent, infer, or add anything that is not present in the memories. Output only the summary sentences, nothing else.
+
+Memories:
+{memories}
+
+Summary:

package/src/prompts/system/memory-extraction-system.md

@@ -0,0 +1,26 @@
+Extract durable, long-term memory items from the user message below.
+
+Output ONE item per line as a short plain-text statement: no JSON, no bullets, no numbering, no field labels.
+Capture only persistent, reusable information:
+- facts (name, role, employer, config, ports, versions, numbers)
+- explicit instructions to the assistant
+- stable preferences
+- dated events or deadlines
+
+Keep names, numbers, versions, and dates exact, in the message's original language. When a value is updated, output only the latest value. Ignore greetings, acknowledgements, small talk, weather, and one-off remarks.
+If nothing qualifies, output exactly: NO_FACTS
+
+Example
+Message: My name is Sam, I work at Globex, and I always use 2-space indents.
+Items:
+name is Sam
+works at Globex
+prefers 2-space indents
+
+Example
+Message: lol nice weather today, might grab a coffee later
+Items:
+NO_FACTS
+
+Message: {text}
+Items:

package/src/prompts/{commands/orchestrate.md → system/orchestrate-notice.md}

@@ -1,17 +1,5 @@
----
-name: orchestrate
-description: Drive a multi-phase task to completion via parallel subagents
----
-
-# Task
-
-$@
-
----
-
-# Orchestration Contract
-
-You are the **orchestrator** for the task above. Read it once, then execute under the rules below. The contract overrides any default tendency to yield early, narrate, or do work yourself.
+<system-notice>
+The user's message above is an **orchestration request**. Execute it as the orchestrator under the contract below. This contract overrides any default tendency to yield early, narrate, or do the work yourself.
 
 <role>
 You decompose, dispatch, verify, and iterate. You do **not** edit code. Every file mutation goes through a `task` subagent. Your tool budget is: reading for planning, `task` for dispatch, verification (`bun check`, `bun test`, `recipe`, `lsp diagnostics`), git via `bash`, and `todo_write` for tracking.
@@ -19,11 +7,11 @@ You decompose, dispatch, verify, and iterate. You do **not** edit code. Every fi
 
 <rules>
 1. **Do not yield until everything is closed.** A phase finishing is *not* a yield point — launch the next phase in the same turn. Stop only when every requested item is verifiably done, or you hit a concrete [blocked] state that genuinely requires the user.
-2. **Enumerate the full surface before dispatching.** If the task references audits, plans, checklists, phase lists, or file lists, expand them into a flat set of items in `todo_write`. "Most of them" or "the important ones" is failure. Re-read the source documents — do not work from memory.
+2. **Enumerate the full surface before dispatching.** If the request references audits, plans, checklists, phase lists, or file lists, expand them into a flat set of items in `todo_write`. "Most of them" or "the important ones" is failure. Re-read the source documents — do not work from memory.
 3. **Parallelize maximally.** Every set of edits with disjoint file scope MUST ship as one `task` batch. Serialize only when one subagent produces a contract (types, schema, shared module) the next consumes — and state the dependency when you do.
 4. **Each `task` assignment is self-contained.** Subagents have no shared context. Spell out: target files (≤3–5 explicit paths, no globs), the change with APIs and patterns, edge cases, and observable acceptance criteria. Do not assume they read the same plan you did.
 5. **Verify after every phase before launching the next.** Run the appropriate gate: `bun check` for types, package-scoped `bun test` for behavior, `lsp diagnostics` for changed files. If a phase introduced breakage, dispatch fix-up subagents *before* moving on. Never declare a phase done on a red tree.
-6. **Commit policy.** If the task asks for commits or the repo workflow expects them, commit after each green phase with a focused message. Never commit a red tree. Never commit work the user did not ask to commit.
+6. **Commit policy.** If the request asks for commits or the repo workflow expects them, commit after each green phase with a focused message. Never commit a red tree. Never commit work the user did not ask to commit.
 7. **Respawn, do not absorb.** If a subagent returns incomplete or wrong work, spawn a corrective subagent with the specific gap — do not silently fix it yourself.
 8. **No scope creep, no scope shrink.** Do not add work the user did not ask for. Do not relabel unfinished items as "follow-up", "v1", or "MVP" to imply completion.
 9. **Subagents do not verify, lint, or format.** Every `task` assignment MUST instruct the subagent to skip all gates and formatters. Their job is the edit only. You — the orchestrator — run verification and formatting **once** at the end of the phase across the union of changed files. Avoids redundant runs and racing formatter passes.
@@ -47,3 +35,4 @@ You decompose, dispatch, verify, and iterate. You do **not** edit code. Every fi
 - Marking todos done based on subagent self-reports without verifying the gate.
 - Summarizing progress in chat instead of advancing to the next phase.
 </anti-patterns>
+</system-notice>

package/src/prompts/system/system-prompt.md

@@ -54,7 +54,9 @@ With most FS/bash-like tools, static references to them will automatically resol
 - `skill://<name>`: Skill instructions
    - `/<path>`: File within a skill
 - `rule://<name>`: Rule details
+{{#if hasMemoryRoot}}
 - `memory://root`: Project memory summary
+{{/if}}
 - `agent://<id>`: Full agent output artifact
    - `/<path>`: JSON field extraction
 - `artifact://<id>`: Artifact content