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

package/src/prompt/custom-editor.ts

@@ -2,12 +2,21 @@ import * as url from "node:url";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { BracketedPasteHandler } from "../bracketed-paste";
 import { BRACKETED_PASTE_END, BRACKETED_PASTE_START } from "../stdin-buffer";
-import { Editor, type EditorTextDecorationContext, type EditorTheme } from "../components/editor";
+import {
+	Editor,
+	type EditorTextDecorationContext,
+	type EditorTheme,
+	type NativeEditorLayout,
+} from "../components/editor";
 import { addKeyAliases, canonicalKeyId, getKeybindings } from "../keybindings";
 import { type KeyId, parseKey, parseKittySequence } from "../keys";
 import { SpaceHoldGesture } from "../space-hold";
-import { TUI } from "../tui";
+import { type Component, TUI } from "../tui";
 import type { AppKeybinding } from "../app-keybindings";
+import { formatKeyHint } from "../key-hint-format";
+import { compact, keyed, node, row, span } from "../native/describe";
+import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node";
+import type { ComposerFacts, ComposerFactsSource } from "../status-line/types";
 import { allowsModelMentions, allowsSkillTokens, SKILL_TOKEN_RE } from "./skill-tokens";
 import { expandModelMentionTags, MODEL_MENTION_RE, modelMentionToken } from "./model-mention-syntax";
 import { imageAttachmentSource } from "./image-source";
@@ -30,11 +39,42 @@ import {
 	skillToken,
 } from "./composer-attachments";
 import { type MacOSSpellingFeatures, MacOSSpellingProvider } from "./macos-spelling";
-import { hasMagicKeyword, highlightMagicKeywords } from "./magic-keywords";
+import { hasMagicKeyword, highlightMagicKeywords, magicKeywordRanges } from "./magic-keywords";
+import type { TspEditorDecoration } from "@oh-my-pi/pi-wire";
+import { isNativeRendering } from "../native/state";
 import { isQueuedMessageList, parseQueueShorthand, QUEUE_LIST_MARKER_RE } from "./queue-input";
 import { type WordCompletionMethod, WordCompletionProvider } from "./word-completion";
 import { fgOrPlain, theme } from "../theme/theme";
 
+/** A shell-mode draft's sigil (`!`, `!!`, `$`, `$$`) with its surrounding blanks; the mode chip stands in for it natively. */
+const SHELL_SIGIL_RE = /^\s*(?:!!?|\$\$?)[ \t]?/;
+
+/** The composer's TSP placeholder; the rotating ANSI hints (thinking effort, …) move into control tooltips. */
+const NATIVE_COMPOSER_PLACEHOLDER = "Ask omp — / commands · @ files · ! bash";
+
+/** Live composer state the TSP layout shows; the interactive host wires {@link CustomEditor.composerState}. */
+export interface ComposerNativeState {
+	/** The draft runs as a shell command (`!`, `!!`) or Python (`$`, `$$`); `excluded` keeps it from the model. */
+	readonly shell?: { readonly kind: "bash" | "python"; readonly excluded: boolean };
+	/** Thinking effort word (`high`, `off`, `auto`); undefined when the model has no thinking. */
+	readonly thinking?: string;
+	/** A turn is running: the send keycap becomes a Stop button. */
+	readonly running: boolean;
+}
+
+const IDLE_COMPOSER: ComposerNativeState = { running: false };
+
+/** Filled steps (of four) of the effort chip's meter per thinking level; `auto` before it resolves has none known. */
+const EFFORT_STEPS: Partial<Record<string, number>> = {
+	off: 0,
+	minimal: 1,
+	low: 1,
+	medium: 2,
+	high: 3,
+	xhigh: 4,
+	max: 4,
+};
+
 /** Independently switchable prose-assistance features of the composer. */
 export interface SpellingFeatures extends MacOSSpellingFeatures {
 	/** Word-completion engine; `off` disables ghost text. */
@@ -838,6 +878,67 @@ export class CustomEditor extends Editor {
 		);
 	};
 
+	/**
+	 * TSP decorations: magic keywords shimmer (terminal-clocked) in the accent
+	 * color, chips and markers take their token colors, misspellings are marked,
+	 * and queue-composer markers are dimmed/accented, all as ranges over the raw
+	 * buffer instead of painted text. A shell-mode draft is code: only its sigil
+	 * is decorated, hidden behind the mode chip.
+	 */
+	override describeDecorations = (lines: readonly string[]): readonly TspEditorDecoration[] => {
+		const text = lines.join("\n");
+		if (this.composerState().shell) {
+			const sigil = SHELL_SIGIL_RE.exec(text)?.[0].length ?? 0;
+			return sigil > 0 ? [{ from: 0, to: sigil, s: "hide" }] : [];
+		}
+		this.#syncComposerTokenPattern();
+		const decor: TspEditorDecoration[] = [];
+		let offset = 0;
+		const mark = (length: number, s: string): string => {
+			decor.push({ from: offset, to: offset + length, s });
+			offset += length;
+			return "";
+		};
+		renderPlaceholders(
+			text,
+			{
+				renderText: value => {
+					offset += value.length;
+					return "";
+				},
+				renderSkill: label => mark(label.length, "customMessageLabel strong"),
+				renderMention: label => mark(label.length, "statusLineModel strong"),
+				renderReference: value => mark(value.length, "accent strong"),
+			},
+			this.atomicTokenPattern,
+		);
+
+		const fx = this.#shimmerEnabled() ? "shimmer" : undefined;
+		for (const range of magicKeywordRanges(text)) decor.push({ ...range, s: "accent", fx });
+
+		const queueBody = parseQueueShorthand(text);
+		const queueList = queueBody !== undefined && isQueuedMessageList(queueBody);
+		let lineStart = 0;
+		for (let line = 0; line < lines.length; line++) {
+			const value = lines[line] ?? "";
+			if (queueBody !== undefined && (value.startsWith("->") || value.startsWith("=>"))) {
+				decor.push({ from: lineStart, to: lineStart + 2, s: "dim" });
+			}
+			if (queueList) {
+				const marker = QUEUE_LIST_MARKER_RE.exec(value);
+				if (marker) {
+					const indent = marker[1]?.length ?? 0;
+					decor.push({ from: lineStart + indent, to: lineStart + marker[0].length, s: "accent" });
+				}
+			}
+			for (const typo of this.#spelling.typoRanges(value, { editorText: text, lines, line, startCol: 0 })) {
+				decor.push({ from: lineStart + typo.start, to: lineStart + typo.start + typo.length, s: "mark" });
+			}
+			lineStart += value.length + 1;
+		}
+		return decor.sort((a, b) => a.from - b.from);
+	};
+
 	/** Optional test override for the magic-keyword shimmer gate. */
 	magicKeywordsEnabledOverride: boolean | undefined;
 
@@ -877,13 +978,210 @@ export class CustomEditor extends Editor {
 	 *  decides whether to schedule another, so the chain stops by itself when
 	 *  `focused` flips off or the keyword leaves the buffer. */
 	#scheduleShimmerFrame(): void {
-		if (this.#shimmerTimer || !this.#requestShimmerRepaint) return;
+		// A TSP terminal animates the keyword shimmer from `describeDecorations`.
+		if (this.#shimmerTimer || !this.#requestShimmerRepaint || isNativeRendering()) return;
 		this.#shimmerTimer = setTimeout(() => {
 			this.#shimmerTimer = undefined;
 			this.#requestShimmerRepaint?.();
 		}, CustomEditor.SHIMMER_FRAME_MS);
 		this.#shimmerTimer.unref?.();
 	}
+	override nativePlaceholder: string | undefined = NATIVE_COMPOSER_PLACEHOLDER;
+	/** A shell-mode draft highlights as its language. */
+	override describeLanguage = (): string | undefined => this.composerState().shell?.kind;
+	/** Host-owned live state for the TSP composer (shell mode, effort chip, send/stop). */
+	composerState: () => ComposerNativeState = () => IDLE_COMPOSER;
+	/** The attachment band, described inside the composer on a TSP terminal (ANSI renders it above). */
+	attachmentChips: Component | undefined;
+	/** The status line's facts the TSP composer carries (context, model, usage, the other segments). */
+	composerFacts: ComposerFactsSource | undefined;
+	#nativeComposer:
+		| {
+				key: string;
+				facts: ComposerFacts | undefined;
+				chips: Component | undefined;
+				input: NativeNode;
+				mode: NativeNode | undefined;
+				bar: NativeNode;
+				layout: NativeEditorLayout;
+		  }
+		| undefined;
+
+	/**
+	 * The TSP composer: role `omp.editor[.bash|.python]` (tone `pending` while
+	 * a turn runs) over the context hairline, the attachment chips, a `line`
+	 * row of the shell-mode chip and the input, and the `bar`: model chip,
+	 * effort chip, the other status facts, usage, then send (Stop while a turn
+	 * runs). Clicks come back as `status.model`, `thinking.cycle`, `submit`
+	 * and `interrupt` actions.
+	 */
+	override describeLayout = (input: NativeNode, _cx: DescribeContext): NativeEditorLayout => {
+		const state = this.composerState();
+		const shell = state.shell;
+		const facts = this.composerFacts?.describeComposerFacts();
+		const thinkingKey = this.#actionKeys.get("app.thinking.cycle")?.[0];
+		const modelKey = this.#actionKeys.get("app.model.selectTemporary")?.[0];
+		const interruptKey = this.#actionKeys.get("app.interrupt")?.[0] ?? "escape";
+		const key = [
+			shell?.kind,
+			shell?.excluded,
+			state.thinking,
+			state.running,
+			thinkingKey,
+			modelKey,
+			interruptKey,
+		].join("\0");
+		const chips = this.attachmentChips;
+		const memo = this.#nativeComposer;
+		if (memo && memo.key === key && memo.facts === facts && memo.input === input && memo.chips === chips) {
+			return memo.layout;
+		}
+		const { mode, bar } =
+			memo?.key === key && memo.facts === facts
+				? memo
+				: this.#describeComposerControls(state, facts, thinkingKey, modelKey, interruptKey);
+		const line = keyed(row(compact([mode, input]), { role: "omp.composer.line", align: "start", gap: "sm" }), "line");
+		const layout: NativeEditorLayout = {
+			role: shell ? `omp.editor.${shell.kind}` : "omp.editor",
+			tone: state.running ? "pending" : undefined,
+			children: compact([facts?.context, chips, line, bar]),
+			caret: "line/input",
+		};
+		this.#nativeComposer = { key, facts, chips, input, mode, bar, layout };
+		return layout;
+	};
+
+	/** The shell-mode chip before the input, and the bar under it. */
+	#describeComposerControls(
+		state: ComposerNativeState,
+		facts: ComposerFacts | undefined,
+		thinkingKey: KeyId | undefined,
+		modelKey: KeyId | undefined,
+		interruptKey: KeyId,
+	): { mode: NativeNode | undefined; bar: NativeNode } {
+		const shell = state.shell;
+		const model =
+			facts &&
+			node(
+				"row",
+				{
+					role: "omp.composer.model",
+					gap: "xs",
+					align: "center",
+					tone: facts.model.tone,
+					title: modelKey ? `Switch model  ${formatKeyHint(modelKey)}` : "Switch model",
+					actions: { click: "status.model" },
+				},
+				[
+					node("icon", { name: "model" }, undefined, "icon"),
+					node("text", { spans: facts.model.spans, wrap: "none" }, undefined, "name"),
+					node("icon", { name: "chev" }, undefined, "chev"),
+				],
+				"model",
+			);
+		const effortSteps = state.thinking === undefined ? undefined : EFFORT_STEPS[state.thinking];
+		const effort =
+			state.thinking !== undefined &&
+			node(
+				"row",
+				{
+					role: "omp.composer.effort",
+					gap: "xs",
+					align: "center",
+					title: thinkingKey ? `Thinking effort  ${formatKeyHint(thinkingKey)}` : "Thinking effort",
+					actions: { click: "thinking.cycle" },
+				},
+				[
+					node(
+						"meter",
+						{ value: effortSteps === undefined ? null : effortSteps / 4, style: "blocks", steps: 4 },
+						undefined,
+						"meter",
+					),
+					node("text", { text: state.thinking, wrap: "none" }, undefined, "level"),
+				],
+				"effort",
+			);
+		const submit = state.running
+			? node(
+					"text",
+					{
+						role: "omp.composer.stop",
+						text: "Stop",
+						tone: "error",
+						title: `Stop  ${interruptKey === "escape" ? "esc" : formatKeyHint(interruptKey)}`,
+						actions: { click: "interrupt" },
+					},
+					undefined,
+					"stop",
+				)
+			: node(
+					"kbd",
+					{
+						role: "omp.composer.send",
+						keys: ["enter"],
+						title: `Send  ${formatKeyHint("enter")}`,
+						actions: { click: "submit" },
+					},
+					undefined,
+					"send",
+				);
+		// The status facts are the bar's flexible space; without them a spacer keeps send at the end.
+		const bar = keyed(
+			row(compact([model, effort, facts?.extras ?? node("row", { grow: 1 }, [], "gap"), facts?.usage, submit]), {
+				role: "omp.composer.bar",
+				gap: "sm",
+				align: "center",
+			}),
+			"bar",
+		);
+		if (!shell) return { mode: undefined, bar };
+		const runs = shell.kind === "bash" ? "Runs in your shell" : "Runs in Python";
+		const mode = keyed(
+			row(
+				compact([
+					shell.excluded &&
+						node("icon", { name: "eye-off", title: "Not sent to the model" }, undefined, "excluded"),
+					node(
+						"text",
+						{ spans: [span(shell.kind, shell.kind === "bash" ? "bashMode" : "pythonMode")], wrap: "none" },
+						undefined,
+						"label",
+					),
+				]),
+				{
+					role: "omp.composer.mode",
+					gap: "xs",
+					align: "center",
+					title: shell.excluded ? `${runs} · not sent to the model` : runs,
+				},
+			),
+			"mode",
+		);
+		return { mode, bar };
+	}
+
+	/**
+	 * Clicks on the composer's controls take the same paths as their keys: ⇧⇥,
+	 * ⏎ and Esc; the status facts' clicks (`status.*`) go to their source.
+	 */
+	handleNativeEvent(event: NativeUiEvent): void {
+		if (event.type !== "action") return;
+		switch (event.act) {
+			case "thinking.cycle":
+				this.onCycleThinkingLevel?.();
+				return;
+			case "submit":
+				this.submit();
+				return;
+			case "interrupt":
+				this.onEscape?.();
+				return;
+			default:
+				this.composerFacts?.handleNativeEvent(event);
+		}
+	}
+
 	onEscape?: () => void;
 	onClear?: () => void;
 	onExit?: () => void;

package/src/prompt/editor-top-gap.ts

@@ -1,4 +1,6 @@
 import type { Component } from "../index";
+import type { NativeNode } from "../native/node";
+import { col } from "../native/describe";
 let composerShape = "box";
 
 /** Set the process-wide editor gap layout. */
@@ -8,6 +10,8 @@ export function setEditorGapComposerShape(shape: string): void {
 
 const GAP: readonly string[] = [""];
 const FLUSH: readonly string[] = [];
+/** A TSP terminal spaces the dock itself; the gap describes nothing. */
+const NATIVE_GAP: NativeNode = col([]);
 
 /**
  * One-line top margin between the working/status HUD row and the editor.
@@ -25,4 +29,8 @@ export class EditorTopGap implements Component {
 	render(_width: number): readonly string[] {
 		return composerShape === "band" && this.statusRowOccupied() ? FLUSH : GAP;
 	}
+
+	describe(): NativeNode {
+		return NATIVE_GAP;
+	}
 }

package/src/prompt/macos-spelling.ts

@@ -96,10 +96,27 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		context: SpellingDecorationContext,
 		decorate: (span: string) => string = value => value,
 	): string {
-		if (!this.#available || !this.#features.typoDetection || text.length === 0) return decorate(text);
-		if (!this.#prose.isProse(context, context.startCol, context.startCol + text.length)) {
-			return decorate(text);
+		const ranges = this.typoRanges(text, context);
+		if (ranges.length === 0) return decorate(text);
+		let rendered = "";
+		let cursor = 0;
+		for (const range of ranges) {
+			const end = range.start + range.length;
+			rendered += decorate(text.slice(cursor, range.start));
+			rendered += this.#marks.start + decorate(text.slice(range.start, end)) + this.#marks.end;
+			cursor = end;
 		}
+		return rendered + decorate(text.slice(cursor));
+	}
+
+	/**
+	 * Misspelled prose ranges in `text` (offsets into it), in order and
+	 * non-overlapping. Schedules the verification check for uncached text; its
+	 * result arrives through {@link onUpdate}.
+	 */
+	typoRanges(text: string, context: SpellingDecorationContext): readonly native.SpellingRange[] {
+		if (!this.#available || !this.#features.typoDetection || text.length === 0) return [];
+		if (!this.#prose.isProse(context, context.startCol, context.startCol + text.length)) return [];
 		const lane = `${context.line}:${context.startCol}`;
 		const cached = this.#typoCache.get(text);
 		// A cache hit obsoletes any older text queued for this lane. A miss must
@@ -110,9 +127,8 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 		if (cached === undefined) this.#scheduleTypoRanges(text, lane);
 		else this.#automaticTypoQueue.delete(lane);
 		const ranges = cached ?? this.#projectTypoRanges(text);
-		if (!ranges) return decorate(text);
-		if (ranges.length === 0) return decorate(text);
-		let rendered = "";
+		if (!ranges || ranges.length === 0) return [];
+		const kept: native.SpellingRange[] = [];
 		let cursor = 0;
 		for (const range of ranges) {
 			const end = range.start + range.length;
@@ -123,11 +139,10 @@ export class MacOSSpellingProvider implements EditorTextAssistProvider {
 			if (!this.#prose.isProse(context, context.startCol + range.start, context.startCol + end)) {
 				continue;
 			}
-			rendered += decorate(text.slice(cursor, range.start));
-			rendered += this.#marks.start + decorate(text.slice(range.start, end)) + this.#marks.end;
+			kept.push(range);
 			cursor = end;
 		}
-		return rendered + decorate(text.slice(cursor));
+		return kept;
 	}
 
 	/** Return the confident macOS correction after a completed prose word. */

package/src/prompt/magic-keywords.ts

@@ -1,5 +1,5 @@
 import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
-import { keywordInProse } from "./markdown-prose";
+import { keywordInProse, maskNonProse } from "./markdown-prose";
 
 /**
  * Magic-keyword engine: standalone prose words the host registers via
@@ -39,6 +39,8 @@ function magicKeywordRegex(word: string, flags = ""): RegExp {
 interface RegisteredKeyword {
 	readonly word: string;
 	readonly highlight: KeywordHighlighter;
+	/** Global standalone-prose matcher, walked over masked text. */
+	readonly pattern: RegExp;
 }
 
 let registry: readonly RegisteredKeyword[] = [];
@@ -62,6 +64,7 @@ function matcherFor(word: string): RegExp {
 export function setMagicKeywords(specs: readonly MagicKeywordSpec[]): void {
 	registry = specs.map(({ word, hue: [from, to] }) => ({
 		word,
+		pattern: magicKeywordRegex(word, "g"),
 		highlight: createGradientHighlighter({
 			probe: word,
 			highlight: magicKeywordRegex(word, "g"),
@@ -110,6 +113,24 @@ export function highlightMagicKeywords(text: string, resetTo?: string, phase?: n
 	return out;
 }
 
+/**
+ * UTF-16 ranges of every registered keyword standing as prose in `text`
+ * (never inside code or XML/HTML sections), for decorating the keywords
+ * without painting them: a TSP terminal draws the gradient sweep itself.
+ */
+export function magicKeywordRanges(text: string): { from: number; to: number }[] {
+	const ranges: { from: number; to: number }[] = [];
+	let masked: string | undefined;
+	for (const keyword of registry) {
+		if (!text.includes(keyword.word)) continue;
+		masked ??= maskNonProse(text);
+		for (const match of masked.matchAll(keyword.pattern)) {
+			ranges.push({ from: match.index, to: match.index + match[0].length });
+		}
+	}
+	return ranges.sort((a, b) => a.from - b.from);
+}
+
 /**
  * Cheap test for "does this text contain any registered keyword as standalone
  * prose?". Short-circuits on a substring probe before paying for the

package/src/prompt/model-mention-autocomplete.ts

@@ -50,6 +50,7 @@ export function getModelMentionSuggestions(
 			label: item.selector,
 			description: modelMentionDisplayName(item.model),
 			icon: theme.symbol("icon.model"),
+			iconName: "model",
 		}));
 	return items.length > 0 ? { items, prefix } : null;
 }

package/src/prompt/queued-messages.ts

@@ -0,0 +1,101 @@
+import { Container } from "../tui";
+import { Spacer } from "../components/spacer";
+import { TruncatedText } from "../components/truncated-text";
+import { formatKeyHint } from "../key-hint-format";
+import type { KeyId } from "../keys";
+import { kbd, node, text } from "../native/describe";
+import type { NativeNode, NativeUiEvent } from "../native/node";
+import { replaceTabs } from "../utils";
+import { theme } from "../theme/theme";
+
+/** Queued messages under one heading ("Steering", "After yield"). */
+export interface QueuedMessageGroup {
+	readonly label: string;
+	readonly messages: readonly string[];
+}
+
+/**
+ * Messages queued while the agent works, above the editor. ANSI: a heading
+ * per group, numbered dim rows and the dequeue hint. Natively (§8.1): a
+ * stack of pills, each `corner-down-right` · the text · `⌥↑ Edit`, the total
+ * count in the first pill when more than one waits; the edit control sends
+ * `queue.edit`, answered like the dequeue key.
+ */
+export class QueuedMessagesBand extends Container {
+	readonly #native: NativeNode;
+
+	constructor(
+		groups: readonly QueuedMessageGroup[],
+		dequeueKey: KeyId,
+		private readonly onEdit: () => void,
+	) {
+		super();
+		this.addChild(new Spacer(1));
+		for (const group of groups) {
+			const heading = theme.fg("muted", `${group.label}${theme.sep.dot}${group.messages.length}`);
+			this.addChild(new TruncatedText(heading, 1, 0));
+			for (let index = 0; index < group.messages.length; index++) {
+				const message = replaceTabs(group.messages[index] ?? "").replace(/\r?\n/g, " ↵ ");
+				this.addChild(new TruncatedText(theme.fg("dim", `  ${index + 1}. ${message}`), 1, 0));
+			}
+		}
+		const editKey = formatKeyHint(dequeueKey);
+		this.addChild(new TruncatedText(theme.fg("dim", `  ${theme.tree.hook} ${editKey} to edit`), 1, 0));
+
+		const count = groups.reduce((sum, group) => sum + group.messages.length, 0);
+		const pills: NativeNode[] = [];
+		for (const group of groups) {
+			group.messages.forEach((message, index) => {
+				const children: NativeNode[] = [
+					node("icon", { name: "corner-down-right" }, undefined, "icon"),
+					node(
+						"text",
+						{
+							text: replaceTabs(message).replace(/\s*\r?\n\s*/g, " ↵ "),
+							wrap: "none",
+							truncate: "end",
+							grow: 1,
+						},
+						undefined,
+						"text",
+					),
+				];
+				if (pills.length === 0 && count > 1) {
+					children.push(node("badge", { text: `${count}`, role: "omp.queue.count" }, undefined, "count"));
+				}
+				children.push(
+					node(
+						"row",
+						{
+							role: "omp.queue.edit",
+							gap: "xs",
+							align: "center",
+							title: `Edit  ${editKey}`,
+							actions: { click: "queue.edit" },
+						},
+						[kbd(dequeueKey), text("Edit")],
+						"edit",
+					),
+				);
+				pills.push(
+					node(
+						"row",
+						{ role: "omp.queue.item", align: "center", gap: "sm", title: group.label },
+						children,
+						`${group.label}/${index}`,
+					),
+				);
+			});
+		}
+		this.#native = node("col", { role: "omp.queue", gap: "xs" }, pills);
+	}
+
+	override describe(): NativeNode {
+		return this.#native;
+	}
+
+	/** The pills' Edit control: the dequeue key's path (queued messages back into the editor). */
+	handleNativeEvent(event: NativeUiEvent): void {
+		if (event.type === "action" && event.act === "queue.edit") this.onEdit();
+	}
+}

package/src/prompt/skill-tokens.ts

@@ -1,9 +1,11 @@
 /**
  * One `/skill:<name>` token delimited by whitespace or line edges. Group 1 is
- * the leading delimiter (empty at line start), group 2 the bare skill name.
- * Global so callers can walk every token; reset `lastIndex` before reuse.
+ * the leading delimiter (empty at line start), group 2 the skill name: a bare
+ * name or a collision-namespaced `<namespace>/<name>` (exactly one `/`; deeper
+ * paths never match). Global so callers can walk every token; reset
+ * `lastIndex` before reuse.
  */
-export const SKILL_TOKEN_RE = /(^|\s)\/skill:([^\s/]+)(?=\s|$)/g;
+export const SKILL_TOKEN_RE = /(^|\s)\/skill:([^\s/]+(?:\/[^\s/]+)?)(?=\s|$)/g;
 
 /**
  * Whether the (already left-trimmed) draft begins with a TUI local-execution