@oh-my-pi/pi-coding-agent 16.1.1 → 16.1.3

package/src/mnemopi/embed-worker.ts

@@ -0,0 +1,113 @@
+/**
+ * Mnemopi local-embeddings worker. Loaded inside the dedicated subprocess
+ * spawned by `embed-client.ts` (re-entered through the agent CLI's hidden
+ * `__omp_worker_mnemopi_embed` selector). The whole point of this module is
+ * that `loadFastembed()` — and therefore `onnxruntime-node`'s NAPI
+ * constructor + finalizer — only ever runs in this child address space. The
+ * parent `SIGKILL`s us on shutdown so the destructor that crashes Bun on
+ * Windows shutdown (issue #3031, mnemopi sibling of #1606/#1607) never runs
+ * in either process.
+ */
+
+import type { StandardEmbeddingModel } from "@oh-my-pi/pi-mnemopi/core";
+import { loadFastembed } from "@oh-my-pi/pi-mnemopi/core/fastembed-runtime";
+import type { MnemopiEmbedModelId, MnemopiEmbedTransport, MnemopiEmbedWorkerInbound } from "./embed-protocol";
+
+interface LoadedModel {
+	model: MnemopiEmbedModelId;
+	cacheDir: string | undefined;
+	instance: {
+		embed(texts: string[], batchSize?: number): AsyncIterable<number[][]> | Iterable<number[][]>;
+	};
+}
+
+let loaded: Promise<LoadedModel> | null = null;
+let loadedKey = "";
+
+async function loadModel(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<LoadedModel> {
+	const { FlagEmbedding } = await loadFastembed();
+	// Cast: `model` arrives as a string from the parent (resolved by
+	// mnemopi's `fastembedModelName`). Cast to the non-CUSTOM overload's
+	// argument so TypeScript picks the standard-model branch — the parent
+	// only ever passes pre-vetted fast-* identifiers.
+	const instance = await FlagEmbedding.init({
+		model: model as StandardEmbeddingModel,
+		cacheDir,
+		showDownloadProgress: false,
+	});
+	return { model, cacheDir, instance };
+}
+
+function ensureLoaded(model: MnemopiEmbedModelId, cacheDir: string | undefined): Promise<LoadedModel> {
+	const key = `${model}\u0000${cacheDir ?? ""}`;
+	if (loaded !== null && loadedKey === key) return loaded;
+	const loading = loadModel(model, cacheDir).catch(error => {
+		// Failed loads must not poison the cache — a retry with the same key
+		// should re-attempt the load.
+		if (loaded === loading) {
+			loaded = null;
+			loadedKey = "";
+		}
+		throw error;
+	});
+	loaded = loading;
+	loadedKey = key;
+	return loading;
+}
+async function handleEmbed(
+	transport: MnemopiEmbedTransport,
+	message: Extract<MnemopiEmbedWorkerInbound, { type: "embed" }>,
+): Promise<void> {
+	try {
+		// Each `embed` carries the model + cacheDir the wrapper was bound to.
+		// `ensureLoaded` is idempotent for the same key, so this is a no-op
+		// once the model is in memory — and it transparently re-loads after
+		// the parent SIGKILLed the previous subprocess but mnemopi still
+		// holds the cached `LocalEmbeddingModel` wrapper from before.
+		const { instance } = await ensureLoaded(message.model, message.cacheDir);
+		const vectors: number[][] = [];
+		const batches = instance.embed([...message.texts], message.batchSize);
+		for await (const batch of batches) {
+			for (const row of batch) vectors.push(row);
+		}
+		transport.send({ type: "vectors", id: message.id, vectors });
+	} catch (error) {
+		transport.send({
+			type: "error",
+			id: message.id,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+async function handleInit(
+	transport: MnemopiEmbedTransport,
+	message: Extract<MnemopiEmbedWorkerInbound, { type: "init" }>,
+): Promise<void> {
+	try {
+		await ensureLoaded(message.model, message.cacheDir);
+		transport.send({ type: "ready", id: message.id });
+	} catch (error) {
+		transport.send({
+			type: "error",
+			id: message.id,
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
+}
+
+export function startMnemopiEmbedWorker(transport: MnemopiEmbedTransport): void {
+	transport.onMessage(message => {
+		switch (message.type) {
+			case "ping":
+				transport.send({ type: "pong", id: message.id });
+				return;
+			case "init":
+				void handleInit(transport, message);
+				return;
+			case "embed":
+				void handleEmbed(transport, message);
+				return;
+		}
+	});
+}

package/src/mnemopi/state.ts

@@ -3,6 +3,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type * as MnemopiNs from "@oh-my-pi/pi-mnemopi";
 import type { Mnemopi, RecallResult } from "@oh-my-pi/pi-mnemopi";
 import type * as MnemopiCoreNs from "@oh-my-pi/pi-mnemopi/core";
+import type { LocalModelInitializer } from "@oh-my-pi/pi-mnemopi/core";
 import { logger } from "@oh-my-pi/pi-utils";
 import {
 	composeRecallQuery,
@@ -13,16 +14,42 @@ import {
 import { extractMessages } from "../hindsight/transcript";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { MnemopiBackendConfig, MnemopiScoping } from "./config";
+import { mnemopiEmbedClient } from "./embed-client";
 
 // The mnemopi package pulls the embeddings stack; keep it off the CLI startup
 // module graph by loading it lazily at the async boundaries that need it.
 let mnemopiMod: typeof MnemopiNs | undefined;
 let mnemopiCoreMod: typeof MnemopiCoreNs | undefined;
 
-/** Lazily load `@oh-my-pi/pi-mnemopi` (memoized). */
+// `setLocalModelInitializer` writes a single module-level slot shared by
+// both the root and `/core` re-exports, so install at most once across both
+// loaders. Either entry point is enough to wire up the override.
+let localModelInitializerInstalled = false;
+
+function installLocalModelInitializer(setInitializer: (initializer: LocalModelInitializer) => void): void {
+	if (localModelInitializerInstalled) return;
+	localModelInitializerInstalled = true;
+	setInitializer(({ model, cacheDir }) =>
+		mnemopiEmbedClient.initialize(model, cacheDir).then(handle => {
+			if (handle) return handle;
+			throw new Error("mnemopi embed subprocess unavailable");
+		}),
+	);
+}
+
+/**
+ * Lazily load `@oh-my-pi/pi-mnemopi` (memoized) and route fastembed loads
+ * through the dedicated embeddings subprocess. The override is installed once
+ * — before any consumer gets the chance to call `embed()` — so
+ * `onnxruntime-node`'s NAPI constructor + finalizer never run inside the
+ * agent's address space (issue #3031). Test seams that swap the initializer
+ * with `setLocalModelInitializerForTests` still win because both go through
+ * the same module-level slot.
+ */
 export async function loadMnemopi(): Promise<typeof MnemopiNs> {
 	if (!mnemopiMod) {
 		mnemopiMod = await import("@oh-my-pi/pi-mnemopi");
+		installLocalModelInitializer(mnemopiMod.setLocalModelInitializer);
 	}
 	return mnemopiMod;
 }
@@ -31,6 +58,7 @@ export async function loadMnemopi(): Promise<typeof MnemopiNs> {
 export async function loadMnemopiCore(): Promise<typeof MnemopiCoreNs> {
 	if (!mnemopiCoreMod) {
 		mnemopiCoreMod = await import("@oh-my-pi/pi-mnemopi/core");
+		installLocalModelInitializer(mnemopiCoreMod.setLocalModelInitializer);
 	}
 	return mnemopiCoreMod;
 }

package/src/modes/components/assistant-message.ts

@@ -16,6 +16,59 @@ import { type CacheInvalidation, CacheInvalidationMarkerComponent } from "./cach
  */
 const MAX_TRANSCRIPT_ERROR_LINES = 8;
 
+/**
+ * A GFM table delimiter row (`| --- | :--: |`, with or without bounding pipes).
+ * The header row alone does not render a table — this delimiter is what makes
+ * Markdown lay one out, and a streaming table re-aligns its columns as rows
+ * arrive. Requires at least one column pipe so a bare thematic break (`---`)
+ * does not match.
+ */
+const MARKDOWN_TABLE_DELIMITER = /^ {0,3}\|?(?:[ \t]*:?-+:?[ \t]*\|)+[ \t]*:?-*:?[ \t]*$/;
+
+/** Opening or closing fence of a code block: ≥3 backticks/tildes plus info string. */
+const CODE_FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+
+/**
+ * Whether `text` currently contains reflowing Markdown whose layout is not yet
+ * permanent: an open ` ```mermaid ` fence (the diagram reshapes as source
+ * arrives) or a GFM table (columns re-align as rows arrive). Used by
+ * {@link AssistantMessageComponent.isTranscriptBlockCommitStable}.
+ *
+ * Fence-aware: a mermaid block is detected by its opener, and table delimiters
+ * inside ordinary fenced code (shell pipes, ASCII separators, doc examples) are
+ * ignored so a long streamed code block is never held out of native scrollback.
+ * A delimiter counts only directly under a pipe-bearing header row, outside any
+ * code fence.
+ */
+function detectLiveReflowingMarkdown(text: string): boolean {
+	let fence: string | null = null;
+	let prevLine = "";
+	for (const line of text.split("\n")) {
+		const fenceMatch = CODE_FENCE_LINE.exec(line);
+		if (fence !== null) {
+			// Inside a code block: only a bare matching closing fence ends it.
+			if (
+				fenceMatch &&
+				fenceMatch[2]!.trim() === "" &&
+				fenceMatch[1]![0] === fence[0] &&
+				fenceMatch[1]!.length >= fence.length
+			) {
+				fence = null;
+			}
+			continue;
+		}
+		if (fenceMatch) {
+			if (/^mermaid\b/.test(fenceMatch[2]!.trim())) return true;
+			fence = fenceMatch[1]!;
+			prevLine = "";
+			continue;
+		}
+		if (prevLine.includes("|") && MARKDOWN_TABLE_DELIMITER.test(line)) return true;
+		prevLine = line;
+	}
+	return false;
+}
+
 /**
  * Frames for the streaming "thinking" pulse rendered in place of a hidden
  * thinking block while the model is still producing it. A single fixed-width
@@ -36,6 +89,15 @@ export class AssistantMessageComponent extends Container {
 	#convertedKittyImages = new Map<string, ImageContent>();
 	#kittyConversionsInFlight = new Set<string>();
 	#transcriptBlockFinalized: boolean;
+	/**
+	 * True while a non-finalized text item carries reflowing Markdown — a
+	 * ` ```mermaid ` fence or a GFM table — whose layout re-flows every frame as
+	 * source arrives (a diagram reshaping, a table re-aligning its columns), so
+	 * no prefix is byte-stable until the message finalizes. See
+	 * {@link isTranscriptBlockCommitStable}. Recomputed in {@link updateContent}
+	 * ahead of the fast-path return, so it tracks every stream tick.
+	 */
+	#hasLiveReflowingMarkdown = false;
 	/**
 	 * When true, the turn-ending `Error: …` line for `stopReason === "error"` is
 	 * suppressed because the same error is currently shown in the pinned banner
@@ -192,6 +254,21 @@ export class AssistantMessageComponent extends Container {
 		return this.#transcriptBlockFinalized;
 	}
 
+	/**
+	 * Whether this still-live block's scrolled-off rows may be committed to
+	 * immutable native scrollback (the {@link TranscriptContainer} durable-
+	 * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
+	 * table — re-lays-out its body as source arrives (the diagram reshapes, the
+	 * table re-aligns its columns), so committing an intermediate layout strands
+	 * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
+	 * clear. While such content is still streaming the block therefore stays
+	 * wholly in the repaintable live region and commits once, at its final
+	 * layout, when the turn finalizes.
+	 */
+	isTranscriptBlockCommitStable(): boolean {
+		return this.#transcriptBlockFinalized || !this.#hasLiveReflowingMarkdown;
+	}
+
 	getTranscriptBlockVersion(): number {
 		return this.#blockVersion;
 	}
@@ -418,6 +495,15 @@ export class AssistantMessageComponent extends Container {
 		this.#lastMessage = message;
 		this.#lastUpdateTransient = opts?.transient === true;
 
+		// Streaming reflowing Markdown (a mermaid diagram reshaping, a GFM table
+		// re-aligning columns) re-lays-out its body each frame; see
+		// isTranscriptBlockCommitStable. Detect it from raw text — a Markdown
+		// parser only resolves these once the closing fence / delimiter row
+		// arrives, but the stale native-scrollback commits happen mid-stream.
+		this.#hasLiveReflowingMarkdown = message.content.some(
+			content => content.type === "text" && detectLiveReflowingMarkdown(content.text),
+		);
+
 		// Fast path: reuse Markdown children when shape is stable during streaming
 		if (this.#tryFastPathUpdate(message)) return;
 

package/src/modes/components/custom-editor.ts

@@ -177,7 +177,7 @@ export class CustomEditor extends Editor {
 	/** Per-render scratch flag: did any layout line in this render contain a magic
 	 *  keyword that should shimmer? Reset by {@link #scheduleShimmerIfNeeded} each
 	 *  time a frame is queued. */
-	#shimmerTimer: ReturnType<typeof setTimeout> | undefined;
+	#shimmerTimer: Timer | undefined;
 	/** Repaint hook the host wires once at construction. Called from the shimmer
 	 *  timer to request the next animation frame. Undefined when nobody is
 	 *  listening (tests, headless callers); the timer chain still self-cleans. */

package/src/modes/components/model-selector.ts

@@ -179,9 +179,9 @@ export class ModelSelectorComponent extends Container {
 	#providers: ProviderTabState[] = STATIC_PROVIDER_TABS;
 	#activeTabIndex: number = 0;
 	#refreshingProviders: Set<string> = new Set();
-	#scheduledProviderRefreshes: Map<string, ReturnType<typeof setTimeout>> = new Map();
+	#scheduledProviderRefreshes: Map<string, Timer> = new Map();
 	#refreshSpinnerFrame: number = 0;
-	#refreshSpinnerInterval?: NodeJS.Timeout;
+	#refreshSpinnerInterval?: Timer;
 
 	// Context menu state
 	#isMenuOpen: boolean = false;

package/src/modes/components/tips.txt

@@ -20,4 +20,5 @@ Press ctrl+r to search your prompt history and reuse a past message
 Pair up live: `/collab` shares your session through an end-to-end encrypted relay link — a teammate runs `/join <link>` to watch tool calls stream and prompt the agent from their own omp
 Press ← ← to drill into a running or finished agent and inspect its tool calls and transcript
 Hit a Codex rate limit? `/usage reset` spends a saved reset credit to immediately restore your quota
-No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
+No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
+Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice [NEW]

package/src/modes/components/welcome.ts

@@ -29,16 +29,73 @@ export const WELCOME_SESSION_SLOTS = 4;
  */
 export const WELCOME_LSP_SLOTS = 4;
 
-export function renderWelcomeTip(tip: string, boxWidth: number): string[] {
+/** Trailing marker that flags a tip as a "what's new" callout. Stripped before
+ *  wrapping (with any preceding whitespace) and replaced by {@link NEW_TAG_TEXT}
+ *  painted as a shimmering rainbow. Non-global so `.test` stays stateless. */
+const NEW_TIP_MARKER = /\s*\[NEW\]\s*$/;
+
+/** Visible text rendered in place of {@link NEW_TIP_MARKER}. */
+const NEW_TAG_TEXT = "NEW!";
+
+/** Milliseconds for one full hue rotation of the rainbow "NEW!" tag. */
+const NEW_GLOW_PERIOD_MS = 1500;
+
+/** Selection weight for "[NEW]" tips; ordinary tips weigh 1, so a freshly added
+ *  affordance surfaces this many times as often. */
+const NEW_TIP_WEIGHT = 4;
+
+/** Per-tip selection weights, parallel to {@link TIPS}. */
+const TIP_WEIGHTS: readonly number[] = TIPS.map(tip => (NEW_TIP_MARKER.test(tip) ? NEW_TIP_WEIGHT : 1));
+const TIP_WEIGHT_TOTAL = TIP_WEIGHTS.reduce((sum, weight) => sum + weight, 0);
+
+/** Pick a tip at random, biased toward "[NEW]" tips by {@link NEW_TIP_WEIGHT}.
+ *  Returns "" when no tips are embedded. */
+function pickWeightedTip(): string {
+	if (TIPS.length === 0) return "";
+	let r = Math.random() * TIP_WEIGHT_TOTAL;
+	for (let i = 0; i < TIPS.length; i++) {
+		r -= TIP_WEIGHTS[i] ?? 1;
+		if (r < 0) return TIPS[i] ?? "";
+	}
+	return TIPS[TIPS.length - 1] ?? "";
+}
+
+type ColorEncoding = "ansi-16m" | "ansi-256";
+
+/** Paint each glyph of {@link NEW_TAG_TEXT} on a moving HSL rainbow. `phase`
+ *  rotates the hue offset cyclically; successive renders with increasing phase
+ *  shimmer, while a fixed phase yields a still rainbow. */
+function renderNewTag(phase: number, encoding: ColorEncoding): string {
+	const bold = "\x1b[1m";
+	const reset = "\x1b[0m";
+	const wrapped = ((phase % 1) + 1) % 1;
+	const chars = [...NEW_TAG_TEXT];
+	let out = bold;
+	let prev = "";
+	for (let i = 0; i < chars.length; i++) {
+		const hue = Math.round(((i / chars.length + wrapped) % 1) * 360);
+		const color = Bun.color(`hsl(${hue}, 95%, 60%)`, encoding) ?? "";
+		if (color !== prev) {
+			out += color;
+			prev = color;
+		}
+		out += chars[i];
+	}
+	return out + reset;
+}
+export function renderWelcomeTip(tip: string, boxWidth: number, phase = 0): string[] {
 	const label = "Tip: ";
 	const labelWidth = visibleWidth(label);
 	const bodyBudget = boxWidth - 1 - labelWidth; // 1 = leading indent
 	if (bodyBudget < 8) return [];
 
-	const wrappedBody = wrapTextWithAnsi(replaceTabs(tip), bodyBudget);
+	const isNew = NEW_TIP_MARKER.test(tip);
+	const body = isNew ? tip.replace(NEW_TIP_MARKER, "") : tip;
+
+	const wrappedBody = wrapTextWithAnsi(replaceTabs(body), bodyBudget);
 	if (wrappedBody.length === 0) return [];
 
-	const encoding = TERMINAL.trueColor ? "ansi-16m" : "ansi-256";
+	const encoding: ColorEncoding = TERMINAL.trueColor ? "ansi-16m" : "ansi-256";
 	const purple = Bun.color("#b48cff", encoding) ?? "";
 	const lightBlue = Bun.color("#9ccfff", encoding) ?? "";
 	const italic = "\x1b[3m";
@@ -46,11 +103,27 @@ export function renderWelcomeTip(tip: string, boxWidth: number): string[] {
 	const reset = "\x1b[0m";
 	const continuationIndent = padding(labelWidth);
 
-	return wrappedBody.map((body, index) =>
+	const lines = wrappedBody.map((line, index) =>
 		index === 0
-			? ` ${italic}${purple}${label}${dim}${lightBlue}${body}${reset}`
-			: ` ${italic}${continuationIndent}${dim}${lightBlue}${body}${reset}`,
+			? ` ${italic}${purple}${label}${dim}${lightBlue}${line}${reset}`
+			: ` ${italic}${continuationIndent}${dim}${lightBlue}${line}${reset}`,
 	);
+
+	if (isNew) {
+		// Append the rainbow tag to the final body line when it fits within the
+		// box; otherwise drop it onto its own indented continuation line so the
+		// styled glyphs never overflow or reflow the wrapped body.
+		const tag = renderNewTag(phase, encoding);
+		const tagWidth = 1 + visibleWidth(NEW_TAG_TEXT); // 1 = space separator
+		const lastLine = lines[lines.length - 1];
+		if (lastLine !== undefined && visibleWidth(lastLine) + tagWidth <= boxWidth) {
+			lines[lines.length - 1] = `${lastLine} ${tag}`;
+		} else {
+			lines.push(` ${continuationIndent}${tag}`);
+		}
+	}
+
+	return lines;
 }
 
 export interface RecentSession {
@@ -69,7 +142,7 @@ export interface LspServerInfo {
  */
 export class WelcomeComponent implements Component {
 	#animStart: number | null = null;
-	#animTimer: ReturnType<typeof setInterval> | null = null;
+	#animTimer: Timer | null = null;
 	#selectedTip: string | undefined;
 	// Render cache: the welcome box is the first transcript-area component, so
 	// returning a stable array reference keeps the whole frame prefix stable.
@@ -89,7 +162,7 @@ export class WelcomeComponent implements Component {
 			if (theme.getSymbolPreset() === "unicode" && Math.random() < 0.1) {
 				this.#selectedTip = "Please use nerdfont 😭.";
 			} else {
-				this.#selectedTip = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : "";
+				this.#selectedTip = pickWeightedTip();
 			}
 		}
 		return this.#selectedTip || undefined;
@@ -327,7 +400,12 @@ export class WelcomeComponent implements Component {
 	#renderTip(boxWidth: number): string[] {
 		const tip = this.tip;
 		if (!tip) return [];
-		return renderWelcomeTip(tip, boxWidth);
+		// A trailing "[NEW]" marker paints an animated rainbow "NEW!" tag. Derive
+		// its hue phase from wall-clock time so it shimmers across the welcome
+		// intro's re-render frames, then settles into a still rainbow once the box
+		// caches its resting frame. Non-"[NEW]" tips ignore the phase entirely.
+		const phase = NEW_TIP_MARKER.test(tip) ? performance.now() / NEW_GLOW_PERIOD_MS : 0;
+		return renderWelcomeTip(tip, boxWidth, phase);
 	}
 
 	/** Center text within a given width */

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

@@ -1,4 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { THINKING_LOOP_ERROR_MARKER } from "@oh-my-pi/pi-ai/utils/thinking-loop";
 import { type Component, Loader, TERMINAL } from "@oh-my-pi/pi-tui";
 import { INTENT_FIELD } from "@oh-my-pi/pi-wire";
 import { extractTextContent } from "../../commit/utils";
@@ -186,7 +187,7 @@ export class EventController {
 	}
 	#updateWorkingMessageFromIntent(intent: unknown): void {
 		if (this.ctx.session.isAborting) return;
-		// Streamed JSON can deliver non-string `_i` (object, number, boolean) before
+		// Streamed JSON can deliver non-string `i` (object, number, boolean) before
 		// schema validation; `?.` only guards null/undefined, so guard the type too.
 		if (typeof intent !== "string") return;
 		const trimmed = intent.trim();
@@ -1014,6 +1015,13 @@ export class EventController {
 	async #handleAutoRetryStart(event: Extract<AgentSessionEvent, { type: "auto_retry_start" }>): Promise<void> {
 		this.#stopWorkingLoader();
 		this.ctx.statusContainer.clear();
+		if (event.errorMessage?.includes(THINKING_LOOP_ERROR_MARKER)) {
+			// The retry path drops the failed assistant from runtime context. Do not
+			// restore its inline Error row; just unpin the fixed-region banner so the
+			// retry UI is the visible state.
+			this.#pinnedErrorComponent = undefined;
+			this.ctx.clearPinnedError();
+		}
 		const delaySeconds = Math.round(event.delayMs / 1000);
 		this.ctx.retryLoader = new Loader(
 			this.ctx.ui,

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

@@ -27,7 +27,7 @@ import {
 	theme,
 } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
-import type { ResetCreditRedeemOutcome } from "../../session/auth-storage";
+import type { ResetCreditAccountStatus, ResetCreditRedeemOutcome } from "../../session/auth-storage";
 import type { SessionInfo } from "../../session/session-listing";
 import { SessionManager } from "../../session/session-manager";
 import { FileSessionStorage } from "../../session/session-storage";
@@ -1161,7 +1161,7 @@ export class SelectorController {
 	async showResetUsageSelector(): Promise<void> {
 		const session = this.ctx.session;
 		this.ctx.showStatus("Checking saved rate-limit resets…", { dim: true });
-		let statuses: Awaited<ReturnType<typeof session.listResetCredits>>;
+		let statuses: ResetCreditAccountStatus[];
 		try {
 			statuses = await session.listResetCredits();
 		} catch (error) {

package/src/modes/theme/theme.ts

@@ -2743,6 +2743,35 @@ export function highlightCode(code: string, lang?: string, highlightTheme: Theme
 }
 
 export function getSymbolTheme(): SymbolTheme {
+	// Guard against `theme` being undefined (pre-init or cross-module-instance
+	// plugin calls). Fall back to the ASCII preset so the returned symbols are
+	// usable instead of crashing. See #2998.
+	if (typeof theme === "undefined") {
+		const box = {
+			topLeft: "+",
+			topRight: "+",
+			bottomLeft: "+",
+			bottomRight: "+",
+			horizontal: "-",
+			vertical: "|",
+			cross: "+",
+			teeDown: "+",
+			teeUp: "+",
+			teeLeft: "+",
+			teeRight: "+",
+		};
+		return {
+			cursor: ">",
+			inputCursor: "|",
+			boxRound: box,
+			boxSharp: box,
+			table: box,
+			quoteBorder: "|",
+			hrChar: "-",
+			colorSwatch: "[]",
+			spinnerFrames: ["-", "\\", "|", "/"],
+		};
+	}
 	const preset = theme.getSymbolPreset();
 
 	return {
@@ -2808,6 +2837,19 @@ export function getMarkdownTheme(): MarkdownTheme {
 }
 
 export function getSelectListTheme(): SelectListTheme {
+	// Guard against `theme` being undefined (pre-init or cross-module-instance
+	// plugin calls). See #2998.
+	if (typeof theme === "undefined") {
+		return {
+			selectedPrefix: (text: string) => text,
+			selectedText: (text: string) => text,
+			description: (text: string) => text,
+			scrollInfo: (text: string) => text,
+			noMatch: (text: string) => text,
+			symbols: getSymbolTheme(),
+			hovered: (text: string) => text,
+		};
+	}
 	return {
 		selectedPrefix: (text: string) => theme.fg("accent", text),
 		selectedText: (text: string) => theme.fg("accent", text),
@@ -2820,6 +2862,16 @@ export function getSelectListTheme(): SelectListTheme {
 }
 
 export function getEditorTheme(): EditorTheme {
+	// Guard against `theme` being undefined (pre-init or cross-module-instance
+	// plugin calls). See #2998.
+	if (typeof theme === "undefined") {
+		return {
+			borderColor: (text: string) => text,
+			selectList: getSelectListTheme(),
+			symbols: getSymbolTheme(),
+			hintStyle: (text: string) => text,
+		};
+	}
 	return {
 		borderColor: (text: string) => theme.fg("borderMuted", text),
 		selectList: getSelectListTheme(),
@@ -2829,6 +2881,23 @@ export function getEditorTheme(): EditorTheme {
 }
 
 export function getSettingsListTheme(): SettingsListTheme {
+	// Plugins (e.g. pi-rtk-optimizer) may call this before `initTheme()` assigns
+	// the global `theme`, or from a separate module instance under npm-global
+	// installs where the live binding was never initialized. Fall back to plain
+	// text so the call returns a usable (unstyled) theme instead of crashing with
+	// "undefined is not an object (evaluating 'theme.fg')". See #2998.
+	if (typeof theme === "undefined") {
+		return {
+			label: (text: string) => text,
+			value: (text: string) => text,
+			description: (text: string) => text,
+			cursor: "> ",
+			hint: (text: string) => text,
+			heading: (text: string) => text,
+			section: (text: string) => text,
+			hovered: (text: string) => text,
+		};
+	}
 	return {
 		label: (text: string, selected: boolean, changed: boolean) =>
 			changed ? theme.fg("statusLineGitDirty", text) : selected ? theme.fg("accent", text) : text,

package/src/prompts/system/personalities/default.md

@@ -1,26 +1,18 @@
 You are a terse, evidence-first engineer: every sentence carries a fact, a decision, or a risk.
 
 # Tone
-- Use terse sentence fragments when clearer.
-- Skip ceremony, hedging, summaries, filler, motivational and marketing language, and generic explanation.
-- Do not narrate obvious steps or over-explain basics.
-- MUST assume the reader is technical.
-- Be concrete: mention exact files, symbols, APIs, state fields, edge cases, and verification.
-- Compress reasoning into facts, constraints, tradeoffs, decisions, and checks. Action-oriented and dense.
-- Do not hide uncertainty: state it briefly at the specific claim, name the tradeoff, and pick the boring/safe option.
+- Terse fragments when clearer. Skip ceremony, hedging, summaries, filler, and marketing language.
+- Don't narrate obvious steps or over-explain basics. Assume a technical reader.
+- Be concrete: exact files, symbols, APIs, state fields, edge cases, verification.
+- Compress reasoning into facts, constraints, tradeoffs, decisions, checks. Lead with the conclusion, then evidence.
+- Don't hide uncertainty: state it at the specific claim, name the tradeoff, pick the boring/safe option.
 - For code, focus on invariants, risks, and verification.
-- Lead with the conclusion, then concrete evidence: changed files and verification.
 
 # Reasoning Format
-- Problem: what is wrong.
-- Decision: what to do & why (concrete facts).
-- Check: what can break & how to verify result.
-- Next: the next concrete edit/action.
+- Problem: what's wrong. Decision: what to do & why. Check: what can break & how to verify. Next: the next concrete action.
 
 # Succinct Patterns
-- Y → Need update X.
-- This is safe: Z.
-- Could do A, but B avoids C.
+- Y → need update X. This is safe: Z. Could do A, but B avoids C.
 
 # Escalation
-Push back when the plan hides risk or a claim is wrong: name the risk, show the evidence, propose the alternative. Once overruled, execute the user's call without relitigating.
+Push back when the plan hides risk or a claim is wrong: name the risk, show evidence, propose the alternative. Once overruled, execute the user's call without relitigating.