@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/interactive/slash-autocomplete.ts

@@ -1,5 +1,3 @@
-import type { Skill } from "../domains/resources/skills/loader.js";
-import type { MarketplaceSkill } from "../domains/resources/skills/marketplace.js";
 import {
 	type AutocompleteItem,
 	type AutocompleteProvider,
@@ -10,33 +8,82 @@ import {
 	visibleWidth,
 } from "../engine/tui.js";
 import { resolveFdBinary } from "../tools/executables.js";
-import { commandReference, SLASH_COMMAND_GROUPS } from "./slash-commands.js";
-import { type CommandArgsSpec, completeArgs, renderArgsSpec } from "./slash-spec.js";
+import {
+	createFileReferenceCompletionSource,
+	type FileReferenceCompletionSource,
+} from "./file-reference-completion.js";
+import { commandReference, SETTINGS_AREA_IDS, SLASH_COMMAND_GROUPS } from "./slash-commands.js";
+import {
+	type ArgCompletion,
+	COMPLETION_SLOT_NAMES,
+	type CommandArgsSpec,
+	type CompletionSlotName,
+	completeArgs,
+	renderArgsSpec,
+} from "./slash-spec.js";
 
 export type SlashAutocompleteCommand = SlashCommand;
 
-/**
- * The suggestion row shares one truncated column with the command description,
- * so the hint's job is orientation, not the full grammar. Anything longer than
- * this budget is elided; the full usage lives in the usage notice and in the
- * per-token argument completions.
- */
 const ARGUMENT_HINT_BUDGET = 44;
-
-/** Fits the narrowest description column the slash popup grants at 120 cols. */
 const COMPLETION_DESCRIPTION_BUDGET = 80;
 
+export interface CompletionValue {
+	/** Stable identity; distinct from the inserted spelling when aliases are displayed. */
+	id: string;
+	value: string;
+	label: string;
+	description: string;
+	disabledReason?: string;
+	sensitive?: boolean;
+}
+
+export interface CompletionSourceRequest {
+	slot: CompletionSlotName;
+	prefix: string;
+	command: string;
+	subcommand?: string;
+	line: string;
+	cursor: number;
+	generation: number;
+	signal: AbortSignal;
+}
+
+export type CompletionSource = (request: CompletionSourceRequest) => Promise<ReadonlyArray<CompletionValue>>;
+export type CompletionSources = Partial<Record<CompletionSlotName, CompletionSource>>;
+
+export interface SlashCompletionItem extends AutocompleteItem {
+	id: string;
+	kind: "command" | "flag" | "value" | "submenu" | "open-submenu";
+	replacement: { start: number; end: number };
+	appendSpace: boolean;
+	disabledReason?: string;
+	completionSlot?: CompletionSlotName;
+	quote?: '"' | "'";
+	remainingGrammar?: string;
+	effectDescription?: string;
+	submenu?: { parent: string; back: true };
+	/** Cursor adjustment after insertion; quoted directories keep it before the closing quote. */
+	cursorOffset?: number;
+}
+
 export interface SlashAutocompleteOptions {
 	basePath?: string;
 	fdPath?: string | null;
-	listSkills?: () => { installed: Skill[]; marketplace: MarketplaceSkill[] };
+	/** Slice 11 replaces the named no-op sources with read-only runtime sources. */
+	completionSources?: CompletionSources;
+	/** Replace the default workspace-aware `@` source without adding a second composer provider. */
+	fileReferenceSource?: FileReferenceCompletionSource;
+	/** @deprecated Dynamic skill values move to the named `skills` slot in slice 11. */
+	listSkills?: () => unknown;
+}
+
+/** Complete provider surface now, deliberately inert until slice 11 wiring. */
+function stubCompletionSources(): Record<CompletionSlotName, CompletionSource> {
+	const sources = {} as Record<CompletionSlotName, CompletionSource>;
+	for (const slot of COMPLETION_SLOT_NAMES) sources[slot] = async () => [];
+	return sources;
 }
 
-/**
- * A hint that fits the row. Subcommand commands list their subcommand names;
- * flag commands keep the positional tail whole and include leading flags only
- * while the budget holds, eliding the remainder behind an ellipsis.
- */
 function compactArgumentHint(args: CommandArgsSpec | undefined): string | undefined {
 	if (!args) return undefined;
 	if (args.subcommands) {
@@ -44,97 +91,224 @@ function compactArgumentHint(args: CommandArgsSpec | undefined): string | undefi
 			...(args.flags ? { flags: args.flags } : {}),
 			...(args.positionals ? { positionals: args.positionals } : {}),
 		});
-		const parts = [...(rootStr.length > 0 ? [rootStr] : []), ...Object.keys(args.subcommands)];
-		const joined = parts.join(" | ");
-		return joined.length > 0 ? joined : undefined;
+		const parts = [...(rootStr ? [rootStr] : []), ...Object.keys(args.subcommands)];
+		return parts.join(" | ") || undefined;
 	}
 	const positionalTail = renderArgsSpec({ ...(args.positionals ? { positionals: args.positionals } : {}) });
-	const tail = positionalTail.length > 0 ? ` ${positionalTail}` : "";
+	const tail = positionalTail ? ` ${positionalTail}` : "";
 	const flagParts = (args.flags ?? []).map((flag) => renderArgsSpec({ flags: [flag] }));
 	const kept: string[] = [];
 	for (const part of flagParts) {
-		const candidate = [...kept, part].join(" ");
-		if (`${candidate} …${tail}`.length > ARGUMENT_HINT_BUDGET) break;
+		if (`${[...kept, part].join(" ")} …${tail}`.length > ARGUMENT_HINT_BUDGET) break;
 		kept.push(part);
 	}
-	let flagsStr = kept.join(" ");
-	if (kept.length < flagParts.length) flagsStr = flagsStr.length > 0 ? `${flagsStr} …` : "…";
-	const hint = `${flagsStr}${flagsStr.length > 0 ? tail : positionalTail}`.trim();
-	return hint.length > 0 ? hint : undefined;
+	let flags = kept.join(" ");
+	if (kept.length < flagParts.length) flags = flags ? `${flags} …` : "…";
+	const hint = `${flags}${flags ? tail : positionalTail}`.trim();
+	return hint || undefined;
 }
 
-function argumentCompletionItems(
-	args: CommandArgsSpec,
-	argumentText: string,
-	subcommandDescriptions?: Readonly<Record<string, string>>,
-): AutocompleteItem[] | null {
-	const result = completeArgs(args, argumentText);
-	if (!result) return null;
-	// The provider replaces the whole argument text with the item value, so
-	// each value carries the typed stem verbatim with only the trailing token
-	// swapped for the completion.
-	const stem = argumentText.slice(0, result.tokenStart);
-	return result.completions.map((completion) => {
-		const description = subcommandDescriptions?.[completion.token] ?? completion.hint;
-		return {
-			value: `${stem}${completion.token}`,
-			label: completion.token,
-			...(description ? { description } : {}),
-		};
-	});
-}
+/** Explicit attachment manifest: grammar owns positions, providers only own values. */
+export const COMPLETION_SLOT_MANIFEST: Readonly<Record<string, CompletionSlotName>> = {
+	"run:pos:agent": "agents",
+	"run:flag:--agent-profile": "agent-profiles",
+	"run:flag:--runtime": "worker-runtimes",
+	"run:flag:--target": "targets",
+	"run:flag:--model": "models",
+	"run:flag:--require": "capabilities",
+	"delegate:pos:agent-id": "external-agents",
+	"council:flag:--roster": "rosters",
+	"share:pos:run-id": "shareable-runs",
+	"skill:pos:name": "skills",
+	"fleet/run:pos:name": "fleet-contracts",
+	"fleet/run:flag:--var": "fleet-vars",
+	"tasks/hand:pos:id": "tasks",
+	"tasks/done:pos:id": "tasks",
+	"tasks/drop:pos:id": "tasks",
+	"context/recall:pos:ref": "context-refs",
+	"view/verify:pos:runId": "receipts",
+	"panes/show:pos:run-or-agent": "pane-runs-agents",
+	"panes/open:pos:preset-or-argv": "pane-presets",
+	"panes/close:pos:target": "pane-targets",
+	"resources/library:pos:kind": "library-tabs",
+	"model:pos:pattern": "models",
+	"thinking:pos:level": "thinking-levels",
+	"settings:pos:area": "settings-areas",
+	"settings:pos:group": "settings-groups",
+	"help:pos:query": "help-queries",
+	"archive/export:pos:path": "paths",
+	"archive/import:pos:path": "paths",
+	"export:pos:path": "paths",
+};
 
-export function buildSlashAutocompleteCommands(): SlashAutocompleteCommand[] {
-	const reference = commandReference();
-	return SLASH_COMMAND_GROUPS.flatMap((group) => reference.filter((ref) => ref.group === group)).map((ref) => {
-		const argumentHint = compactArgumentHint(ref.args);
-		const args = ref.args;
-		return {
-			name: ref.name,
-			description: ref.description,
-			...(argumentHint ? { argumentHint } : {}),
-			...(args
-				? {
-						getArgumentCompletions: (argumentText: string) =>
-							argumentCompletionItems(args, argumentText, ref.subcommandDescriptions),
-					}
-				: {}),
-		};
+function completionGrammar(command: string, args: CommandArgsSpec): CommandArgsSpec {
+	const clone = (spec: CommandArgsSpec, path: string): CommandArgsSpec => ({
+		...spec,
+		...(spec.flags
+			? {
+					flags: spec.flags.map((flag) => {
+						const completionSlot = COMPLETION_SLOT_MANIFEST[`${path}:flag:${flag.name}`];
+						return { ...flag, ...(completionSlot ? { completionSlot } : {}) };
+					}),
+				}
+			: {}),
+		...(spec.positionals
+			? {
+					positionals: spec.positionals.map((pos) => {
+						const completionSlot = COMPLETION_SLOT_MANIFEST[`${path}:pos:${pos.name}`];
+						const values =
+							command === "output" && pos.name === "verbosity"
+								? (["minimal", "default", "verbose"] as const)
+								: command === "settings" && pos.name === "area"
+									? SETTINGS_AREA_IDS
+									: undefined;
+						return { ...pos, ...(completionSlot ? { completionSlot } : {}), ...(values ? { values } : {}) };
+					}),
+				}
+			: {}),
+		...(spec.subcommands
+			? {
+					subcommands: Object.fromEntries(
+						Object.entries(spec.subcommands).map(([name, child]) => [name, clone(child, `${path}/${name}`)]),
+					),
+				}
+			: {}),
 	});
+	return clone(args, command);
 }
 
-function compactCompletionDescription(description: string | undefined): string | undefined {
+function compactDescription(description: string | undefined): string | undefined {
 	if (!description || visibleWidth(description) <= COMPLETION_DESCRIPTION_BUDGET) return description;
-	const clipped = truncateToWidth(description, COMPLETION_DESCRIPTION_BUDGET - 1, "", false).trimEnd();
-	return `${clipped}…`;
+	return `${truncateToWidth(description, COMPLETION_DESCRIPTION_BUDGET - 1, "", false).trimEnd()}…`;
+}
+
+const BARE_VALID_PARENTS = new Set(["agents", "context", "memory", "panes", "resources"]);
+
+interface SlashContext {
+	line: string;
+	command: string;
+	commandStart: number;
+	commandEnd: number;
+	argsStart: number;
 }
 
-function isSlashCommandPrefix(lines: string[], cursorLine: number, cursorCol: number): string | null {
+interface FileReferenceContext {
+	query: string;
+	prefix: string;
+	replacement: { start: number; end: number };
+}
+
+function slashContext(lines: string[], cursorLine: number, cursorCol: number): SlashContext | null {
 	if (cursorLine !== 0) return null;
-	const currentLine = lines[cursorLine] ?? "";
-	const textBeforeCursor = currentLine.slice(0, cursorCol);
-	const firstNonSpace = textBeforeCursor.search(/\S/);
-	if (firstNonSpace === -1 || textBeforeCursor[firstNonSpace] !== "/") return null;
-	const slashText = textBeforeCursor.slice(firstNonSpace);
-	if (slashText.includes(" ")) return null;
-	const prefix = slashText.slice(1);
-	return prefix.includes("/") ? null : prefix;
+	const line = lines[0] ?? "";
+	const first = line.search(/\S/);
+	if (first < 0 || line[first] !== "/" || cursorCol < first + 1) return null;
+	let commandEnd = first + 1;
+	while (commandEnd < line.length && !/\s/.test(line[commandEnd] ?? "")) commandEnd++;
+	const argsStart = commandEnd < line.length ? commandEnd + 1 : commandEnd;
+	// The cursor may be in the command or any argument token, but never in a later editor line.
+	return { line, command: line.slice(first + 1, commandEnd), commandStart: first + 1, commandEnd, argsStart };
+}
+
+function genericTokenRange(line: string, cursor: number): { start: number; end: number } {
+	let start = Math.max(0, Math.min(cursor, line.length));
+	let quote: '"' | "'" | undefined;
+	while (start > 0) {
+		const previous = line[start - 1] ?? "";
+		if (!quote && /\s/.test(previous)) break;
+		if (previous === '"' || previous === "'") quote = quote === previous ? undefined : previous;
+		start--;
+	}
+	let end = Math.max(start, Math.min(cursor, line.length));
+	quote = undefined;
+	while (end < line.length) {
+		const char = line[end] ?? "";
+		if (!quote && /\s/.test(char)) break;
+		if (char === '"' || char === "'") quote = quote === char ? undefined : char;
+		end++;
+	}
+	return { start, end };
+}
+
+function quotedReferenceText(raw: string, quote: '"' | "'"): string {
+	const body = raw.startsWith(quote) ? raw.slice(1) : raw;
+	const withoutClose = body.endsWith(quote) ? body.slice(0, -1) : body;
+	let decoded = "";
+	let escaped = false;
+	for (const character of withoutClose) {
+		if (escaped) {
+			decoded += character;
+			escaped = false;
+			continue;
+		}
+		if (character === "\\") {
+			escaped = true;
+			continue;
+		}
+		decoded += character;
+	}
+	if (escaped) decoded += "\\";
+	return decoded;
+}
+
+function fileReferenceContext(lines: string[], cursorLine: number, cursorCol: number): FileReferenceContext | null {
+	const line = lines[cursorLine] ?? "";
+	const cursor = Math.max(0, Math.min(cursorCol, line.length));
+	for (let start = cursor - 1; start >= 0; start -= 1) {
+		if (line[start] !== "@" || (start > 0 && !/\s/u.test(line[start - 1] ?? ""))) continue;
+		const quote = line[start + 1] === '"' || line[start + 1] === "'" ? (line[start + 1] as '"' | "'") : null;
+		let end = start + 1;
+		let escaped = false;
+		if (quote) {
+			end += 1;
+			while (end < line.length) {
+				const character = line[end] ?? "";
+				end += 1;
+				if (escaped) {
+					escaped = false;
+					continue;
+				}
+				if (character === "\\") {
+					escaped = true;
+					continue;
+				}
+				if (character === quote) break;
+			}
+		} else {
+			while (end < line.length && !/\s/u.test(line[end] ?? "")) end += 1;
+		}
+		if (cursor < start + 1 || cursor > end) continue;
+		const rawQuery = line.slice(start + 1, cursor);
+		return {
+			query: quote ? quotedReferenceText(rawQuery, quote) : rawQuery,
+			prefix: line.slice(start, cursor),
+			replacement: { start, end },
+		};
+	}
+	return null;
+}
+
+function sourceRows(values: ReadonlyArray<CompletionValue>, prefix: string): CompletionValue[] {
+	const lower = prefix.toLowerCase();
+	return values.filter((value) => !value.sensitive && value.value.toLowerCase().startsWith(lower));
 }
 
 class ClioAutocompleteProvider implements AutocompleteProvider {
 	readonly triggerCharacters = ["/", "@"];
-
-	private readonly provider: CombinedAutocompleteProvider;
-	private readonly listSkills: (() => { installed: Skill[]; marketplace: MarketplaceSkill[] }) | undefined;
+	private readonly files: CombinedAutocompleteProvider;
+	private readonly fileReferences: FileReferenceCompletionSource;
+	private readonly sourceBySlot: Record<CompletionSlotName, CompletionSource>;
+	private generation = 0;
 
 	constructor(
-		commands: SlashAutocompleteCommand[],
 		basePath: string,
 		fdPath: string | null,
-		listSkills?: () => { installed: Skill[]; marketplace: MarketplaceSkill[] },
+		sources: CompletionSources,
+		fileReferenceSource?: FileReferenceCompletionSource,
 	) {
-		this.provider = new CombinedAutocompleteProvider(commands, basePath, fdPath);
-		this.listSkills = listSkills;
+		this.files = new CombinedAutocompleteProvider([], basePath, fdPath);
+		this.fileReferences = fileReferenceSource ?? createFileReferenceCompletionSource({ basePath });
+		this.sourceBySlot = { ...stubCompletionSources(), ...sources };
 	}
 
 	async getSuggestions(
@@ -143,114 +317,229 @@ class ClioAutocompleteProvider implements AutocompleteProvider {
 		cursorCol: number,
 		options: { signal: AbortSignal; force?: boolean },
 	): Promise<AutocompleteSuggestions | null> {
-		const currentLine = lines[cursorLine] ?? "";
-		const textBeforeCursor = currentLine.slice(0, cursorCol);
-
-		// Check if we are typing the canonical /skill invocation command (a name
-		// separator after /skill). The bare "/skill" selector with nothing after
-		// it must NOT match here: matching would offer every installed skill as
-		// an autocomplete suggestion with the first one pre-selected, and the
-		// editor's autocomplete-confirm binding shares the Enter key with
-		// submit, so submitting the bare selector would silently commit
-		// whichever skill happened to sort first instead of opening the Skills
-		// Hub (see FINDINGS.md F1).
-		const skillMatch = textBeforeCursor.match(/^\s*\/skill\s+([a-zA-Z0-9_-]*)$/i);
-		if (skillMatch && this.listSkills) {
-			const typedPrefix = skillMatch[1]?.toLowerCase() ?? "";
-			const { installed, marketplace } = this.listSkills();
-
-			const items: AutocompleteItem[] = [];
-
-			// 1. Installed skills
-			for (const skill of installed) {
-				if (skill.name.toLowerCase().startsWith(typedPrefix)) {
-					items.push({
-						value: `skill:${skill.name}`,
-						label: skill.name,
-						description: skill.description,
-					});
-				}
+		const generation = ++this.generation;
+		const context = slashContext(lines, cursorLine, cursorCol);
+		if (!context) {
+			const reference = fileReferenceContext(lines, cursorLine, cursorCol);
+			if (reference) {
+				const values = await this.fileReferences({ query: reference.query, signal: options.signal });
+				if (generation !== this.generation || options.signal.aborted || values.length === 0) return null;
+				return {
+					prefix: reference.prefix,
+					items: values.map((value): SlashCompletionItem => {
+						const quotedDirectory = value.isDirectory && value.value.endsWith('"');
+						return {
+							id: value.id,
+							kind: value.isDirectory ? "open-submenu" : "value",
+							value: value.value,
+							label: value.label,
+							description: value.description,
+							effectDescription: value.description,
+							replacement: reference.replacement,
+							appendSpace: !value.isDirectory,
+							...(quotedDirectory ? { cursorOffset: -1 } : {}),
+							...(value.isDirectory ? { submenu: { parent: `@${value.path}`, back: true } } : {}),
+						};
+					}),
+				};
 			}
+			const suggestions = await this.files.getSuggestions(lines, cursorLine, cursorCol, options);
+			if (!suggestions || generation !== this.generation || options.signal.aborted) return null;
+			const range = genericTokenRange(lines[cursorLine] ?? "", cursorCol);
+			return {
+				prefix: suggestions.prefix,
+				items: suggestions.items.map((item, index) => ({
+					...item,
+					id: `file:${index}:${item.value}`,
+					kind: "value" as const,
+					replacement: range,
+					appendSpace: false,
+					...(item.description ? { effectDescription: item.description } : {}),
+				})),
+			};
+		}
+		const reference = commandReference();
+		const refs = SLASH_COMMAND_GROUPS.flatMap((group) => reference.filter((ref) => ref.group === group));
+		const exactRef = refs.find((candidate) => candidate.name.toLowerCase() === context.command.toLowerCase());
+		if (cursorCol === context.commandEnd && options.force && exactRef && BARE_VALID_PARENTS.has(exactRef.name)) {
+			const item: SlashCompletionItem = {
+				id: `open:${exactRef.name}`,
+				kind: "open-submenu",
+				value: "",
+				label: "Open …",
+				description: `Open /${exactRef.name} actions`,
+				effectDescription: `Open /${exactRef.name} actions`,
+				replacement: { start: context.commandEnd, end: context.commandEnd },
+				appendSpace: true,
+				submenu: { parent: exactRef.name, back: true },
+			};
+			return { items: [item], prefix: "" };
+		}
+		if (cursorCol === context.commandEnd && options.force && exactRef?.args) {
+			const item: SlashCompletionItem = {
+				id: `advance:${exactRef.name}`,
+				kind: "command",
+				value: exactRef.name,
+				label: exactRef.name,
+				description: exactRef.description,
+				effectDescription: exactRef.description,
+				replacement: { start: context.commandStart, end: context.commandEnd },
+				appendSpace: true,
+			};
+			return { items: [item], prefix: context.command };
+		}
+		if (cursorCol <= context.commandEnd) {
+			const prefix = context.line.slice(context.commandStart, cursorCol);
+			const items: SlashCompletionItem[] = refs
+				.filter((ref) => ref.name.toLowerCase().startsWith(prefix.toLowerCase()) && ref.name !== prefix)
+				.map((ref) => {
+					const remainingGrammar = compactArgumentHint(ref.args);
+					const description = compactDescription(`${remainingGrammar ? `${remainingGrammar} — ` : ""}${ref.description}`);
+					const item: SlashCompletionItem = {
+						id: `command:${ref.name}`,
+						kind: "command",
+						value: ref.name,
+						label: ref.name,
+						effectDescription: ref.description,
+						replacement: { start: context.commandStart, end: context.commandEnd },
+						appendSpace: Boolean(ref.args && (ref.args.positionals || ref.args.flags || ref.args.subcommands)),
+					};
+					if (description) item.description = description;
+					if (remainingGrammar) item.remainingGrammar = remainingGrammar;
+					return item;
+				});
+			return items.length ? { items, prefix } : null;
+		}
 
-			// 2. Marketplace skills (uninstalled)
-			for (const skill of marketplace) {
-				if (installed.some((s) => s.name === skill.name)) continue;
-
-				if (skill.name.toLowerCase().startsWith(typedPrefix)) {
-					items.push({
-						value: `marketplace:${skill.name}`,
-						label: `${skill.name} (marketplace)`,
-						description: skill.description,
-					});
+		const ref = refs.find((candidate) => candidate.name.toLowerCase() === context.command.toLowerCase());
+		if (!ref?.args) return null;
+		const argumentText = context.line.slice(context.argsStart);
+		const argumentCursor = Math.max(0, cursorCol - context.argsStart);
+		const grammar = completionGrammar(ref.name, ref.args);
+		const result = completeArgs(grammar, argumentText, argumentCursor);
+		if (!result) return null;
+		const beforeCursor = argumentText.slice(result.tokenStart, argumentCursor);
+		const selectedSubcommand = Object.keys(ref.args.subcommands ?? {}).find(
+			(name) => argumentText.trimStart().split(/\s+/, 1)[0] === name,
+		);
+		const items: SlashCompletionItem[] = [];
+		for (const completion of result.completions) {
+			if (completion.completionSlot) {
+				const values = await this.sourceBySlot[completion.completionSlot]({
+					slot: completion.completionSlot,
+					prefix: beforeCursor,
+					command: ref.name,
+					...(selectedSubcommand ? { subcommand: selectedSubcommand } : {}),
+					line: context.line,
+					cursor: cursorCol,
+					generation,
+					signal: options.signal,
+				});
+				if (generation !== this.generation || options.signal.aborted) return null;
+				for (const value of sourceRows(values, beforeCursor)) {
+					items.push(
+						this.itemFromValue(
+							value,
+							completion,
+							context.argsStart + result.tokenStart,
+							context.argsStart + result.tokenEnd,
+							result.quote,
+						),
+					);
 				}
+				continue;
 			}
-
-			if (items.length > 0) return { items, prefix: typedPrefix };
+			if (completion.token === beforeCursor && options.force !== true) continue;
+			const description = completion.description ?? ref.subcommandDescriptions?.[completion.token] ?? completion.hint;
+			const effectDescription = completion.description ?? ref.subcommandDescriptions?.[completion.token];
+			const item: SlashCompletionItem = {
+				id: `${ref.name}:${completion.token}`,
+				kind: result.submenu ? "submenu" : completion.token.startsWith("--") ? "flag" : "value",
+				value: completion.token,
+				label: completion.token,
+				replacement: { start: context.argsStart + result.tokenStart, end: context.argsStart + result.tokenEnd },
+				appendSpace: completion.hasNextSlot,
+			};
+			if (description) item.description = description;
+			if (completion.hint) item.remainingGrammar = completion.hint;
+			if (effectDescription) item.effectDescription = effectDescription;
+			if (result.submenu) item.submenu = { parent: ref.name, back: true };
+			if (result.quote) item.quote = result.quote;
+			items.push(item);
 		}
+		return items.length ? { items, prefix: beforeCursor } : null;
+	}
 
-		const suggestions = await this.provider.getSuggestions(lines, cursorLine, cursorCol, options);
-		const commandPrefix = isSlashCommandPrefix(lines, cursorLine, cursorCol);
-		if (commandPrefix !== null) {
-			const canonicalItems = (suggestions?.items ?? [])
-				.filter((item) => item.value.startsWith(commandPrefix))
-				.map((item) => {
-					const description = compactCompletionDescription(item.description);
-					if (description === item.description || description === undefined) return item;
-					return { ...item, description };
-				});
-			const items = canonicalItems;
-			if (items.length === 0) return null;
-			return { items, prefix: suggestions?.prefix ?? textBeforeCursor };
-		}
-		// Enter accepts the open completion instead of submitting, so a suggestion
-		// the input already equals costs a keystroke that changes no pixel: typing
-		// `/memory seed` and pressing Enter accepted "seed" and submitted nothing,
-		// which reads as a dropped key and concatenates whatever is typed next
-		// onto the unsent line. Nothing left to complete, no popup, and the first
-		// Enter submits. An explicit Tab is left alone: it asked for the list.
-		if (suggestions && options.force !== true && suggestions.items.some((item) => item.value === suggestions.prefix)) {
-			return null;
-		}
-		return suggestions;
+	private itemFromValue(
+		value: CompletionValue,
+		grammar: ArgCompletion,
+		start: number,
+		end: number,
+		quote?: '"' | "'",
+	): SlashCompletionItem {
+		return {
+			id: value.id,
+			kind: "value",
+			value: value.value,
+			label: value.label,
+			description: value.disabledReason ?? value.description,
+			replacement: { start, end },
+			appendSpace: grammar.hasNextSlot,
+			effectDescription: value.description,
+			...(grammar.completionSlot ? { completionSlot: grammar.completionSlot } : {}),
+			...(quote ? { quote } : {}),
+			...(value.disabledReason ? { disabledReason: value.disabledReason } : {}),
+		};
 	}
 
 	applyCompletion(
 		lines: string[],
 		cursorLine: number,
-		cursorCol: number,
+		_cursorCol: number,
 		item: AutocompleteItem,
-		prefix: string,
+		_prefix: string,
 	): { lines: string[]; cursorLine: number; cursorCol: number } {
-		const currentLine = lines[cursorLine] ?? "";
-		const textBeforeCursor = currentLine.slice(0, cursorCol);
-		const textAfterCursor = currentLine.slice(cursorCol);
-
-		const skillMatch = textBeforeCursor.match(/^\s*\/skill\s+[a-zA-Z0-9_-]*$/i);
-		if (skillMatch && (item.value.startsWith("skill:") || item.value.startsWith("marketplace:"))) {
-			const skillName = item.value.slice(item.value.indexOf(":") + 1);
-			const newLine = `/skill ${skillName} ${textAfterCursor}`;
-			const newLines = [...lines];
-			newLines[cursorLine] = newLine;
+		const completion = item as SlashCompletionItem;
+		if (!completion.replacement || completion.disabledReason) {
+			return { lines, cursorLine, cursorCol: _cursorCol };
+		}
+		const current = lines[cursorLine] ?? "";
+		if (completion.appendSpace && completion.quote && current[completion.replacement.end] === completion.quote) {
+			const needsSpace = !/\s/.test(current[completion.replacement.end + 1] ?? "");
+			const inserted = `${completion.value}${completion.quote}${needsSpace ? " " : ""}`;
+			const next = [...lines];
+			next[cursorLine] =
+				`${current.slice(0, completion.replacement.start)}${inserted}${current.slice(completion.replacement.end + 1)}`;
 			return {
-				lines: newLines,
+				lines: next,
 				cursorLine,
-				cursorCol: `/skill ${skillName} `.length,
+				cursorCol: completion.replacement.start + inserted.length + (completion.cursorOffset ?? 0),
 			};
 		}
-
-		return this.provider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+		const needsSpace = completion.appendSpace && !/\s/.test(current[completion.replacement.end] ?? "");
+		const inserted = `${completion.value}${needsSpace ? " " : ""}`;
+		const next = [...lines];
+		next[cursorLine] =
+			`${current.slice(0, completion.replacement.start)}${inserted}${current.slice(completion.replacement.end)}`;
+		return {
+			lines: next,
+			cursorLine,
+			cursorCol: completion.replacement.start + inserted.length + (completion.cursorOffset ?? 0),
+		};
 	}
 
 	shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean {
-		return this.provider.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+		if (slashContext(lines, cursorLine, cursorCol) !== null) return false;
+		if (fileReferenceContext(lines, cursorLine, cursorCol) !== null) return true;
+		return this.files.shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
 	}
 }
 
 export function createSlashCommandAutocompleteProvider(options: SlashAutocompleteOptions = {}): AutocompleteProvider {
 	return new ClioAutocompleteProvider(
-		buildSlashAutocompleteCommands(),
 		options.basePath ?? process.cwd(),
 		options.fdPath === undefined ? resolveFdBinary() : options.fdPath,
-		options.listSkills,
+		options.completionSources ?? {},
+		options.fileReferenceSource,
 	);
 }