@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/status-line/separators.ts

@@ -1,10 +1,6 @@
 import type { Theme } from "../theme";
 import type { SeparatorDef, StatusLineSeparatorStyle } from "./types";
 
-function trimSep(value: string): string {
-	return value.trim();
-}
-
 export function getSeparator(style: StatusLineSeparatorStyle, theme: Theme): SeparatorDef {
 	switch (style) {
 		case "powerline":
@@ -17,22 +13,12 @@ export function getSeparator(style: StatusLineSeparatorStyle, theme: Theme): Sep
 					useBgAsFg: true,
 				},
 			};
-		case "powerline-thin":
-			return {
-				left: theme.sep.powerlineThinLeft,
-				right: theme.sep.powerlineThinRight,
-				endCaps: {
-					left: theme.sep.powerlineRight,
-					right: theme.sep.powerlineLeft,
-					useBgAsFg: true,
-				},
-			};
 		case "slash": {
-			const slash = trimSep(theme.sep.slash);
+			const slash = theme.sep.slash.trim();
 			return { left: slash, right: slash };
 		}
 		case "pipe": {
-			const pipe = trimSep(theme.sep.pipe);
+			const pipe = theme.sep.pipe.trim();
 			return { left: pipe, right: pipe };
 		}
 		case "block":
@@ -41,6 +27,7 @@ export function getSeparator(style: StatusLineSeparatorStyle, theme: Theme): Sep
 			return { left: theme.sep.space, right: theme.sep.space };
 		case "ascii":
 			return { left: theme.sep.asciiLeft, right: theme.sep.asciiRight };
+		// "powerline-thin" is also the fallback for unknown styles.
 		default:
 			return {
 				left: theme.sep.powerlineThinLeft,

package/src/status-line/types.ts

@@ -1,5 +1,6 @@
 import type { Model } from "@oh-my-pi/pi-ai";
-import type { SessionState } from "@oh-my-pi/pi-wire";
+import type { SessionState, TspSpan, TspTone } from "@oh-my-pi/pi-wire";
+import type { NativeNode, NativeUiEvent } from "../native/node";
 import type { ContextLineMode, StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "./schema";
 import type { ActiveRepoContext, StatusLineSession } from "./host";
 import type { LoopConditionConfig, LoopLimitRuntime } from "./loop";
@@ -203,9 +204,50 @@ export interface RenderedSegment {
 	visible: boolean; // Whether to render (e.g., git hidden when not in repo)
 }
 
+/**
+ * A segment described for a TSP terminal: styled spans (theme/semantic
+ * tokens, no ANSI), a named icon, a tone, and terminal-clocked nodes
+ * (`spinner`, `elapsed`, `rate`) laid out after the spans.
+ */
+export interface SegmentView {
+	readonly spans: readonly TspSpan[];
+	readonly icon?: string;
+	readonly tone?: TspTone;
+	readonly motion?: readonly NativeNode[];
+	/** Tooltip on the segment. */
+	readonly title?: string;
+}
+
+/**
+ * The status line's facts for the native composer. A TSP terminal shows no
+ * status strip: the tab title carries the session, the pane header the path
+ * and branch, and the composer the rest.
+ */
+export interface ComposerFacts {
+	/** `meter` (role `omp.composer.context`): context usage along the composer's top edge. */
+	readonly context: NativeNode;
+	/** The model chip's label: name plus the advisor, fast-mode and slow-mode marks. */
+	readonly model: SegmentView;
+	/**
+	 * `status` (role `omp.composer.extras`, `grow: 1`) of the other configured
+	 * segments as `seg`s; the bar's flexible space, so present even when empty.
+	 */
+	readonly extras: NativeNode;
+	/** `text` (role `omp.composer.usage`): the context share of the window and the session cost. */
+	readonly usage: NativeNode;
+}
+
+/** Supplies {@link ComposerFacts} and takes the clicks on them (`status.*` actions). */
+export interface ComposerFactsSource {
+	describeComposerFacts(): ComposerFacts;
+	handleNativeEvent(event: NativeUiEvent): void;
+}
+
 export interface StatusLineSegment {
 	id: StatusLineSegmentId;
 	render(ctx: SegmentContext): RenderedSegment;
+	/** Native description; null when the segment is hidden. */
+	describe(ctx: SegmentContext): SegmentView | null;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/stdin-buffer.ts

@@ -424,11 +424,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#rawPasteCandidate = "";
 	#rawPasteTimer?: NodeJS.Timeout;
 	// Unbracketed raw-paste classification is a fallback for terminals that do
-	// not wrap pastes in DECSET 2004 markers. When the terminal confirms mode
-	// 2004 support, a genuine paste always arrives bracketed, so the heuristic
-	// can only misfire on keystrokes an event-loop stall batched into one read
-	// (issue #12540) — Terminal disables it via `setRawPasteClassification`.
-	#rawPasteClassificationEnabled = true;
+	// not wrap pastes in DECSET 2004 markers. Once the terminal confirms mode
+	// 2004, Terminal installs this probe: an unmarked multiline burst is then
+	// an input-method commit (#13344) unless an event-loop stall batched the
+	// keystrokes into one read (#12540). See `setRawPasteStallProbe`.
+	#rawPasteStallProbe?: () => boolean;
 	#stringDiscardActive = false;
 	#stringDiscardBytes = 0;
 	#stringDiscardEscHeld = false;
@@ -491,14 +491,13 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			} else {
 				this.#rawPasteCandidate += str;
 				if (isRawMultilineBurst(this.#rawPasteCandidate)) {
-					this.#emitRawPasteCandidate();
+					this.#classifyRawPasteCandidate();
 				}
 				return;
 			}
 		}
 
 		if (
-			this.#rawPasteClassificationEnabled &&
 			this.#buffer.length === 0 &&
 			str.indexOf(ESC) === -1 &&
 			(str.indexOf("\r") !== -1 || str.indexOf("\n") !== -1)
@@ -508,7 +507,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			// Enter is replayed unchanged when the fixed window expires.
 			this.#rawPasteCandidate = str;
 			if (isRawMultilineBurst(str)) {
-				this.#emitRawPasteCandidate();
+				this.#classifyRawPasteCandidate();
 			} else {
 				this.#armRawPasteTimer();
 			}
@@ -649,18 +648,18 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	}
 
 	/**
-	 * Enable or disable unbracketed raw-paste classification. Terminal disables
-	 * it once DECRQM confirms bracketed-paste (mode 2004) support: a genuine
-	 * paste then always arrives wrapped, so the heuristic can only misfire on
-	 * keystrokes an event-loop stall batched into one read (issue #12540).
-	 * Disabling flushes any candidate already held by the classification window
-	 * as ordinary key events so no buffered input is lost.
+	 * Gate unbracketed raw-paste classification on event-loop responsiveness.
+	 * Terminal installs a probe once DECRQM confirms bracketed-paste (mode
+	 * 2004) support: a genuine paste then always arrives wrapped, so an
+	 * unmarked multiline burst is either an input-method commit — IME,
+	 * dictation, and emoji commits are typed input, never bracketed (#13344) —
+	 * or keystrokes an event-loop stall batched into one read (#12540). A burst
+	 * classified while `stalled()` reports a stall is replayed as the original
+	 * keys so every Enter submits; otherwise it is delivered as one paste.
+	 * `undefined` restores unconditional classification.
 	 */
-	setRawPasteClassification(enabled: boolean): void {
-		this.#rawPasteClassificationEnabled = enabled;
-		if (!enabled && this.#rawPasteCandidate.length > 0) {
-			this.#flushRawPasteCandidate();
-		}
+	setRawPasteStallProbe(stalled: (() => boolean) | undefined): void {
+		this.#rawPasteStallProbe = stalled;
 	}
 
 	/** Start one fixed window from the first break-bearing raw read. */
@@ -686,8 +685,15 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		return content;
 	}
 
-	/** Emit a classified raw multiline burst through the paste channel. */
-	#emitRawPasteCandidate(): void {
+	/**
+	 * Deliver a classified raw multiline burst: one paste, or the original
+	 * keys when the stall probe says a blocked loop batched typed input.
+	 */
+	#classifyRawPasteCandidate(): void {
+		if (this.#rawPasteStallProbe?.()) {
+			this.#flushRawPasteCandidate();
+			return;
+		}
 		const content = this.#takeRawPasteCandidate();
 		this.#pendingKittyPrintableCodepoint = undefined;
 		this.emit("paste", content);

package/src/terminal-capabilities.ts

@@ -39,6 +39,7 @@ export type TerminalId =
 	| "orca"
 	| "otty"
 	| "rio"
+	| "tern"
 	| "base"
 	| "trueColor";
 
@@ -698,6 +699,11 @@ const KNOWN_TERMINALS = Object.freeze({
 	// OSC 99, and OSC 66 text sizing are outside rio's supported set and keep
 	// the conservative defaults.
 	rio: new TerminalInfo("rio", ImageProtocol.Kitty, true, true),
+	// Tern (Stencil's terminal, `stencil-term`) sets TERM_PROGRAM=tern and
+	// implements Kitty graphics, OSC 8 and OSC 9/99 notifications. Whether omp
+	// renders natively (Tern Surface Protocol) is decided by the `hello`
+	// handshake alone, never by this identity.
+	tern: new TerminalInfo("tern", ImageProtocol.Kitty, true, true, NotifyProtocol.Osc99),
 });
 
 /** Resolve terminal identity from environment markers used by common emulators. */
@@ -718,6 +724,7 @@ export function detectTerminalId(env: NodeJS.ProcessEnv = Bun.env): TerminalId {
 		if (caseEq(program, "orca")) return "orca";
 		if (caseEq(program, "otty")) return "otty";
 		if (caseEq(program, "rio")) return "rio";
+		if (caseEq(program, "tern")) return "tern";
 		return null;
 	}
 

package/src/terminal.ts

@@ -5,6 +5,7 @@ import { $env, isBunTestRuntime, isTerminalHeadless, isWsl } from "@oh-my-pi/pi-
 import * as logger from "@oh-my-pi/pi-utils/logger";
 import * as postmortem from "@oh-my-pi/pi-utils/postmortem";
 import { restoreTerminalStderr, suppressTerminalStderr } from "@oh-my-pi/pi-utils/stderr-guard";
+import { TSP_VERSION } from "@oh-my-pi/pi-wire";
 import {
 	encodeBundledGlyphRegistrations,
 	encodeGlyphCoverageQuery,
@@ -14,6 +15,7 @@ import {
 	parseGlyphProtocolReply,
 } from "./glyph-protocol";
 import { setKittyProtocolActive } from "./keys";
+import { encodeTspHelloQuery, parseTspMessage, TSP_PREFIX, type TspHello } from "./native/encode";
 import { StdinBuffer } from "./stdin-buffer";
 import {
 	isInsideTerminalMultiplexer,
@@ -460,6 +462,15 @@ export interface TerminalStartOptions {
 	 * echoes even while module loading blocks the event loop.
 	 */
 	deferInput?: boolean;
+	/**
+	 * Reports whether the event loop is stalled or just recovered from a
+	 * stall. Once the terminal confirms bracketed paste, an unmarked multiline
+	 * burst is an input-method commit (IME, dictation) delivered as one paste
+	 * on a responsive loop, but keystrokes a stall batched into one read —
+	 * replayed as keys so Enter submits — while this returns true. Without a
+	 * probe every such burst is treated as an input-method commit.
+	 */
+	isLoopStalled?: () => boolean;
 }
 /** Identity of an accepted explicit terminal appearance refresh request. */
 export type TerminalAppearanceRequestToken = number;
@@ -477,6 +488,12 @@ export type PrivateModeReportHandler = (mode: number, supported: boolean, confir
  * glossary, so a host can safely repaint — or switch to the nerd preset.
  */
 export type GlyphProtocolReportHandler = (supported: boolean) => void;
+/**
+ * Outcome of the Tern Surface Protocol `hello` probe: the terminal's reply,
+ * or null when it answered the DA1 sentinel first (no TSP) or the probe was
+ * skipped (`PI_TUI_NATIVE=0`, multiplexers).
+ */
+export type TspHelloHandler = (hello: TspHello | null) => void;
 
 /**
  * Cursor shapes addressable via DECSCUSR (`CSI <n> SP q`). `"default"` (0) hands the shape back to
@@ -645,6 +662,23 @@ export interface Terminal {
 	 * pi-tui versions keep working.
 	 */
 	onGlyphProtocolReport?(callback: GlyphProtocolReportHandler): void;
+	/**
+	 * Register a callback fired once the Tern Surface Protocol `hello` probe
+	 * resolves (see {@link TspHelloHandler}); a resolved outcome is replayed to
+	 * late subscribers. TSP events arriving afterwards are delivered through
+	 * `onInput` as complete `ESC _ tsp;e;… ESC \` strings. Optional so custom
+	 * Terminals built against older pi-tui versions keep working.
+	 */
+	onTspHello?(callback: TspHelloHandler): void;
+	/** True while the `hello` probe awaits its reply or DA1 sentinel. */
+	readonly tspProbePending?: boolean;
+	/**
+	 * The environment names a Tern Surface Protocol terminal
+	 * (`TERM_PROGRAM=tern`) and the `hello` probe will run: the TUI takes input
+	 * at start and opens its surface before the reply, which then confirms or
+	 * revokes it.
+	 */
+	readonly tspExpected?: boolean;
 }
 
 /**
@@ -667,7 +701,8 @@ type Da1SentinelOwner =
 	| { kind: "osc11" }
 	| { kind: "privateMode"; mode: number }
 	| { kind: "osc99Probe"; id: string }
-	| { kind: "glyphProtocol"; phase: "support" | "confirm" };
+	| { kind: "glyphProtocol"; phase: "support" | "confirm" }
+	| { kind: "tsp" };
 
 let nextOsc99ProbeId = 1;
 
@@ -717,6 +752,7 @@ export class ProcessTerminal implements Terminal {
 	#resizeHandler?: () => void;
 	/** True between a `deferInput` start() and enableInput(). */
 	#inputDeferred = false;
+	#isLoopStalled?: () => boolean;
 	#stdoutResizeListener?: () => void;
 	#kittyProtocolActive = false;
 	#kittyEnableSeq: string | null = null;
@@ -803,6 +839,10 @@ export class ProcessTerminal implements Terminal {
 	#glyphProtocolReplyBuffer = "";
 	#glyphProtocolResult: boolean | undefined;
 	#glyphProtocolCallbacks: GlyphProtocolReportHandler[] = [];
+	#tspPending = false;
+	#tspResult: TspHello | null | undefined;
+	#tspCallbacks: TspHelloHandler[] = [];
+	#tspReplyBuffer = "";
 	#privateCsiResponseBuffer = "";
 	#da1SentinelOwners: Da1SentinelOwner[] = [];
 	/** Resolved DECRQM support per private mode (mode → supported). */
@@ -914,6 +954,26 @@ export class ProcessTerminal implements Terminal {
 		if (this.#glyphProtocolResult !== undefined) callback(this.#glyphProtocolResult);
 	}
 
+	onTspHello(callback: TspHelloHandler): void {
+		this.#tspCallbacks.push(callback);
+		if (this.#tspResult !== undefined) callback(this.#tspResult);
+	}
+
+	get tspProbePending(): boolean {
+		return this.#tspPending;
+	}
+
+	get tspExpected(): boolean {
+		// A multiplexer started from Tern can leave `TERM_PROGRAM=tern` behind
+		// while swallowing APC, even when `PI_TUI_NATIVE=1` forces the probe.
+		return (
+			$env.TERM_PROGRAM?.toLowerCase() === "tern" &&
+			!isInsideTerminalMultiplexer($env) &&
+			!isTerminalHeadless() &&
+			this.#shouldQueryTspSupport()
+		);
+	}
+
 	start(
 		onInput: (data: string) => void,
 		onResize: () => void,
@@ -923,6 +983,7 @@ export class ProcessTerminal implements Terminal {
 		this.#inputHandler = onInput;
 		this.#resizeHandler = onResize;
 		this.#disconnectHandler = onDisconnect;
+		this.#isLoopStalled = options?.isLoopStalled;
 		// The host terminal's cursor visibility is unknown until we write it.
 		this.#cursorVisible = undefined;
 
@@ -1055,6 +1116,10 @@ export class ProcessTerminal implements Terminal {
 		// without a patched font installed.
 		this.#queryGlyphProtocolSupport();
 
+		// Tern Surface Protocol `hello`, same DA1 sentinel FIFO. A reply switches
+		// the TUI to describing its UI instead of painting rows.
+		this.#queryTspSupport();
+
 		// Subscribe to Mode 2031 appearance change notifications.
 		// When the terminal reports a change, we re-query OSC 11 to get the
 		// actual background color (following Neovim convention) with 100ms debounce.
@@ -1081,9 +1146,10 @@ export class ProcessTerminal implements Terminal {
 		this.#queryPrivateMode(2048);
 		this.#queryPrivateMode(2031);
 		// 2004 (bracketed paste) is queried only to confirm the terminal brackets
-		// pastes; once confirmed, the unbracketed raw-paste heuristic in
-		// StdinBuffer is disabled so keystrokes an event-loop stall batches into
-		// one read are never misclassified as a paste (#12540).
+		// pastes; once confirmed, StdinBuffer's unbracketed raw-paste heuristic
+		// consults the host's stall probe so keystrokes an event-loop stall
+		// batches into one read stay keys (#12540) while input-method commits
+		// still land as one paste (#13344).
 		this.#queryPrivateMode(2004);
 		for (const mode of XTERM_SCROLL_TO_BOTTOM_MODES) {
 			this.#queryPrivateMode(mode);
@@ -1198,7 +1264,8 @@ export class ProcessTerminal implements Terminal {
 				this.#inBandResizeBuffer.length === 0 &&
 				this.#osc11ResponseBuffer.length === 0 &&
 				this.#osc99ResponseBuffer.length === 0 &&
-				this.#glyphProtocolReplyBuffer.length === 0
+				this.#glyphProtocolReplyBuffer.length === 0 &&
+				this.#tspReplyBuffer.length === 0
 			) {
 				if (this.#inputHandler) {
 					this.#inputHandler(sequence);
@@ -1364,6 +1431,11 @@ export class ProcessTerminal implements Terminal {
 						if (owner.phase === this.#glyphProtocolPhase) this.#resolveGlyphProtocolSupport(false);
 						break;
 					}
+					case "tsp": {
+						// DA1 before any `tsp;r` reply: the terminal doesn't speak TSP.
+						this.#resolveTspSupport(null);
+						break;
+					}
 				}
 				return;
 			}
@@ -1448,6 +1520,22 @@ export class ProcessTerminal implements Terminal {
 				}
 			}
 
+			// Tern Surface Protocol APC (`ESC _ tsp ; … ESC \`): the hello reply
+			// resolves the probe; events go to the input handler whole, where the
+			// TUI routes them to the native backend before key matching.
+			if (this.#tspReplyBuffer || sequence.startsWith(TSP_PREFIX)) {
+				if (this.#tspReplyBuffer && sequence.startsWith("\x1b") && sequence !== "\x1b\\") {
+					this.#tspReplyBuffer = "";
+				} else {
+					this.#tspReplyBuffer += sequence;
+					if (!this.#tspReplyBuffer.endsWith("\x1b\\")) return;
+					const message = this.#tspReplyBuffer;
+					this.#tspReplyBuffer = "";
+					this.#handleTspMessage(message);
+					return;
+				}
+			}
+
 			// Glyph Protocol APC replies (`ESC _ 25a1 ; … ESC \`). Swallowed for
 			// the whole session, not just while the probe is outstanding: an APC is
 			// exclusively terminal->host data, and registrations use `reply=0`, so
@@ -1657,6 +1745,54 @@ export class ProcessTerminal implements Terminal {
 		}
 	}
 
+	#shouldQueryTspSupport(): boolean {
+		const override = $env.PI_TUI_NATIVE;
+		if (override === "0") return false;
+		if (override === "1") return true;
+		// Multiplexers swallow APC, so the reply could never arrive.
+		if (isInsideTerminalMultiplexer($env)) return false;
+		return !isBunTestRuntime();
+	}
+
+	#queryTspSupport(): void {
+		this.#tspPending = false;
+		this.#tspResult = undefined;
+		this.#tspReplyBuffer = "";
+		if (this.#dead) return;
+		if (!this.#shouldQueryTspSupport()) {
+			this.#tspResult = null;
+			for (const cb of this.#tspCallbacks) cb(null);
+			return;
+		}
+		this.#tspPending = true;
+		this.#da1SentinelOwners.push({ kind: "tsp" });
+		this.#safeWrite(`${encodeTspHelloQuery()}\x1b[c`);
+	}
+
+	#handleTspMessage(sequence: string): void {
+		const message = parseTspMessage(sequence);
+		if (message?.verb === "r") {
+			if (message.reply.r === "hello") this.#resolveTspSupport(message.reply);
+			return;
+		}
+		this.#inputHandler?.(sequence);
+	}
+
+	#resolveTspSupport(hello: TspHello | null): void {
+		if (!this.#tspPending) return;
+		this.#tspPending = false;
+		const result = hello !== null && hello.v === TSP_VERSION ? hello : null;
+		if (hello !== null && result === null) logger.warn("TSP: unsupported protocol version", { v: hello.v });
+		this.#tspResult = result;
+		for (const cb of this.#tspCallbacks) {
+			try {
+				cb(result);
+			} catch (error) {
+				logger.warn("TSP: hello subscriber failed", { error: String(error) });
+			}
+		}
+	}
+
 	/** Finish the handshake in either phase and notify subscribers once. */
 	#resolveGlyphProtocolSupport(supported: boolean): void {
 		if (this.#glyphProtocolPhase === "idle") return;
@@ -1774,15 +1910,17 @@ export class ProcessTerminal implements Terminal {
 		}
 		if (mode === 2048 && supported) this.#enableInBandResize();
 		if (mode === 2031) this.#syncWindowsTerminalAppearancePolling(supported);
-		// Confirmed bracketed-paste support makes the unbracketed raw-paste
-		// heuristic pure downside — turn it off so stall-batched keystrokes are
-		// not misread as a paste (#12540). `supported` is only true here after an
-		// explicit DECRPM reply (the DA1-sentinel fallback resolves unsupported).
+		// Confirmed bracketed-paste support means a genuine paste arrives
+		// wrapped, so an unmarked multiline burst is an input-method commit
+		// (#13344) unless an event-loop stall batched typed keys into one read
+		// (#12540). Let the host's stall probe decide per burst. `supported` is
+		// only true here after an explicit DECRPM reply (the DA1-sentinel
+		// fallback resolves unsupported).
 		if (mode === 2004 && supported) {
-			this.#stdinBuffer?.setRawPasteClassification(false);
+			this.#stdinBuffer?.setRawPasteStallProbe(this.#isLoopStalled);
 			// A terminal can reset this mode after the initial probe (for example,
 			// iTerm2's Terminal State toggle). Keep the mode asserted while we own
-			// the TTY, since the raw fallback is disabled after confirmation.
+			// the TTY, since a stalled loop now replays unmarked bursts as keys.
 			this.#bracketedPasteRefreshTimer ??= setInterval(() => {
 				if (this.#active && !this.#dead) this.#safeWrite("\x1b[?2004h");
 			}, 1000);
@@ -2003,6 +2141,10 @@ export class ProcessTerminal implements Terminal {
 		this.#glyphProtocolReplyBuffer = "";
 		this.#glyphProtocolCallbacks = [];
 		setTerminalGlyphProtocol(false);
+		this.#tspPending = false;
+		this.#tspResult = undefined;
+		this.#tspReplyBuffer = "";
+		this.#tspCallbacks = [];
 		this.#privateCsiResponseBuffer = "";
 		this.#inBandResizeBuffer = "";
 		this.#da1SentinelOwners.length = 0;

package/src/theme/defaults/dark-neon-noir.json

@@ -0,0 +1,100 @@
+{
+	"$schema": "https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/theme-schema.json",
+	"name": "dark-neon-noir",
+	"vars": {
+		"magenta": "#ff2bd6",
+		"hotMagenta": "#ff4f9a",
+		"deepMagenta": "#8f1a78",
+		"cyan": "#00e5ff",
+		"paleCyan": "#8ff4ff",
+		"deepCyan": "#0a6f80",
+		"violet": "#a35cff",
+		"amber": "#ffc857",
+		"ash": "#d8d8e0",
+		"smoke": "#8a8a96",
+		"soot": "#4a4a55",
+		"black": "#050507",
+		"panelBg": "#0d0d12",
+		"selectedBg": "#1c0b1c",
+		"userMsgBg": "#0b1418",
+		"toolPendingBg": "#0d0d12",
+		"toolSuccessBg": "#06141a",
+		"toolErrorBg": "#1f0612",
+		"customMsgBg": "#140a18"
+	},
+	"colors": {
+		"accent": "magenta",
+		"border": "deepMagenta",
+		"borderAccent": "cyan",
+		"borderMuted": "soot",
+		"success": "cyan",
+		"error": "hotMagenta",
+		"warning": "amber",
+		"muted": "smoke",
+		"dim": "soot",
+		"text": "",
+		"thinkingText": "smoke",
+		"selectedBg": "selectedBg",
+		"userMessageBg": "userMsgBg",
+		"userMessageText": "",
+		"customMessageBg": "customMsgBg",
+		"customMessageText": "",
+		"customMessageLabel": "magenta",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolText": "",
+		"toolTitle": "",
+		"toolOutput": "smoke",
+		"mdHeading": "magenta",
+		"mdLink": "cyan",
+		"mdLinkUrl": "deepCyan",
+		"mdCode": "paleCyan",
+		"mdCodeBlock": "ash",
+		"mdCodeBlockBorder": "deepMagenta",
+		"mdQuote": "smoke",
+		"mdQuoteBorder": "deepMagenta",
+		"mdHr": "soot",
+		"mdListBullet": "magenta",
+		"toolDiffAdded": "cyan",
+		"toolDiffRemoved": "hotMagenta",
+		"toolDiffContext": "smoke",
+		"link": "cyan",
+		"syntaxComment": "soot",
+		"syntaxKeyword": "magenta",
+		"syntaxFunction": "cyan",
+		"syntaxVariable": "ash",
+		"syntaxString": "paleCyan",
+		"syntaxNumber": "amber",
+		"syntaxType": "violet",
+		"syntaxOperator": "hotMagenta",
+		"syntaxPunctuation": "smoke",
+		"thinkingOff": "soot",
+		"thinkingMinimal": "smoke",
+		"thinkingLow": "deepCyan",
+		"thinkingMedium": "cyan",
+		"thinkingHigh": "magenta",
+		"thinkingXhigh": "hotMagenta",
+		"bashMode": "cyan",
+		"statusLineBg": "black",
+		"statusLineSep": 238,
+		"statusLineModel": "magenta",
+		"statusLinePath": "cyan",
+		"statusLineGitClean": "cyan",
+		"statusLineGitDirty": "amber",
+		"statusLineContext": "violet",
+		"statusLineSpend": "ash",
+		"statusLineStaged": "cyan",
+		"statusLineDirty": "amber",
+		"statusLineUntracked": "hotMagenta",
+		"statusLineOutput": "magenta",
+		"statusLineCost": "paleCyan",
+		"statusLineSubagents": "magenta",
+		"pythonMode": "amber"
+	},
+	"export": {
+		"pageBg": "#050507",
+		"cardBg": "#0d0d12",
+		"infoBg": "#1c0b1c"
+	}
+}

package/src/theme/defaults/index.ts

@@ -25,6 +25,7 @@ import dark_midnight from "./dark-midnight.json" with { type: "json" };
 import dark_monochrome from "./dark-monochrome.json" with { type: "json" };
 import dark_monokai from "./dark-monokai.json" with { type: "json" };
 import dark_nebula from "./dark-nebula.json" with { type: "json" };
+import dark_neon_noir from "./dark-neon-noir.json" with { type: "json" };
 import dark_nord from "./dark-nord.json" with { type: "json" };
 import dark_ocean from "./dark-ocean.json" with { type: "json" };
 import dark_one from "./dark-one.json" with { type: "json" };
@@ -126,6 +127,7 @@ export const defaultThemes = {
 	"dark-monochrome": dark_monochrome,
 	"dark-monokai": dark_monokai,
 	"dark-nebula": dark_nebula,
+	"dark-neon-noir": dark_neon_noir,
 	"dark-nord": dark_nord,
 	"dark-ocean": dark_ocean,
 	"dark-one": dark_one,

package/src/theme/defaults/light-prism.json

@@ -25,7 +25,7 @@
 		"muted": "slate",
 		"dim": "dim",
 		"text": "",
-		"thinkingText": "muted",
+		"thinkingText": "slate",
 		"selectedBg": "#f2f5fb",
 		"userMessageBg": "#ffffff",
 		"userMessageText": "",
@@ -36,20 +36,20 @@
 		"toolSuccessBg": "#effaf2",
 		"toolErrorBg": "#fceeee",
 		"toolTitle": "",
-		"toolOutput": "muted",
+		"toolOutput": "slate",
 		"mdHeading": "indigo",
 		"mdLink": "blue",
 		"mdLinkUrl": "dim",
 		"mdCode": "violet",
 		"mdCodeBlock": "slate",
 		"mdCodeBlockBorder": "#e1e4ea",
-		"mdQuote": "muted",
+		"mdQuote": "slate",
 		"mdQuoteBorder": "#e1e4ea",
 		"mdHr": "#e1e4ea",
 		"mdListBullet": "cyan",
 		"toolDiffAdded": "green",
 		"toolDiffRemoved": "red",
-		"toolDiffContext": "muted",
+		"toolDiffContext": "slate",
 		"syntaxComment": "dim",
 		"syntaxKeyword": "indigo",
 		"syntaxFunction": "blue",
@@ -72,7 +72,7 @@
 		"statusLinePath": "blue",
 		"statusLineGitClean": "green",
 		"statusLineGitDirty": "orange",
-		"statusLineContext": "muted",
+		"statusLineContext": "slate",
 		"statusLineSpend": "cyan",
 		"statusLineStaged": "green",
 		"statusLineDirty": "orange",