pi-umbra 0.1.0

package/node_modules/pi-umbra-rename/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-umbra-rename",
+  "version": "0.1.0",
+  "description": "One command that renames a pi session and the terminal window title together, which pi keeps behind two separate APIs.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "session",
+    "rename",
+    "title"
+  ],
+  "author": "grkn",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grknbyk/pi-umbra.git",
+    "directory": "pi-umbra-rename"
+  },
+  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-rename#readme",
+  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
+  "files": [
+    "extensions",
+    "checks",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}

package/node_modules/pi-umbra-shimmer/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pi-umbra-shimmer/README.md

@@ -0,0 +1,19 @@
+# pi-umbra-shimmer
+
+A wave of colour running through pi's working indicator, over both the spinner and the text. Needs the umbra bundle patches; without them it does nothing.
+
+```
+pi-umbra-shimmer/
+├── checks
+│   └── umbra-shimmer.check.ts
+└── extensions
+    └── umbra-shimmer.ts
+```
+
+## Install
+
+```sh
+pi install npm:pi-umbra-shimmer
+```
+
+MIT.

package/node_modules/pi-umbra-shimmer/checks/umbra-shimmer.check.ts

@@ -0,0 +1,89 @@
+// What goes wrong here without anything failing: the band never reaches an end of the line, the
+// two halves of the indicator drift into different coordinate spaces, and `off` quietly keeps
+// animating. All three look like a working shimmer until you watch it.
+//
+//   bun run umbra-shimmer.check.ts
+import assert from "node:assert";
+import shimmer, { blend, highlight, middleAt, painters, parseSpec, strength, toneOf } from "../extensions/umbra-shimmer.ts";
+
+const RGB = { muted: [128, 128, 128], text: [255, 255, 255], accent: [0, 200, 255] } as const;
+const CLASSIC = { mode: "classic", speed: 1 } as const;
+const theme = {
+	fg: (color: string, text: string) => {
+		const rgb = RGB[color as keyof typeof RGB] ?? [10, 20, 30];
+		return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${text}\x1b[39m`;
+	},
+};
+
+// pi exposes no raw theme values, so the colour is read back out of a painted character.
+assert.deepEqual(toneOf(theme, "muted"), [128, 128, 128], "the tone comes back out of the escape");
+assert.equal(toneOf({ fg: (_c, t) => t }, "muted"), undefined, "a theme that paints nothing has no tone");
+
+assert.deepEqual(blend([0, 0, 0], [10, 20, 30], 0), [0, 0, 0], "no highlight is the base colour");
+assert.deepEqual(blend([0, 0, 0], [10, 20, 30], 1), [10, 20, 30], "full highlight is the tone itself");
+assert.deepEqual(blend([0, 0, 0], [10, 20, 40], 0.5), [5, 10, 20], "and halfway is halfway");
+
+assert.equal(strength(10, 10, 4), 1, "the middle of the band gets all of it");
+assert.equal(strength(14, 10, 4), 0, "its edge gets none");
+assert.equal(strength(40, 10, 4), 0, "and nothing outside goes negative");
+
+// classic has to enter from off the left edge and leave past the right one, or the wave appears
+// and vanishes mid-line instead of running through it.
+const classic = [0, 500, 1000, 1500, 1999].map((ms) => middleAt("classic", ms, 30, 1));
+assert.ok(classic[0]! < 0, "the pass starts off the left edge");
+assert.ok(classic[4]! > 30, "and ends past the right one");
+assert.deepEqual(classic, [...classic].sort((a, b) => a - b), "it only ever moves one way");
+
+// kitt has to turn around, and reach both ends while doing it.
+const kitt = Array.from({ length: 45 }, (_, i) => middleAt("kitt", i * 50, 30, 1));
+assert.ok(Math.min(...kitt) < 1, "the scanner reaches the left end");
+assert.ok(Math.max(...kitt) > 29, "and the right one");
+assert.ok(kitt.some((v, i) => i > 0 && v < kitt[i - 1]!), "and comes back");
+
+// One tone per pass, cycling: a highlight that never changes is the thing this replaces.
+// The ramp runs white -> the accent lifted toward white -> lifted a little -> the accent, and
+// it is walked rather than stepped: two frames a moment apart must not jump colour.
+const ACCENT: [number, number, number] = [0, 200, 255];
+assert.deepEqual(highlight(ACCENT, 0, 1), [255, 255, 255], "the ramp starts at white");
+assert.deepEqual(highlight(ACCENT, 3300, 1), ACCENT, "and reaches the theme's own colour");
+assert.deepEqual(highlight(ACCENT, 6600, 1), [255, 255, 255], "then comes back rather than cutting");
+const near = highlight(ACCENT, 1000, 1);
+const later = highlight(ACCENT, 1080, 1);
+assert.notDeepEqual(near, later, "the tone moves between frames");
+assert.ok(Math.max(...[0, 1, 2].map((i) => Math.abs(near[i]! - later[i]!))) < 20, "but never jumps");
+
+// The speed multiplier has to reach both halves: the sweep and the colour.
+assert.equal(parseSpec("classic 3")?.speed, 3, "a second argument is the speed");
+assert.equal(parseSpec("kitt")?.speed, 1, "no argument is speed 1");
+assert.equal(parseSpec("classic x")?.speed, 1, "and so is a speed that is not a number");
+assert.equal(parseSpec("classic 99")?.speed, 8, "an absurd speed is clamped, not refused");
+assert.equal(parseSpec("nope"), undefined, "an unknown mode is refused");
+assert.deepEqual(highlight(ACCENT, 1650, 2), highlight(ACCENT, 3300, 1), "speed 2 gets there twice as fast");
+assert.equal(middleAt("classic", 500, 30, 2), middleAt("classic", 1000, 30, 1), "and sweeps twice as fast");
+
+// off is off. It also takes the footer's colour rather than pi's own accent for the spinner.
+const dark = painters(theme, { mode: "off", speed: 1 });
+assert.equal(dark.spinner("x"), theme.fg("muted", "x"), "off paints the spinner in the footer colour");
+assert.equal(dark.message("y"), theme.fg("muted", "y"), "and the message in the same one");
+
+// The message is what tells the spinner how long the line is; without that they shimmer as two
+// separate waves that meet in the middle.
+const live = painters(theme, CLASSIC);
+const message = live.message("Working... (esc to interrupt)");
+assert.equal([...message.matchAll(/38;2;/g)].length, 29, "every character is painted on its own");
+assert.ok(live.spinner("⠾").includes("38;2;"), "and so is the glyph");
+assert.ok(!message.includes("\x1b[39m\x1b[39m"), "no character is painted twice");
+
+// pi reads `label` when it applies a completion. An item with only `value` is an
+// uncaughtException on the first Tab, which takes pi down rather than logging anything.
+const commands: Record<string, { getArgumentCompletions(text: string): { value: string; label: string }[] | null }> = {};
+shimmer({ on() {}, registerCommand: (name: string, def: never) => (commands[name] = def) } as never);
+const complete = commands["umb-shimmer"]!.getArgumentCompletions.bind(commands["umb-shimmer"]);
+for (const item of complete("") ?? []) {
+	assert.equal(typeof item.value, "string", "every completion carries a value");
+	assert.equal(typeof item.label, "string", "and a label, which is the one pi reads");
+}
+assert.equal((complete("k") ?? []).length, 1, "a prefix narrows the list");
+assert.equal(complete("zzz"), null, "no match is null, not an empty list");
+
+console.log("umbra-shimmer.check.ts ok - tone 2 cases, blend 3, band 3, classic 3, kitt 3, ramp 5, speed 7, off 2, span 3, completions 4");

package/node_modules/pi-umbra-shimmer/extensions/umbra-shimmer.ts

@@ -0,0 +1,183 @@
+// A wave of colour running through the working indicator, over both the spinner and the text.
+//
+// pi builds that indicator with a colour function already in hand - the editor embeds the working
+// status, so pi hands it the editor's border colour - and paints custom spinner frames verbatim,
+// skipping the colour step for them entirely. repatch stands both of those down when a shimmer is
+// installed and routes the two colour functions here. With nothing installed pi keeps its own
+// behaviour, so the patches are inert on their own.
+//
+// The highlight is not one colour. It travels from white down to the theme's own main colour and
+// back, blending the whole way rather than stepping, so the band changes tone while it moves.
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const MODES = ["classic", "kitt", "off"] as const;
+export type Mode = (typeof MODES)[number];
+export type Spec = { mode: Mode; speed: number };
+
+const FILE = join(homedir(), ".pi", "agent", "shimmer");
+
+// One pass of the wave at speed 1. kitt is quicker because it covers the same ground twice.
+const CLASSIC_MS = 2000;
+const KITT_MS = 1100;
+
+// How long the highlight takes to travel the whole ramp and come back. Deliberately not a
+// multiple of either sweep, so the tone lands somewhere new on every pass instead of arriving
+// in the same colour each time.
+const TONE_MS = 3300;
+
+// Half the band's width, as a share of the line. kitt's is tighter - a scanner, not a sweep.
+const CLASSIC_BAND = 0.18;
+const KITT_BAND = 0.12;
+
+// Below a quarter speed the wave stops reading as motion; above eight it is a flicker.
+const SLOWEST = 0.25;
+const FASTEST = 8;
+
+type Rgb = [number, number, number];
+type Paint = (text: string) => string;
+type Palette = { fg: (color: string, text: string) => string };
+
+// The ramp the highlight travels: white, the theme's main colour lifted most of the way to
+// white, the same colour lifted a little, then the colour itself. Written as how far each stop
+// sits from the accent toward white, so every theme gets the same shape in its own hue.
+const TOWARD_WHITE = [1, 0.75, 0.35, 0];
+const WHITE: Rgb = [255, 255, 255];
+
+/** The width the wave travels over when the message has not been seen yet. */
+const NOMINAL = 34;
+
+/** The colour pi would paint with, read back out of the escape it emits. */
+// There is no API for a theme's raw values, and parsing the theme file again would miss the
+// live one during a /settings preview. Painting one character and reading the escape asks the
+// same object pi is about to paint with.
+export const toneOf = (theme: Palette, key: string): Rgb | undefined => {
+	const found = /\x1b\[38;2;(\d+);(\d+);(\d+)m/.exec(theme.fg(key, "x"));
+	return found === null ? undefined : [Number(found[1]), Number(found[2]), Number(found[3])];
+};
+
+export const blend = (from: Rgb, to: Rgb, amount: number): Rgb => [
+	Math.round(from[0] + (to[0] - from[0]) * amount),
+	Math.round(from[1] + (to[1] - from[1]) * amount),
+	Math.round(from[2] + (to[2] - from[2]) * amount),
+];
+
+const ink = ([r, g, b]: Rgb, text: string) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[39m`;
+
+/** Where on the ramp the highlight is at time `ms`, blended rather than stepped. */
+// Stepping from one stop to the next makes the whole line jump colour between two frames. The
+// ramp is walked there and back rather than wrapping, so white never cuts straight back to the
+// accent at the seam.
+export const highlight = (accent: Rgb, ms: number, speed: number): Rgb => {
+	const stops = TOWARD_WHITE.map((toward) => blend(accent, WHITE, toward));
+	const period = (TONE_MS * 2) / speed;
+	const phase = (ms % period) / period;
+	const along = (phase < 0.5 ? phase * 2 : 2 - phase * 2) * (stops.length - 1);
+	const at = Math.min(stops.length - 2, Math.floor(along));
+	return blend(stops[at] as Rgb, stops[at + 1] as Rgb, along - at);
+};
+
+/** How much of the highlight column `index` gets: 1 at the middle of the band, 0 outside it. */
+export const strength = (index: number, middle: number, half: number): number =>
+	half <= 0 ? 0 : Math.max(0, 1 - Math.abs(index - middle) / half);
+
+/** Where the band sits at time `ms`, in columns. */
+// classic starts a band-width off the left edge and ends one off the right, so the wave enters
+// and leaves rather than appearing mid-line. kitt turns around at both ends, and eases into the
+// turn - a linear bounce reads as a hard bounce off a wall.
+export const middleAt = (mode: Mode, ms: number, width: number, speed: number): number => {
+	if (mode === "kitt") {
+		const period = (KITT_MS * 2) / speed;
+		const phase = (ms % period) / period;
+		const there = phase < 0.5 ? phase * 2 : 2 - phase * 2;
+		return there * there * (3 - 2 * there) * width;
+	}
+	const period = CLASSIC_MS / speed;
+	const travel = width * (1 + CLASSIC_BAND * 2);
+	return ((ms % period) / period) * travel - width * CLASSIC_BAND;
+};
+
+/** `classic`, `kitt 3`, `off`. A speed that makes no sense is not a reason to refuse the mode. */
+export const parseSpec = (text: string): Spec | undefined => {
+	const [name, rate] = text.trim().split(/\s+/);
+	if (!(MODES as readonly string[]).includes(name ?? "")) return undefined;
+	const asked = Number(rate);
+	const speed = Number.isFinite(asked) && asked > 0 ? Math.min(FASTEST, Math.max(SLOWEST, asked)) : 1;
+	return { mode: name as Mode, speed };
+};
+
+// The spinner and the message are painted by two separate calls, and only the second one knows
+// how long the line is. Remembering it keeps both in the same coordinate space, so the band
+// crosses the glyph and the text as one wave instead of two.
+let span = NOMINAL;
+
+const wave = (theme: Palette, spec: Spec, text: string, offset: number): string => {
+	const base = toneOf(theme, "muted");
+	const accent = toneOf(theme, "accent");
+	if (base === undefined || accent === undefined) return theme.fg("muted", text);
+
+	const now = Date.now();
+	const high = highlight(accent, now, spec.speed);
+	const middle = middleAt(spec.mode, now, span, spec.speed);
+	const half = span * (spec.mode === "kitt" ? KITT_BAND : CLASSIC_BAND);
+	return [...text]
+		.map((glyph, at) => ink(blend(base, high, strength(offset + at, middle, half)), glyph))
+		.join("");
+};
+
+export const painters = (theme: Palette, spec: Spec): { spinner: Paint; message: Paint } =>
+	spec.mode === "off"
+		? { spinner: (text) => theme.fg("muted", text), message: (text) => theme.fg("muted", text) }
+		: {
+				spinner: (text) => wave(theme, spec, text, 0),
+				message: (text) => {
+					span = text.length + 2; // the glyph and the space pi puts after it
+					return wave(theme, spec, text, 2);
+				},
+			};
+
+const DEFAULT: Spec = { mode: "classic", speed: 1 };
+
+const read = (): Spec => (existsSync(FILE) ? (parseSpec(readFileSync(FILE, "utf8")) ?? DEFAULT) : DEFAULT);
+
+const written = (spec: Spec) => (spec.speed === 1 ? spec.mode : `${spec.mode} ${spec.speed}`);
+
+const install = (ctx: ExtensionContext | ExtensionCommandContext, spec: Spec): void => {
+	// Read the theme on every call rather than closing over it: pi swaps the theme object during
+	// a /settings preview, and a captured one would shimmer in the palette of the theme that was
+	// active when the command ran.
+	const live = painters({ fg: (color, text) => ctx.ui.theme.fg(color as never, text) }, spec);
+	(globalThis as { __umbraShimmer?: unknown }).__umbraShimmer = live;
+};
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+		install(ctx, read());
+	});
+
+	pi.registerCommand("umb-shimmer", {
+		description: "Working indicator animation: /umb-shimmer classic | kitt | off [speed]",
+		// Both fields, and null rather than an empty list: pi reads `label` when it applies a
+		// completion, so an item carrying only `value` takes the whole process down on the first
+		// Tab. That is an uncaughtException, not a caught extension error.
+		getArgumentCompletions(text: string) {
+			const items = MODES.filter((mode) => mode.startsWith(text.trim())).map((mode) => ({ value: mode, label: mode }));
+			return items.length > 0 ? items : null;
+		},
+		handler: (args: string, ctx: ExtensionCommandContext) => {
+			if (args.trim() === "") {
+				return ctx.ui.notify(`Now: ${written(read())}. /umb-shimmer ${MODES.join(" | ")} [speed]`, "info");
+			}
+			const spec = parseSpec(args);
+			if (spec === undefined) {
+				return ctx.ui.notify(`No such shimmer: ${args.trim()}. One of: ${MODES.join(", ")}`, "warning");
+			}
+			writeFileSync(FILE, written(spec));
+			install(ctx, spec);
+			ctx.ui.notify(`Shimmer: ${written(spec)}.`, "info");
+		},
+	});
+}

package/node_modules/pi-umbra-shimmer/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-umbra-shimmer",
+  "version": "0.1.0",
+  "description": "A wave of colour running through pi's working indicator, over both the spinner and the text. Needs the umbra bundle patches; without them it does nothing.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "tui",
+    "spinner",
+    "animation"
+  ],
+  "author": "grkn",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grknbyk/pi-umbra.git",
+    "directory": "pi-umbra-shimmer"
+  },
+  "homepage": "https://github.com/grknbyk/pi-umbra/tree/main/pi-umbra-shimmer#readme",
+  "bugs": "https://github.com/grknbyk/pi-umbra/issues",
+  "files": [
+    "extensions",
+    "checks",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  }
+}

package/node_modules/pi-umbra-skill-matcher/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 grkn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pi-umbra-skill-matcher/README.md

@@ -0,0 +1,19 @@
+# pi-umbra-skill-matcher
+
+Type /huh and reach skill:huh. pi lists every skill under its bare name, which is not the name that dispatches.
+
+```
+pi-umbra-skill-matcher/
+├── checks
+│   └── umbra-skill-matcher.check.ts
+└── extensions
+    └── umbra-skill-matcher.ts
+```
+
+## Install
+
+```sh
+pi install npm:pi-umbra-skill-matcher
+```
+
+MIT.

package/node_modules/pi-umbra-skill-matcher/checks/umbra-skill-matcher.check.ts

@@ -0,0 +1,94 @@
+// Runs skill-fuzzy against pi's REAL built-in provider, so a change in pi's prefix/value
+// contract fails here instead of silently in the TUI.
+//   bun run umbra-skill-matcher.check.ts
+import assert from "node:assert";
+import { CombinedAutocompleteProvider } from "@earendil-works/pi-tui";
+import skillFuzzy, { midPromptWord } from "../extensions/umbra-skill-matcher.ts";
+
+const COMMANDS = [
+    { name: "huh", source: "skill", description: "Restate the last message plainly." },
+    { name: "hula-hola", source: "skill", description: "dance" },
+    { name: "what-the-hex", source: "skill", description: "hex" },
+    { name: "picasso", source: "skill", description: "frontend" },
+    { name: "call-council", source: "skill", description: "council skill" },
+    { name: "call-council", source: "extension", description: "council extension" },
+    { name: "help", source: "builtin", description: "help" },
+];
+
+let wrap: (current: unknown) => any;
+const pi = {
+    getCommands: () => COMMANDS,
+    on: (_event: string, handler: (e: unknown, ctx: unknown) => void) =>
+        handler({}, { ui: { addAutocompleteProvider: (factory: typeof wrap) => (wrap = factory) } }),
+};
+skillFuzzy(pi as never);
+
+const builtin = new CombinedAutocompleteProvider(COMMANDS as never, process.cwd());
+const provider = wrap!(builtin);
+const labels = async (typed: string) => {
+    const got = await provider.getSuggestions([typed], 0, typed.length, { signal: AbortSignal.timeout(5000) });
+    return (got?.items ?? []).map((item: { label: string }) => item.label);
+};
+
+// The user's three examples: a shorter query lists more skills, all in the runnable form.
+// pi's matcher is subsequence-based, not contains, so "/huh" also reaches "hula-hola" (h-u-h).
+// That is pi's own ranking to own; all this checks is that the exact match leads.
+assert.equal((await labels("/huh"))[0], "skill:huh");
+assert.ok((await labels("/hu")).includes("skill:huh"), "/hu must offer skill:huh");
+assert.ok((await labels("/hu")).includes("skill:hula-hola"), "/hu must offer skill:hula-hola");
+assert.ok((await labels("/h")).includes("skill:what-the-hex"), "/h must reach a mid-word match");
+
+// A skill is never offered under the bare name that does not run.
+assert.ok(!(await labels("/pic")).includes("picasso"), "bare picasso must be gone");
+assert.deepEqual(await labels("/pic"), ["skill:picasso"]);
+
+// "skill:" typed by hand still finds it, which plain fuzzy on the bare name cannot.
+assert.ok((await labels("/skill:pic")).includes("skill:picasso"), "explicit prefix must still match");
+
+// call-council belongs to an extension too, so its bare form stays runnable and untouched.
+assert.ok((await labels("/call")).includes("call-council"), "extension command must survive");
+
+// Browsing the whole list with a bare "/" must show the runnable form too, not just a search.
+const all = await labels("/");
+assert.ok(all.includes("skill:huh"), "bare / must list skills in runnable form");
+assert.ok(!all.includes("huh"), "bare / must not leak the name that does not run");
+assert.ok(all.includes("help"), "bare / must keep non-skill commands");
+
+// Selecting the row writes exactly "/skill:huh " — one slash, one trailing space.
+const item = { value: "skill:huh", label: "skill:huh" };
+const applied = provider.applyCompletion(["/huh"], 0, 4, item, "/huh");
+assert.equal(applied.lines[0], "/skill:huh ");
+assert.equal(applied.cursorCol, 11);
+
+console.log("umbra-skill-matcher: all checks passed");
+
+// --- mid-sentence ---------------------------------------------------------------------------
+// The token test, first on its own. These are the shapes the repatch entries also decide with,
+// so a change here without a change there means the menu opens on something it cannot fill.
+assert.equal(midPromptWord("run this /pic"), "pic", "a token after real text is ours");
+assert.equal(midPromptWord("run this /"), "", "an empty token is ours - that is the keystroke");
+assert.equal(midPromptWord("/pic"), null, "the line-start form belongs to the built-in provider");
+assert.equal(midPromptWord("   /pic"), null, "an indented line start is still a line start");
+assert.equal(midPromptWord("open src/pic"), null, "a path is not a command");
+assert.equal(midPromptWord("open ~/pic"), null, "nor is a home path");
+assert.equal(midPromptWord("run /pic then"), null, "the token must end at the cursor");
+
+// Mid-sentence rows carry the bare skill name, because nothing dispatches them: pi runs a command
+// only when the message starts with a slash. The name is what pi's own <available_skills> block
+// lists, so it is the form the model can act on.
+const mid = async (typed: string) => {
+    const got = await provider.getSuggestions([typed], 0, typed.length, { signal: AbortSignal.timeout(5000) });
+    return (got?.items ?? []).map((item: { value: string }) => item.value);
+};
+assert.deepEqual(await mid("use the /pic"), ["/picasso"]);
+assert.ok(!(await mid("use the /pic")).includes("/skill:picasso"), "no dispatcher prefix mid-sentence");
+assert.ok((await mid("use the /call")).includes("/call-council"), "skills only, once");
+assert.equal((await mid("use the /call")).length, 1, "the extension twin must not double the row");
+assert.equal((await mid("use the /zzz")).length, 0, "no match means no menu");
+
+// Selecting a mid-sentence row keeps the sentence and writes one slash.
+const midItem = { value: "/picasso", label: "picasso" };
+const midApplied = provider.applyCompletion(["use the /pic"], 0, 12, midItem, "/pic");
+assert.equal(midApplied.lines[0], "use the /picasso");
+
+console.log("umbra-skill-matcher: mid-sentence checks passed");

package/node_modules/pi-umbra-skill-matcher/extensions/umbra-skill-matcher.ts

@@ -0,0 +1,124 @@
+// pi registers a skill in the completion list under its bare name ("huh"), but only
+// "/skill:huh" actually runs one. So the built-in dropdown offers "/huh", the user presses
+// enter, and pi answers "Unknown command". The matching itself is already fuzzy; the name it
+// matches against is what is wrong.
+//
+// This wraps the built-in provider and rewrites every skill row to the form that runs. It also
+// re-runs the match against the prefixed name, so typing "/skill:hu" still finds "skill:huh"
+// after the built-in fuzzy pass has given up on it.
+//
+// It also fills the mid-sentence slash menu that two repatch entries open. pi's editor gates the
+// menu on the line starting with "/", so a "/name" written inside a sentence never reached a
+// provider at all; the patches lift that gate and the branch below decides what appears.
+//
+// Contract taken from pi-tui's CombinedAutocompleteProvider: `prefix` is the text before the
+// cursor INCLUDING the leading slash, and `item.value` is the bare command name — applyCompletion
+// writes `${before}/${value} ` itself, so the value carries neither slash nor trailing space.
+// That holds only while the token starts the line. Mid-sentence the same method falls through to
+// `${before}${value}`, which is why those rows carry their own slash.
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const SKILL_PREFIX = "skill:";
+const MAX_ROWS = 12;
+
+type Item = { value: string; label: string; description?: string };
+type Suggestions = { items: Item[]; prefix: string } | null;
+
+// Only complete while the command word is the whole line: "/pic" completes, "/skill:picasso go"
+// does not, because there the user is writing the argument.
+const commandWord = (before: string): string | null => {
+    const match = /^\/(\S*)$/.exec(before);
+    return match ? match[1] : null;
+};
+
+// The same token test the two repatch entries use to open the slash menu mid-sentence, so the
+// menu and its contents agree on what counts: last token on the line, no space in it, and real
+// text before it that ends in whitespace. "src/foo" and an indented "  /foo" both fail, which
+// leaves paths and line-start commands to the built-in provider.
+export const midPromptWord = (before: string): string | null => {
+    const slash = before.lastIndexOf("/");
+    if (slash < 1 || before.slice(slash + 1).includes(" ")) return null;
+    const head = before.slice(0, slash);
+    return head.trim() === "" || head === head.trimEnd() ? null : before.slice(slash + 1);
+};
+
+export default function skillFuzzy(pi: ExtensionAPI) {
+    pi.on("session_start", (_event, ctx: ExtensionContext) => {
+        ctx.ui.addAutocompleteProvider((current) => ({
+            triggerCharacters: ["/"],
+
+            async getSuggestions(lines: string[], line: number, col: number, options: never) {
+                const before = (lines[line] ?? "").slice(0, col);
+
+                // pi dispatches a command only when the whole message starts with a slash, so a
+                // "/name" written mid-sentence is never run - it is text the model reads. pi's
+                // system prompt already lists every skill and tells the model to open the
+                // matching SKILL.md, so the bare name is what belongs here. The "skill:" form
+                // below exists for the dispatcher, and the dispatcher never sees this one.
+                const midWord = midPromptWord(before);
+                if (midWord !== null) {
+                    const query = midWord.toLowerCase();
+                    const items = pi
+                        .getCommands()
+                        .filter((command) => command.source === "skill" && command.name.toLowerCase().includes(query))
+                        .slice(0, MAX_ROWS)
+                        .map((command) => ({
+                            // applyCompletion writes `${before}${value}` for a token that does not
+                            // start the line, so the value carries its own slash.
+                            value: `/${command.name}`,
+                            label: command.name,
+                            description: command.description ?? "skill",
+                        }));
+                    return items.length === 0 ? null : { items, prefix: `/${midWord}` };
+                }
+
+                const base = (await current.getSuggestions(lines, line, col, options)) as Suggestions;
+                const typed = commandWord(before);
+                if (typed === null) return base;
+
+                const commands = pi.getCommands();
+                // "call-council" is both a skill and an extension command, and there the bare
+                // "/call-council" is the real one. Only touch a name nothing else claims.
+                const taken = new Set(
+                    commands.filter((command) => command.source !== "skill").map((command) => command.name),
+                );
+                const skills = commands.filter(
+                    (command) => command.source === "skill" && !taken.has(command.name),
+                );
+                const byName = new Map(skills.map((command) => [command.name, command]));
+
+                const asSkill = (name: string, description?: string): Item => ({
+                    value: `${SKILL_PREFIX}${name}`,
+                    label: `${SKILL_PREFIX}${name}`,
+                    description: description ?? byName.get(name)?.description ?? "skill",
+                });
+
+                const fixed = (base?.items ?? []).map((item) =>
+                    byName.has(item.value) ? asSkill(item.value, item.description) : item,
+                );
+
+                const query = typed.toLowerCase().replace(/^skill:/, "");
+                const shown = new Set(fixed.map((item) => item.value));
+                const extra = query
+                    ? skills
+                          .filter((command) => command.name.toLowerCase().includes(query))
+                          .map((command) => asSkill(command.name))
+                          .filter((item) => !shown.has(item.value))
+                          .slice(0, MAX_ROWS)
+                    : [];
+
+                const items = [...fixed, ...extra];
+                if (items.length === 0) return null;
+                return { items, prefix: base?.prefix ?? `/${typed}` };
+            },
+
+            applyCompletion(lines: string[], line: number, col: number, item: Item, prefix: string) {
+                return current.applyCompletion(lines, line, col, item, prefix);
+            },
+
+            shouldTriggerFileCompletion(lines: string[], line: number, col: number) {
+                return current.shouldTriggerFileCompletion?.(lines, line, col) ?? true;
+            },
+        }));
+    });
+}