@visual-z/xeno 0.1.4 → 0.2.0

package/src/vendor/pi-rich/mime.ts

@@ -0,0 +1,116 @@
+import { open } from "node:fs/promises";
+
+const IMAGE_TYPE_SNIFF_BYTES = 4100;
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+
+export function detectSupportedImageMimeType(buffer: Uint8Array): string | null {
+	if (startsWith(buffer, [0xff, 0xd8, 0xff])) {
+		return buffer[3] === 0xf7 ? null : "image/jpeg";
+	}
+	if (startsWith(buffer, PNG_SIGNATURE)) {
+		return isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null;
+	}
+	if (startsWithAscii(buffer, 0, "GIF87a") || startsWithAscii(buffer, 0, "GIF89a")) {
+		return "image/gif";
+	}
+	if (startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP")) {
+		return "image/webp";
+	}
+	if (startsWithAscii(buffer, 0, "BM") && isBmp(buffer)) {
+		return "image/bmp";
+	}
+	return null;
+}
+
+export async function detectSupportedImageMimeTypeFromFile(filePath: string): Promise<string | null> {
+	const fileHandle = await open(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(IMAGE_TYPE_SNIFF_BYTES);
+		const { bytesRead } = await fileHandle.read(buffer, 0, IMAGE_TYPE_SNIFF_BYTES, 0);
+		return detectSupportedImageMimeType(buffer.subarray(0, bytesRead));
+	} finally {
+		await fileHandle.close();
+	}
+}
+
+function isPng(buffer: Uint8Array): boolean {
+	return (
+		buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR")
+	);
+}
+
+function isAnimatedPng(buffer: Uint8Array): boolean {
+	let offset = PNG_SIGNATURE.length;
+	while (offset + 8 <= buffer.length) {
+		const chunkLength = readUint32BE(buffer, offset);
+		const chunkTypeOffset = offset + 4;
+		if (startsWithAscii(buffer, chunkTypeOffset, "acTL")) return true;
+		if (startsWithAscii(buffer, chunkTypeOffset, "IDAT")) return false;
+
+		const nextOffset = offset + 8 + chunkLength + 4;
+		if (nextOffset <= offset || nextOffset > buffer.length) return false;
+		offset = nextOffset;
+	}
+	return false;
+}
+
+function isBmp(buffer: Uint8Array): boolean {
+	if (buffer.length < 26) return false;
+
+	const declaredFileSize = readUint32LE(buffer, 2);
+	const pixelDataOffset = readUint32LE(buffer, 10);
+	const dibHeaderSize = readUint32LE(buffer, 14);
+	if (declaredFileSize !== 0 && declaredFileSize < 26) return false;
+	if (pixelDataOffset < 14 + dibHeaderSize) return false;
+	if (declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize) return false;
+
+	let colorPlanes: number;
+	let bitsPerPixel: number;
+	if (dibHeaderSize === 12) {
+		colorPlanes = readUint16LE(buffer, 22);
+		bitsPerPixel = readUint16LE(buffer, 24);
+	} else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+		if (buffer.length < 30) return false;
+		colorPlanes = readUint16LE(buffer, 26);
+		bitsPerPixel = readUint16LE(buffer, 28);
+	} else {
+		return false;
+	}
+
+	return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+
+function readUint16LE(buffer: Uint8Array, offset: number): number {
+	return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
+
+function readUint32BE(buffer: Uint8Array, offset: number): number {
+	return (
+		(buffer[offset] ?? 0) * 0x1000000 +
+		((buffer[offset + 1] ?? 0) << 16) +
+		((buffer[offset + 2] ?? 0) << 8) +
+		(buffer[offset + 3] ?? 0)
+	);
+}
+
+function readUint32LE(buffer: Uint8Array, offset: number): number {
+	return (
+		(buffer[offset] ?? 0) +
+		((buffer[offset + 1] ?? 0) << 8) +
+		((buffer[offset + 2] ?? 0) << 16) +
+		(buffer[offset + 3] ?? 0) * 0x1000000
+	);
+}
+
+function startsWith(buffer: Uint8Array, bytes: number[]): boolean {
+	if (buffer.length < bytes.length) return false;
+	return bytes.every((byte, index) => buffer[index] === byte);
+}
+
+function startsWithAscii(buffer: Uint8Array, offset: number, text: string): boolean {
+	if (buffer.length < offset + text.length) return false;
+	for (let index = 0; index < text.length; index++) {
+		if (buffer[offset + index] !== text.charCodeAt(index)) return false;
+	}
+	return true;
+}

package/src/vendor/pi-rich/photon.ts

@@ -0,0 +1,139 @@
+/**
+ * Photon image processing wrapper.
+ *
+ * This module provides a unified interface to @silvia-odwyer/photon-node that works in:
+ * 1. Node.js (development, npm run build)
+ * 2. Bun compiled binaries (standalone distribution)
+ *
+ * The challenge: photon-node's CJS entry uses fs.readFileSync(__dirname + '/photon_rs_bg.wasm')
+ * which bakes the build machine's absolute path into Bun compiled binaries.
+ *
+ * Solution:
+ * 1. Patch fs.readFileSync to redirect missing photon_rs_bg.wasm reads
+ * 2. Copy photon_rs_bg.wasm next to the executable in build:binary
+ */
+
+import type { PathOrFileDescriptor } from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+import { fileURLToPath } from "url";
+
+const require = createRequire(import.meta.url);
+const fs = require("fs") as typeof import("fs");
+
+// Re-export types from the main package
+export type { PhotonImage as PhotonImageType } from "@silvia-odwyer/photon-node";
+
+type ReadFileSync = typeof fs.readFileSync;
+
+const WASM_FILENAME = "photon_rs_bg.wasm";
+
+// Lazy-loaded photon module
+let photonModule: typeof import("@silvia-odwyer/photon-node") | null = null;
+let loadPromise: Promise<typeof import("@silvia-odwyer/photon-node") | null> | null = null;
+
+function pathOrNull(file: PathOrFileDescriptor): string | null {
+	if (typeof file === "string") {
+		return file;
+	}
+	if (file instanceof URL) {
+		return fileURLToPath(file);
+	}
+	return null;
+}
+
+function getFallbackWasmPaths(): string[] {
+	const execDir = path.dirname(process.execPath);
+	return [
+		path.join(execDir, WASM_FILENAME),
+		path.join(execDir, "photon", WASM_FILENAME),
+		path.join(process.cwd(), WASM_FILENAME),
+	];
+}
+
+function patchPhotonWasmRead(): () => void {
+	const originalReadFileSync: ReadFileSync = fs.readFileSync.bind(fs);
+	const fallbackPaths = getFallbackWasmPaths();
+	const mutableFs = fs as { readFileSync: ReadFileSync };
+
+	const patchedReadFileSync: ReadFileSync = ((...args: Parameters<ReadFileSync>) => {
+		const [file, options] = args;
+		const resolvedPath = pathOrNull(file);
+
+		if (resolvedPath?.endsWith(WASM_FILENAME)) {
+			try {
+				return originalReadFileSync(...args);
+			} catch (error) {
+				const err = error as NodeJS.ErrnoException;
+				if (err?.code && err.code !== "ENOENT") {
+					throw error;
+				}
+
+				for (const fallbackPath of fallbackPaths) {
+					if (!fs.existsSync(fallbackPath)) {
+						continue;
+					}
+					if (options === undefined) {
+						return originalReadFileSync(fallbackPath);
+					}
+					return originalReadFileSync(fallbackPath, options);
+				}
+
+				throw error;
+			}
+		}
+
+		return originalReadFileSync(...args);
+	}) as ReadFileSync;
+
+	try {
+		mutableFs.readFileSync = patchedReadFileSync;
+	} catch {
+		Object.defineProperty(fs, "readFileSync", {
+			value: patchedReadFileSync,
+			writable: true,
+			configurable: true,
+		});
+	}
+
+	return () => {
+		try {
+			mutableFs.readFileSync = originalReadFileSync;
+		} catch {
+			Object.defineProperty(fs, "readFileSync", {
+				value: originalReadFileSync,
+				writable: true,
+				configurable: true,
+			});
+		}
+	};
+}
+
+/**
+ * Load the photon module asynchronously.
+ * Returns cached module on subsequent calls.
+ */
+export async function loadPhoton(): Promise<typeof import("@silvia-odwyer/photon-node") | null> {
+	if (photonModule) {
+		return photonModule;
+	}
+
+	if (loadPromise) {
+		return loadPromise;
+	}
+
+	loadPromise = (async () => {
+		const restoreReadFileSync = patchPhotonWasmRead();
+		try {
+			photonModule = await import("@silvia-odwyer/photon-node");
+			return photonModule;
+		} catch {
+			photonModule = null;
+			return photonModule;
+		} finally {
+			restoreReadFileSync();
+		}
+	})();
+
+	return loadPromise;
+}

package/src/vendor/pi-rich/syntax-highlight.ts

@@ -0,0 +1,214 @@
+import hljs from "highlight.js/lib/core.js";
+import bash from "highlight.js/lib/languages/bash.js";
+import c from "highlight.js/lib/languages/c.js";
+import cpp from "highlight.js/lib/languages/cpp.js";
+import csharp from "highlight.js/lib/languages/csharp.js";
+import dart from "highlight.js/lib/languages/dart.js";
+import go from "highlight.js/lib/languages/go.js";
+import groovy from "highlight.js/lib/languages/groovy.js";
+import java from "highlight.js/lib/languages/java.js";
+import javascript from "highlight.js/lib/languages/javascript.js";
+import json from "highlight.js/lib/languages/json.js";
+import kotlin from "highlight.js/lib/languages/kotlin.js";
+import lua from "highlight.js/lib/languages/lua.js";
+import nix from "highlight.js/lib/languages/nix.js";
+import perl from "highlight.js/lib/languages/perl.js";
+import php from "highlight.js/lib/languages/php.js";
+import python from "highlight.js/lib/languages/python.js";
+import ruby from "highlight.js/lib/languages/ruby.js";
+import rust from "highlight.js/lib/languages/rust.js";
+import scala from "highlight.js/lib/languages/scala.js";
+import swift from "highlight.js/lib/languages/swift.js";
+import typescript from "highlight.js/lib/languages/typescript.js";
+import { decodeHtmlEntityAt } from "./html.ts";
+
+const eagerLanguages = {
+	python,
+	java,
+	go,
+	javascript,
+	json,
+	cpp,
+	typescript,
+	php,
+	ruby,
+	c,
+	csharp,
+	nix,
+	bash,
+	rust,
+	scala,
+	kotlin,
+	swift,
+	dart,
+	groovy,
+	perl,
+	lua,
+};
+
+for (const [name, language] of Object.entries(eagerLanguages)) {
+	hljs.registerLanguage(name, language);
+}
+
+let allLanguagesPromise: Promise<void> | undefined;
+
+export function loadAllHighlightLanguages(): Promise<void> {
+	if (!allLanguagesPromise) {
+		allLanguagesPromise = new Promise((resolve) => {
+			setImmediate(() => {
+				void import("highlight.js/lib/index.js").then(
+					() => resolve(),
+					() => {
+						// Eager languages and plaintext fallback remain available.
+						resolve();
+					},
+				);
+			});
+		});
+	}
+	return allLanguagesPromise;
+}
+
+export type HighlightFormatter = (text: string) => string;
+export type HighlightTheme = Partial<Record<string, HighlightFormatter>>;
+
+export interface HighlightOptions {
+	language?: string;
+	ignoreIllegals?: boolean;
+	languageSubset?: string[];
+	theme?: HighlightTheme;
+}
+
+const SPAN_CLOSE = "</span>";
+const HIGHLIGHT_CLASS_PREFIX = "hljs-";
+
+function getScopeFromSpanTag(tag: string): string | undefined {
+	const match = /\sclass\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(tag);
+	const classValue = match?.[1] ?? match?.[2];
+	if (!classValue) {
+		return undefined;
+	}
+
+	for (const className of classValue.split(/\s+/)) {
+		if (className.startsWith(HIGHLIGHT_CLASS_PREFIX)) {
+			return className.slice(HIGHLIGHT_CLASS_PREFIX.length);
+		}
+	}
+
+	return undefined;
+}
+
+function getScopeFormatter(scope: string, theme: HighlightTheme): HighlightFormatter | undefined {
+	const exact = theme[scope];
+	if (exact) {
+		return exact;
+	}
+
+	const dotIndex = scope.indexOf(".");
+	if (dotIndex !== -1) {
+		const prefixFormatter = theme[scope.slice(0, dotIndex)];
+		if (prefixFormatter) {
+			return prefixFormatter;
+		}
+	}
+
+	const dashIndex = scope.indexOf("-");
+	if (dashIndex !== -1) {
+		const prefixFormatter = theme[scope.slice(0, dashIndex)];
+		if (prefixFormatter) {
+			return prefixFormatter;
+		}
+	}
+
+	return undefined;
+}
+
+function getActiveFormatter(scopes: Array<string | undefined>, theme: HighlightTheme): HighlightFormatter | undefined {
+	for (let i = scopes.length - 1; i >= 0; i--) {
+		const scope = scopes[i];
+		if (!scope) {
+			continue;
+		}
+		const formatter = getScopeFormatter(scope, theme);
+		if (formatter) {
+			return formatter;
+		}
+	}
+	return theme.default;
+}
+
+function isSpanOpenTagStart(html: string, index: number): boolean {
+	if (!html.startsWith("<span", index)) {
+		return false;
+	}
+	const nextChar = html[index + "<span".length];
+	return nextChar === ">" || nextChar === " " || nextChar === "\t" || nextChar === "\n" || nextChar === "\r";
+}
+
+export function renderHighlightedHtml(html: string, theme: HighlightTheme = {}): string {
+	let output = "";
+	let textBuffer = "";
+	const scopes: Array<string | undefined> = [];
+
+	const flushText = () => {
+		if (!textBuffer) {
+			return;
+		}
+		const formatter = getActiveFormatter(scopes, theme);
+		output += formatter ? formatter(textBuffer) : textBuffer;
+		textBuffer = "";
+	};
+
+	let index = 0;
+	while (index < html.length) {
+		if (isSpanOpenTagStart(html, index)) {
+			const tagEndIndex = html.indexOf(">", index + 5);
+			if (tagEndIndex !== -1) {
+				flushText();
+				const tag = html.slice(index, tagEndIndex + 1);
+				const scope = getScopeFromSpanTag(tag);
+				scopes.push(scope);
+				index = tagEndIndex + 1;
+				continue;
+			}
+		}
+
+		if (html.startsWith(SPAN_CLOSE, index)) {
+			flushText();
+			if (scopes.length > 0) {
+				scopes.pop();
+			}
+			index += SPAN_CLOSE.length;
+			continue;
+		}
+
+		if (html[index] === "&") {
+			const decoded = decodeHtmlEntityAt(html, index);
+			if (decoded) {
+				textBuffer += decoded.text;
+				index += decoded.length;
+				continue;
+			}
+		}
+
+		textBuffer += html[index];
+		index++;
+	}
+
+	flushText();
+	return output;
+}
+
+export function highlight(code: string, options: HighlightOptions = {}): string {
+	const html = options.language
+		? hljs.highlight(code, {
+				language: options.language,
+				ignoreIllegals: options.ignoreIllegals,
+			}).value
+		: hljs.highlightAuto(code, options.languageSubset).value;
+	return renderHighlightedHtml(html, options.theme);
+}
+
+export function supportsLanguage(name: string): boolean {
+	return hljs.getLanguage(name) !== undefined;
+}

package/src/vendor/pi-tui/UPSTREAM.json

@@ -0,0 +1,50 @@
+{
+  "commit": "02eed88fd8912e54a804ddebd409e2e4c08ac5ef",
+  "files": {
+    "alt-screen-search.ts": "2ed3821323723515523075ac143ce5e25fdcd7c7",
+    "autocomplete.ts": "3ff45bf17a5def8d0bdf81e9eb1af264f1c5f768",
+    "colors.ts": "070a261344e307988f45e7c86d1728db5a00b8f3",
+    "components/alt-screen-flash.ts": "e4b823cd2bdd54696895cac93807cc6fcddaddd4",
+    "components/box.ts": "7c880d9145eff2c26db7969937223bb3776acced",
+    "components/cancellable-loader.ts": "7822cb04219440703a9100e02679725b3326fa1c",
+    "components/editor.ts": "c7fda44eb8288a10f518791f931cff4fc36c62b5",
+    "components/h-stack.ts": "07f8f8ffd055789d69266152f62ee97390bacf01",
+    "components/image.ts": "91d68016aae5d292e22a3e892631b7ed53b13e64",
+    "components/input.ts": "1bc26453098639991c22515cc94fee89b53f289d",
+    "components/loader.ts": "0c59e73a83bb4bd9978818b16bf556da53f48123",
+    "components/markdown.ts": "30c40c1715dfc374687b538d447988a81feb237f",
+    "components/mouse-region.ts": "a77ded0c1e59167fe2f0643e87531b95ed9e544d",
+    "components/scroll-view.ts": "b8f8a51ff0f8f93aabce0df072ee29c5a47c82b3",
+    "components/select-list.ts": "f4f4354dd850939e2e84ea8ce8a755206d3e8e43",
+    "components/settings-list.ts": "b1b8366bf349b30a1d93073a4cc1d0e2bfa9dc8a",
+    "components/spacer.ts": "7abe1551ca79a17bbb03d6b62f3ec18c50274a75",
+    "components/stack.ts": "68bde0368455646144a1dd3942b56a48e9d4f45a",
+    "components/text.ts": "7a50e2721028d544f641ab5f66ef1b752ff6d1f7",
+    "components/truncated-text.ts": "c26b8892967a8462a8828cfed4ea572a73af1602",
+    "components/v-stack.ts": "ce7b9292d6dfd0981650a1cf927f223b926f9714",
+    "editor-component.ts": "595645033a074d17b8190b73709c2623d3e479b5",
+    "fuzzy.ts": "1b5352c1c592956ea614a2ec3630cb6f606ccd83",
+    "index.ts": "93fb8b72777a3a4f8423cf4e7d5f74b8dbd982f0",
+    "keybindings.ts": "d6afb5ec39642c098b7d95e10ab6b57568e514b4",
+    "keys.ts": "8b6f8a0a708cc9a1c9b795ff1ec9766c4209114b",
+    "kill-ring.ts": "2292f91aa36baa1bf762df2890bdbed8ca17eb19",
+    "latex.ts": "060fd052d820b42903896e53053614e1c578a995",
+    "layout-node.ts": "a3c06b24564efaa35321f190641a80e95ce7c7ab",
+    "layout.ts": "897c51de2ffbc4c543e87399eaa4e8b6421449ef",
+    "native-modifiers.ts": "8cdc60d484717431bd5f1577b36f189275aa06d3",
+    "native-module-path.ts": "b75117feb7384da268cfd7d3a8c8fc6af0aeb10e",
+    "native-platform.ts": "3a6580a445d8a816225ed824d30e48a93268a761",
+    "oklab.ts": "83ddda42fca5bcd485464c74029c2f3db7a5cc6d",
+    "stdin-buffer.ts": "cc10c61a55196eb90d9da3e1858e48cab27e925f",
+    "terminal-colors.ts": "6a972a95bb5c3c0de65657f4861cdb3ad3579c41",
+    "terminal-image.ts": "a84d22c575599c55e5ea96c528e641e54df8511c",
+    "terminal.ts": "cce2dd116ca55b2c9f3add30b080a395e8f1f4bb",
+    "tui-alt-screen.ts": "bf8affb13ba1d3625711268c8b6f0956c9e5d90e",
+    "tui-main-screen.ts": "c079dd776984b23f5e0b4a833ac5b67fb31ff337",
+    "tui.ts": "7968a9e792375b9e8701ca4dbe89d18735aa387b",
+    "undo-stack.ts": "5b9a7e9cee03a08b5d7ee637b92834a3a28d7fd2",
+    "utils.ts": "f537ad7e37dcf35db1259aa05d43f1b45bdef7c7",
+    "wheel-scroll.ts": "a6c0018bd4caa9b5bc197d05d548bfdca4036172",
+    "word-navigation.ts": "7c7eced2b6ac3ff5b49418824c3ac00a1f0204a3"
+  }
+}

package/src/vendor/pi-tui/VENDOR.md

@@ -2,8 +2,9 @@
 
 Source: https://github.com/earendil-works/pi — `packages/tui/src`
 License: MIT (see `LICENSE.upstream`), Copyright (c) 2025 Mario Zechner
-Copied: 2026-09-21
-Commit: `3390bd93630965a12a0a1a5c36ce890ec22f7e1d`
+Copied: 2026-09-30
+Commit: `02eed88fd8912e54a804ddebd409e2e4c08ac5ef`
+All 45 source files verified against upstream Git blob hashes in `UPSTREAM.json`.
 
 The application also follows coding-agent's CustomEditor, searchable model
 selector and interactive-mode composition. Those product behaviors are adapted
@@ -18,6 +19,7 @@ adapts this to xeno and is the only thing allowed to import from here.
 checks, because those exist to keep *our* code's layering decidable and
 upstream organises its code its own way.
 
-Native modules (`native-*.ts`) are optional: `isNativeModifierPressed`
-returns false when no helper loads, so the prebuilt `.node` binaries from
-upstream are deliberately NOT copied.
+Native sources and all six upstream prebuilt `.node` binaries are included
+under `native/`, verified by `native/UPSTREAM.json` at the same commit.
+The upstream resolver loads them directly; unavailable platform capabilities
+retain its optional fallback. No install script or startup download is required.

package/src/vendor/pi-tui/autocomplete.ts

@@ -7,6 +7,8 @@ import { autocompleteBoundaryRegex, autocompleteSeparatorRegex } from "./utils.t
 
 const PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
 const tokenStartRegex = new RegExp(`${autocompleteBoundaryRegex.source}$`, "u");
+// Opening wrappers that may precede a path in prose, mapped to their closing counterpart.
+const PATH_WRAPPERS: Record<string, string> = { "(": ")", "[": "]", "{": "}", "<": ">", "`": "`" };
 
 function toDisplayPath(value: string): string {
 	return value.replace(/\\/g, "/");
@@ -56,6 +58,20 @@ function findLastDelimiter(text: string): number {
 	return lastDelimiter;
 }
 
+// Strip opening wrappers before a path, e.g. "(~/Dev" -> "~/Dev" or "`src/ma" -> "src/ma".
+// Keep a wrapper if the token also contains its closer, e.g. "app/[slug]/pa" or "(group)/pa".
+function stripLeadingWrappers(token: string): string {
+	let result = token;
+	while (result.length > 0) {
+		const closer = PATH_WRAPPERS[result[0]!];
+		if (!closer || result.includes(closer, 1)) {
+			break;
+		}
+		result = result.slice(1);
+	}
+	return result;
+}
+
 function findUnclosedQuoteStart(text: string): number | null {
 	let inQuotes = false;
 	let quoteStart = -1;
@@ -73,7 +89,11 @@ function findUnclosedQuoteStart(text: string): number | null {
 }
 
 function isTokenStart(text: string, index: number): boolean {
-	return PATH_DELIMITERS.has(text[index - 1] ?? "") || tokenStartRegex.test(text.slice(0, index));
+	let start = index;
+	while (start > 0 && PATH_WRAPPERS[text[start - 1]!]) {
+		start -= 1;
+	}
+	return PATH_DELIMITERS.has(text[start - 1] ?? "") || tokenStartRegex.test(text.slice(0, start));
 }
 
 function extractQuotedPrefix(text: string): string | null {
@@ -332,11 +352,16 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 					};
 				});
 
-				const filtered = fuzzyFilter(commandItems, prefix, (item) =>
-					!prefix.startsWith("skill:") && item.name.startsWith("skill:")
-						? item.name.slice("skill:".length)
-						: item.name,
-				).map((item) => ({
+				const bareNameMatches = fuzzyFilter(commandItems, prefix, (item) =>
+					item.name.startsWith("skill:") ? item.name.slice("skill:".length) : item.name,
+				);
+				const bareNameMatchSet = new Set(bareNameMatches);
+				const fullNameOnlyMatches = fuzzyFilter(
+					commandItems.filter((item) => item.name.startsWith("skill:") && !bareNameMatchSet.has(item)),
+					prefix,
+					(item) => item.name,
+				);
+				const filtered = [...bareNameMatches, ...fullNameOnlyMatches].map((item) => ({
 					value: item.name,
 					label: item.label,
 					...(item.description && { description: item.description }),
@@ -481,10 +506,10 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		}
 
 		const lastDelimiterIndex = findLastDelimiter(text);
-		const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
+		const token = stripLeadingWrappers(lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1));
 
-		if (text[tokenStart] === "@") {
-			return text.slice(tokenStart);
+		if (token.startsWith("@")) {
+			return token;
 		}
 
 		return null;
@@ -498,7 +523,7 @@ export class CombinedAutocompleteProvider implements AutocompleteProvider {
 		}
 
 		const lastDelimiterIndex = findLastDelimiter(text);
-		const pathPrefix = lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1);
+		const pathPrefix = stripLeadingWrappers(lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1));
 
 		// For forced extraction (Tab key), always return something
 		if (forceExtract) {