@selesai/code 0.13.40 → 0.14.3

package/dist/core/llama/provider.js

@@ -1,143 +0,0 @@
-import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
-import { LlamaClient, llamaInferenceUrl, normalizeLlamaServerUrl } from "./client.js";
-export const LLAMA_PROVIDER_ID = "llama.cpp";
-export const DEFAULT_LLAMA_SERVER_URL = "http://127.0.0.1:8080";
-function credentialServerUrl(credential) {
-    const value = credential?.env?.LLAMA_BASE_URL;
-    return typeof value === "string" && value.trim() ? normalizeLlamaServerUrl(value) : undefined;
-}
-async function resolveServerUrl(ctx, credential) {
-    const configured = credentialServerUrl(credential) ?? (await ctx.env("LLAMA_BASE_URL"))?.trim();
-    return configured ? normalizeLlamaServerUrl(configured) : undefined;
-}
-function modelIsSelectable(model, routerAutoload) {
-    if (model.status.value === "loaded")
-        return true;
-    // Unloaded presets are routable only when llama.cpp router autoload can load them on first use.
-    return routerAutoload && model.status.value === "unloaded" && !model.status.failed && model.source === "preset";
-}
-async function routerAutoloadEnabled(client, catalog, signal) {
-    if (!catalog.some((model) => model.status.value === "unloaded" && model.source === "preset"))
-        return false;
-    try {
-        return (await client.props({ signal })).models_autoload === true;
-    }
-    catch {
-        return false;
-    }
-}
-function toPiModel(model, serverUrl) {
-    const reportedContextWindow = model.meta?.n_ctx ?? model.meta?.n_ctx_train;
-    const contextWindow = reportedContextWindow && reportedContextWindow > 0 ? reportedContextWindow : 128000;
-    return {
-        id: model.id,
-        name: model.id,
-        api: "openai-completions",
-        provider: LLAMA_PROVIDER_ID,
-        baseUrl: llamaInferenceUrl(serverUrl),
-        reasoning: false,
-        input: model.architecture?.input_modalities?.includes("image") ? ["text", "image"] : ["text"],
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow,
-        maxTokens: contextWindow,
-        compat: {
-            supportsStore: false,
-            supportsDeveloperRole: false,
-            supportsReasoningEffort: false,
-            supportsUsageInStreaming: true,
-            supportsStrictMode: false,
-            maxTokensField: "max_tokens",
-        },
-    };
-}
-export function createLlamaProvider() {
-    let models = [];
-    const setCatalog = (catalog, serverUrl, options = {}) => {
-        models = catalog
-            .filter((model) => modelIsSelectable(model, options.routerAutoload === true))
-            .map((model) => toPiModel(model, serverUrl));
-    };
-    const provider = {
-        id: LLAMA_PROVIDER_ID,
-        name: "llama.cpp",
-        baseUrl: llamaInferenceUrl(DEFAULT_LLAMA_SERVER_URL),
-        auth: {
-            apiKey: {
-                name: "llama.cpp server",
-                login: async (interaction) => {
-                    const enteredUrl = await interaction.prompt({
-                        type: "text",
-                        message: "llama.cpp server URL",
-                        placeholder: process.env.LLAMA_BASE_URL ?? DEFAULT_LLAMA_SERVER_URL,
-                    });
-                    const serverUrl = normalizeLlamaServerUrl(enteredUrl.trim() || process.env.LLAMA_BASE_URL || DEFAULT_LLAMA_SERVER_URL);
-                    const apiKey = (await interaction.prompt({
-                        type: "secret",
-                        message: "API key (optional)",
-                    })).trim();
-                    await new LlamaClient(serverUrl, apiKey || undefined).list({ signal: interaction.signal });
-                    return {
-                        type: "api_key",
-                        key: apiKey || undefined,
-                        env: { LLAMA_BASE_URL: serverUrl },
-                    };
-                },
-                check: async ({ ctx, credential }) => {
-                    const serverUrl = await resolveServerUrl(ctx, credential);
-                    return serverUrl
-                        ? { type: "api_key", source: credential ? "stored credential" : "LLAMA_BASE_URL" }
-                        : undefined;
-                },
-                resolve: async ({ ctx, credential }) => {
-                    const serverUrl = await resolveServerUrl(ctx, credential);
-                    if (!serverUrl)
-                        return undefined;
-                    const apiKey = credential?.key ?? (await ctx.env("LLAMA_API_KEY")) ?? "local";
-                    return {
-                        auth: { apiKey, baseUrl: llamaInferenceUrl(serverUrl) },
-                        env: { ...credential?.env, LLAMA_BASE_URL: serverUrl },
-                        source: credential ? "stored credential" : "LLAMA_BASE_URL",
-                    };
-                },
-            },
-        },
-        getModels: () => models,
-        refreshModels: async (context) => {
-            const stored = context.stored;
-            const restored = stored
-                ? stored.models.filter((model) => model.provider === LLAMA_PROVIDER_ID && model.api === "openai-completions")
-                : [];
-            if (!(await context.publish({
-                update: () => {
-                    models = restored;
-                },
-            }))) {
-                return;
-            }
-            if (!context.allowNetwork || context.signal.aborted || context.credential?.type !== "api_key")
-                return;
-            const serverUrl = credentialServerUrl(context.credential);
-            if (!serverUrl)
-                return;
-            const client = new LlamaClient(serverUrl, context.credential.key);
-            const catalog = await client.list({ signal: context.signal });
-            if (context.signal.aborted)
-                return;
-            const routerAutoload = await routerAutoloadEnabled(client, catalog, context.signal);
-            if (context.signal.aborted)
-                return;
-            const refreshed = catalog
-                .filter((model) => modelIsSelectable(model, routerAutoload))
-                .map((model) => toPiModel(model, serverUrl));
-            await context.publish({
-                persist: { models: refreshed, checkedAt: Date.now() },
-                update: () => {
-                    models = refreshed;
-                },
-            });
-        },
-        stream: (model, context, options) => stream(model, context, options),
-        streamSimple: (model, context, options) => streamSimple(model, context, options),
-    };
-    return { provider, setCatalog };
-}

package/dist/core/settings-manager-auto-handoff.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/settings-manager-auto-handoff.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SettingsManager } from "./settings-manager.js";
-describe("auto handoff settings", () => {
-    it("seeds persisted defaults for existing user settings", async () => {
-        const manager = SettingsManager.inMemory({ theme: "dark" });
-        await manager.flush();
-        await manager.reload();
-        expect(manager.getAutoHandoffEnabled()).toBe(false);
-        expect(manager.getAutoHandoffThresholdTokens()).toBe(128_000);
-        expect(manager.getGlobalSettings().autoHandoff).toEqual({
-            enabled: false,
-            thresholdTokens: 128_000,
-        });
-    });
-    it("preserves configured auto handoff values while filling missing fields", async () => {
-        const manager = SettingsManager.inMemory({ autoHandoff: { enabled: true } });
-        await manager.flush();
-        expect(manager.getGlobalSettings().autoHandoff).toEqual({
-            enabled: true,
-            thresholdTokens: 128_000,
-        });
-    });
-    it("persists enabled state", async () => {
-        const manager = SettingsManager.inMemory();
-        manager.setAutoHandoffEnabled(true);
-        await manager.flush();
-        expect(manager.getAutoHandoffEnabled()).toBe(true);
-        expect(manager.getGlobalSettings().autoHandoff?.enabled).toBe(true);
-    });
-    it("persists threshold and clamps to minimum 1000", async () => {
-        const manager = SettingsManager.inMemory();
-        manager.setAutoHandoffThresholdTokens(64_000);
-        await manager.flush();
-        expect(manager.getAutoHandoffThresholdTokens()).toBe(64_000);
-        manager.setAutoHandoffThresholdTokens(500);
-        await manager.flush();
-        expect(manager.getAutoHandoffThresholdTokens()).toBe(1000);
-        manager.setAutoHandoffThresholdTokens(128_500.7);
-        await manager.flush();
-        expect(manager.getAutoHandoffThresholdTokens()).toBe(128_500);
-    });
-    it("defaults Jev capability routing on and persists the /settings toggle", async () => {
-        const manager = SettingsManager.inMemory();
-        expect(manager.getCapabilityGatewayJevEnabled()).toBe(true);
-        manager.setCapabilityGatewayJevEnabled(false);
-        await manager.flush();
-        expect(manager.getCapabilityGatewayJevEnabled()).toBe(false);
-        expect(manager.getGlobalSettings().capabilityGateway?.routing?.jev?.enabled).toBe(false);
-        manager.setCapabilityGatewayJevEnabled(true);
-        await manager.flush();
-        expect(manager.getCapabilityGatewayJevEnabled()).toBe(true);
-    });
-});

package/dist/extensions/capability-gateway/catalog.ts

@@ -1,177 +0,0 @@
-/**
- * Capability gateway catalog and deterministic router.
- *
- * Pure functions: no host imports, fully unit-testable. The router uses
- * deterministic local scoring (name/alias matches above token overlap) and
- * never calls a model.
- */
-
-import { readFileSync } from "node:fs";
-
-import { parseFrontmatter, type ResolvedSkillInfo, type ToolInfo } from "@selesai/code";
-
-export interface CatalogEntry {
-	name: string;
-	kind: "tool" | "skill";
-	summary: string;
-	aliases: string[];
-	category?: string;
-	eligible: boolean;
-}
-
-/** Built-in tools are never mediated by the gateway. */
-export const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls"]);
-
-/** First sentence of a description, used as the conservative fallback summary. */
-export function firstSentence(text: string): string {
-	const trimmed = text.trim();
-	const end = trimmed.search(/[.!?](?:\s|$)/);
-	return (end === -1 ? trimmed : trimmed.slice(0, end + 1)).trim();
-}
-
-/** Compact summary for a tool: explicit discovery metadata wins, then the description's first sentence. */
-export function toolSummary(tool: ToolInfo): string {
-	const explicit = tool.discovery?.summary?.trim();
-	if (explicit) return explicit;
-	const sentence = firstSentence(tool.description);
-	if (sentence) return sentence;
-	return tool.name;
-}
-
-export function buildToolCatalog(tools: ToolInfo[], gatewayToolNames: Set<string>): CatalogEntry[] {
-	return tools
-		.filter((tool) => !BUILTIN_TOOL_NAMES.has(tool.name) && !gatewayToolNames.has(tool.name))
-		.map((tool) => ({
-			name: tool.name,
-			kind: "tool" as const,
-			summary: toolSummary(tool),
-			aliases: tool.discovery?.aliases ?? [],
-			category: tool.discovery?.category,
-			eligible: true,
-		}));
-}
-
-export function buildSkillCatalog(skills: ResolvedSkillInfo[]): CatalogEntry[] {
-	// The same skill resolves once per source (user dir, package, project); the first one wins, as it
-	// does for loading. Duplicates would only spend a bounded Jev request twice on one name.
-	const seen = new Set<string>();
-	return skills
-		.filter((skill) => !skill.disableModelInvocation && !seen.has(skill.name) && seen.add(skill.name))
-		.map((skill) => ({
-			name: skill.name,
-			kind: "skill" as const,
-			summary: skill.description || skillSummaryFromFile(skill.filePath),
-			aliases: [],
-			category: skill.category,
-			eligible: true,
-		}));
-}
-
-// Disabled skills resolve as paths but never parse; read the frontmatter description instead.
-function skillSummaryFromFile(filePath: string): string {
-	try {
-		const { frontmatter } = parseFrontmatter<{ description?: string }>(readFileSync(filePath, "utf-8"));
-		return firstSentence(frontmatter.description ?? "");
-	} catch {
-		return "";
-	}
-}
-
-export function normalizeQuery(text: string): string {
-	return text
-		.toLowerCase()
-		.replace(/[^a-z0-9\s-]/g, " ")
-		.replace(/\s+/g, " ")
-		.trim();
-}
-
-export function tokenize(text: string): string[] {
-	return normalizeQuery(text).split(/\s+/).filter(Boolean);
-}
-
-/** True when two words differ by at most one insertion, deletion, or substitution. */
-function differsByOne(left: string, right: string): boolean {
-	if (Math.abs(left.length - right.length) > 1) return false;
-	let leftIndex = 0;
-	let rightIndex = 0;
-	let differences = 0;
-	while (leftIndex < left.length && rightIndex < right.length) {
-		if (left[leftIndex] === right[rightIndex]) {
-			leftIndex++;
-			rightIndex++;
-			continue;
-		}
-		if (++differences > 1) return false;
-		if (left.length > right.length) leftIndex++;
-		else if (right.length > left.length) rightIndex++;
-		else {
-			leftIndex++;
-			rightIndex++;
-		}
-	}
-	return true;
-}
-
-/** Words that carry no routing signal. */
-const STOPWORDS = new Set([
-	"the", "a", "an", "to", "of", "for", "with", "and", "or", "use", "using", "me", "my", "i",
-	"please", "help", "can", "you", "do", "does", "is", "are", "on", "in", "at", "by", "from",
-	"this", "that", "it", "its", "want", "need", "run", "call", "invoke", "find", "show", "list",
-	"get", "load", "activate", "discover", "capability", "tool", "skill", "the", "a",
-]);
-
-export interface RouteResult {
-	action: "activate" | "recommend" | "hint" | "none";
-	entry?: CatalogEntry;
-	candidates?: CatalogEntry[];
-}
-
-/**
- * Deterministic routing over the compact catalog.
- *
- * - Exact or one-character-off name/alias matches score 3; prefix matches score 2;
- *   each content token shared with the name/alias or summary adds 1.
- * - A unique tool with score >= 3 is auto-activated.
- * - A unique skill with score >= 3 is recommended (never auto-loaded).
- * - Score 2 or a tie at the top produces a catalog-discovery hint.
- * - No signal produces no hint at all.
- */
-export function route(query: string, catalog: CatalogEntry[]): RouteResult {
-	const q = normalizeQuery(query);
-	if (!q) return { action: "none" };
-	const contentTokens = tokenize(q).filter((token) => !STOPWORDS.has(token));
-	if (contentTokens.length === 0) return { action: "none" };
-
-	const scored = catalog.map((entry) => {
-		const names = [entry.name, ...entry.aliases].map(normalizeQuery);
-		const nameTokens = new Set(names.flatMap((name) => name.split(/\s+/)));
-		const summaryTokens = new Set(tokenize(entry.summary));
-		let score = 0;
-		for (const name of names) {
-			if (name === q) score = Math.max(score, 3);
-			else if (name.startsWith(q) || q.startsWith(name)) score = Math.max(score, 2);
-		}
-		for (const token of contentTokens) {
-			if (nameTokens.has(token)) score += 3;
-			else if (token.length >= 5 && [...nameTokens].some((nameToken) => nameToken.length >= 5 && differsByOne(token, nameToken))) score += 3;
-			else if (token.length >= 3 && [...nameTokens].some((nameToken) => nameToken.startsWith(token))) score += 2;
-			if (summaryTokens.has(token)) score += 1;
-		}
-		return { entry, score };
-	});
-
-	const best = Math.max(0, ...scored.map((s) => s.score));
-	if (best === 0) return { action: "none" };
-	const top = scored.filter((s) => s.score === best);
-	if (top.length > 1) {
-		return { action: "hint", candidates: top.map((s) => s.entry) };
-	}
-	const winner = top[0]!.entry;
-	if (best >= 3) {
-		return { action: winner.kind === "tool" ? "activate" : "recommend", entry: winner };
-	}
-	if (best >= 2) {
-		return { action: "hint", candidates: [winner] };
-	}
-	return { action: "none" };
-}

package/dist/extensions/capability-gateway/index.test.ts

@@ -1,226 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { describe, expect, it } from "vitest";
-import type { ResolvedSkillInfo, ToolInfo } from "@selesai/code";
-import {
-	buildSkillCatalog,
-	buildToolCatalog,
-	firstSentence,
-	route,
-	toolSummary,
-	type CatalogEntry,
-} from "./catalog.ts";
-import { capabilityInstruction, describePick, invocationContract, schemaShape } from "./index.ts";
-
-const tool = (overrides: Partial<ToolInfo>): ToolInfo =>
-	({
-		name: "grep_app_search",
-		description: "Search public GitHub code through grep.app. Returns one page.",
-		parameters: {} as never,
-		sourceInfo: { path: "/ext/index.ts", source: "local", scope: "user", origin: "top-level" },
-		...overrides,
-	}) as ToolInfo;
-
-const skill = (overrides: Partial<ResolvedSkillInfo>): ResolvedSkillInfo => ({
-	name: "research",
-	description: "Investigate a question against high-trust primary sources.",
-	filePath: "/skills/research/SKILL.md",
-	scope: "user",
-	disableModelInvocation: false,
-	...overrides,
-});
-
-describe("catalog metadata", () => {
-	it("uses explicit discovery summary over the description first sentence", () => {
-		const t = tool({ discovery: { summary: "Search public GitHub code" } });
-		expect(toolSummary(t)).toBe("Search public GitHub code");
-	});
-
-	it("falls back to the first sentence of the description", () => {
-		expect(toolSummary(tool({}))).toBe("Search public GitHub code through grep.app.");
-	});
-
-	it("firstSentence handles short text without punctuation", () => {
-		expect(firstSentence("no punctuation here")).toBe("no punctuation here");
-	});
-
-	it("builds a tool catalog excluding built-ins and gateway tools", () => {
-		const tools = [
-			tool({ name: "read" }),
-			tool({ name: "capability_catalog" }),
-			tool({ name: "grep_app_search", discovery: { aliases: ["github-search"], category: "web" } }),
-		];
-		const entries = buildToolCatalog(tools, new Set(["capability_catalog"]));
-		expect(entries.map((e) => e.name)).toEqual(["grep_app_search"]);
-		expect(entries[0]!.aliases).toEqual(["github-search"]);
-		expect(entries[0]!.category).toBe("web");
-		expect(entries[0]!.kind).toBe("tool");
-	});
-
-	it("builds a skill catalog excluding disable-model-invocation skills", () => {
-		const entries = buildSkillCatalog([
-			skill({ name: "research" }),
-			skill({ name: "secret", disableModelInvocation: true }),
-		]);
-		expect(entries.map((e) => e.name)).toEqual(["research"]);
-		expect(entries[0]!.kind).toBe("skill");
-	});
-
-	it("lists a skill resolved from several sources once, keeping the first", () => {
-		const entries = buildSkillCatalog([
-			skill({ name: "to-prd", description: "Turn the conversation into a PRD.", category: "docs" }),
-			skill({ name: "research" }),
-			skill({ name: "to-prd", description: "Older copy." }),
-		]);
-		expect(entries.map((e) => e.name)).toEqual(["to-prd", "research"]);
-		expect(entries[0]!.category).toBe("docs");
-	});
-
-	it("falls back to the file frontmatter description when the resolved description is empty", () => {
-		const dir = mkdtempSync(join(tmpdir(), "gw-skill-"));
-		const filePath = join(dir, "SKILL.md");
-		writeFileSync(
-			filePath,
-			"---\nname: brandkit\ndescription: Premium brand-kit image generation skill for creating high-end brand-guidelines boards.\n---\nbody\n",
-		);
-		try {
-			const entries = buildSkillCatalog([skill({ name: "brandkit", description: "", filePath })]);
-			expect(entries[0]!.summary).toBe("Premium brand-kit image generation skill for creating high-end brand-guidelines boards.");
-		} finally {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-});
-
-describe("deterministic routing", () => {
-	const catalog: CatalogEntry[] = [
-		{ name: "grep_app_search", kind: "tool", summary: "Search public GitHub code", aliases: ["github-search"], category: "web", eligible: true },
-		{ name: "grep_app_fetch", kind: "tool", summary: "Fetch a public GitHub file", aliases: [], category: "web", eligible: true },
-		{ name: "research", kind: "skill", summary: "Investigate a question against primary sources", aliases: [], category: "research", eligible: true },
-	];
-
-	it("auto-activates a unique high-confidence tool match", () => {
-		const result = route("search github code with grep_app_search", catalog);
-		expect(result.action).toBe("activate");
-		expect(result.entry?.name).toBe("grep_app_search");
-	});
-
-	it("matches by alias", () => {
-		const result = route("use github-search", catalog);
-		expect(result.action).toBe("activate");
-		expect(result.entry?.name).toBe("grep_app_search");
-	});
-
-	it("auto-activates a uniquely identifiable one-character tool typo", () => {
-		const result = route("activate inercom", [
-			...catalog,
-			{ name: "intercom", kind: "tool", summary: "Coordinate with other local sessions", aliases: [], category: "coordination", eligible: true },
-		]);
-		expect(result.action).toBe("activate");
-		expect(result.entry?.name).toBe("intercom");
-	});
-
-	it("recommends a unique high-confidence skill without auto-loading", () => {
-		const result = route("do research on this topic", catalog);
-		expect(result.action).toBe("recommend");
-		expect(result.entry?.name).toBe("research");
-	});
-
-	it("returns a hint for ambiguous matches", () => {
-		const result = route("grep app", catalog);
-		expect(result.action).toBe("hint");
-		expect(result.candidates?.length).toBeGreaterThan(1);
-	});
-
-	it("returns none for unrelated prompts", () => {
-		expect(route("refactor the auth module", catalog).action).toBe("none");
-		expect(route("", catalog).action).toBe("none");
-		expect(route("   ", catalog).action).toBe("none");
-	});
-
-	it("is deterministic for the same input", () => {
-		const a = route("search github code", catalog);
-		const b = route("search github code", catalog);
-		expect(a).toEqual(b);
-	});
-});
-
-describe("invocation contract", () => {
-	const toolWith = (parameters: unknown, overrides: Partial<ToolInfo> = {}) =>
-		tool({ name: "graft_find_code", description: "Find code by question.", parameters: parameters as never, ...overrides });
-
-	it("lists each parameter with its shape and required flag", () => {
-		const contract = invocationContract(
-			toolWith({
-				type: "object",
-				properties: {
-					question: { type: "string", description: "What you want to understand, in plain words." },
-					limit: { type: "number" },
-				},
-				required: ["question"],
-			}),
-		);
-		expect(contract).toContain("graft_find_code — Find code by question.");
-		expect(contract).toContain("- question (string, required): What you want to understand, in plain words.");
-		expect(contract).toContain("- limit (number, optional)");
-	});
-
-	it("names nested shapes instead of expanding them", () => {
-		expect(schemaShape({ type: "array", items: { type: "object" } })).toBe("array<object>");
-		expect(schemaShape({ anyOf: [{ type: "string" }, { type: "number" }] })).toBe("one of several");
-		expect(schemaShape({ enum: ["a", "b"] })).toBe('"a" | "b"');
-		expect(schemaShape({})).toBe("value");
-	});
-
-	it("says so when a tool takes no parameters", () => {
-		expect(invocationContract(toolWith({ type: "object", properties: {} }))).toContain("Parameters: none");
-	});
-
-	it("clips long text and never carries the schema itself", () => {
-		const contract = invocationContract(
-			toolWith({
-				type: "object",
-				properties: { question: { type: "string", description: "x".repeat(500) } },
-				required: ["question"],
-			}),
-		);
-		expect(contract).toContain("…");
-		expect(contract).not.toContain('"type"');
-		expect(contract.split("\n").every((line) => line.length <= 200)).toBe(true);
-	});
-});
-
-describe("capability instruction", () => {
-	it("mentions the job route only when Jev can answer it", () => {
-		expect(capabilityInstruction(true)).toContain("capability_discover with `job`");
-		const offline = capabilityInstruction(false);
-		expect(offline).not.toContain("`job`");
-		expect(offline).toContain("capability_catalog");
-		expect(offline).toContain("exact `name`");
-	});
-});
-
-describe("describePick", () => {
-	const side = (pick: Parameters<typeof describePick>[1]["pick"], offered = 3, dropped = 0) => ({ pick, offered, dropped });
-
-	it("reads a hesitant Jev as no confident pick rather than a failure", () => {
-		expect(describePick("Skill", side({ selected: false, reason: "low-confidence" }), undefined, "x")).toBe(
-			"Skill: no confident pick.",
-		);
-		expect(describePick("Tool", side({ selected: false, reason: "unquantified" }), undefined, "x")).toBe(
-			"Tool: no confident pick.",
-		);
-	});
-
-	it("keeps real failures, picks, and an honest none distinct", () => {
-		expect(describePick("Tool", side({ selected: false, reason: "timeout" }), undefined, "x")).toBe("Tool: no decision (timeout).");
-		expect(describePick("Tool", side({ selected: true, name: "t", confidence: 0.9 }), "t", "x")).toBe(
-			'Tool: Jev picked "t" (confidence 0.90).',
-		);
-		expect(describePick("Skill", side({ selected: false, reason: "none" }, 40, 9), undefined, "no procedure")).toContain(
-			"among 40 of 49 offered",
-		);
-	});
-});