@selesai/code 0.13.20 → 0.13.22

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.22] - 2026-09-12
+
+### Fixed
+- **Live TPS gate.** The live tokens-per-second status no longer reports implausible rates: a live reading now needs at least a 200 ms sample window and is dropped when the rate exceeds the plausible maximum, matching the gates the final measurement already applied.
+- **Capability gateway hint noise.** The gateway no longer injects fuzzy skill recommendations or ambiguous-match catalog hints into the model context. A uniquely matched tool is still auto-activated, and optional capabilities remain discoverable through `capability_catalog`.
+
+### Changed
+- **Capability catalog tool rows.** `capability_catalog` calls now render the search query and optional kind in the TUI instead of the bare tool name.
+
+## [0.13.21] - 2026-09-11
+
+### Fixed
+- **Capability catalog unique-match results.** `capability_catalog` now returns a uniquely routed natural-language tool or skill match instead of falling back to a literal full-query search and incorrectly reporting no matching capabilities.
+
 ## [0.13.20] - 2026-09-10
 
 ### Added

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

@@ -13,10 +13,9 @@
  * - capability_discover validates one catalogued tool and activates its native
  *   definition for the current agent run; capability_skill_show loads exactly
  *   the selected skill instructions.
- * - A deterministic router inspects each user prompt and, for a unique
- *   high-confidence tool match, activates it before the run; for a unique
- *   high-confidence skill match it adds a concise recommendation; ambiguous
- *   matches add a catalog hint; unrelated prompts are untouched.
+ * - A deterministic router activates a uniquely matched tool before the run.
+ *   Skills and ambiguous matches remain discoverable through the catalog
+ *   without injecting fuzzy hints into the model context.
  * - Temporary activations reset at agent_settled, restoring the baseline
  *   active-tool set.
  * - The system-prompt skill index is replaced by a compact capability
@@ -28,6 +27,7 @@ import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { stripFrontmatter, type ExtensionAPI, type ToolInfo } from "@selesai/code";
 import { StringEnum } from "@earendil-works/pi-ai";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
 	buildSkillCatalog,
@@ -158,16 +158,18 @@ export default function capabilityGatewayExtension(pi: ExtensionAPI): void {
 			const shown =
 				params.query && matched.candidates
 					? matched.candidates
-					: params.query
-						? filtered.filter((entry) => {
-								const q = params.query!.toLowerCase();
-								return (
-									entry.name.toLowerCase().includes(q) ||
-									entry.summary.toLowerCase().includes(q) ||
-									entry.aliases.some((alias) => alias.toLowerCase().includes(q))
-								);
-							})
-						: filtered;
+					: params.query && matched.entry
+						? [matched.entry]
+						: params.query
+							? filtered.filter((entry) => {
+									const q = params.query!.toLowerCase();
+									return (
+										entry.name.toLowerCase().includes(q) ||
+										entry.summary.toLowerCase().includes(q) ||
+										entry.aliases.some((alias) => alias.toLowerCase().includes(q))
+									);
+								})
+							: filtered;
 			const text = formatCatalog(shown);
 			emitTelemetry(pi, "catalog", { query: params.query ?? "", kind: params.kind ?? "", results: shown.length });
 			return {
@@ -175,6 +177,13 @@ export default function capabilityGatewayExtension(pi: ExtensionAPI): void {
 				details: { count: shown.length, total: filtered.length },
 			};
 		},
+		renderCall(args, theme) {
+			const query = typeof args.query === "string" && args.query.length > 0 ? args.query : "(all)";
+			let text = theme.fg("toolTitle", theme.bold("capability_catalog "));
+			text += theme.fg("accent", `"${query}"`);
+			if (args.kind) text += " " + theme.fg("muted", args.kind);
+			return new Text(text, 0, 0);
+		},
 	});
 
 	pi.registerTool({
@@ -274,27 +283,8 @@ export default function capabilityGatewayExtension(pi: ExtensionAPI): void {
 			emitTelemetry(pi, "route_activate", { tool: result.entry.name });
 			return undefined;
 		}
-		if (result.action === "recommend" && result.entry) {
-			emitTelemetry(pi, "route_recommend", { skill: result.entry.name });
-			return {
-				message: {
-					customType: "capability-gateway-hint",
-					content: `The request matches the optional skill "${result.entry.name}". Load it with capability_skill_show before applying it.`,
-					display: false,
-				},
-			};
-		}
-		if (result.action === "hint" && result.candidates) {
-			const names = result.candidates.map((c) => c.name).join(", ");
-			emitTelemetry(pi, "route_hint", { candidates: result.candidates.map((c) => c.name) });
-			return {
-				message: {
-					customType: "capability-gateway-hint",
-					content: `The request may match optional capabilities: ${names}. Search capability_catalog to confirm before selecting.`,
-					display: false,
-				},
-			};
-		}
+		// Do not inject fuzzy recommendations or catalog hints into the model
+		// context. It can discover capabilities when it actually needs one.
 		return undefined;
 	});
 

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

@@ -157,6 +157,37 @@ describe("capability gateway integration", () => {
 		expect(block).toContain("capability-gateway");
 	});
 
+	it("returns a uniquely routed natural-language catalog match", async () => {
+		const h = await createGatewaySession({ enabled: true, extensions: [GATEWAY_DIR, GREP_APP_DIR] });
+		harnesses.push(h);
+		const catalog = h.session.getToolDefinition("capability_catalog");
+		expect(catalog).toBeDefined();
+
+		const result = await catalog!.execute(
+			"call-1",
+			{ query: "search GitHub code with grep_app_search" },
+			undefined,
+			undefined,
+			{} as never,
+		);
+		expect(result.content[0]!.type).toBe("text");
+		expect(String(result.content[0]!.text)).toContain("grep_app_search");
+		expect(result.details).toMatchObject({ count: 1 });
+	});
+
+	it("renders the query and kind in the tool call line", async () => {
+		const h = await createGatewaySession({ enabled: true });
+		harnesses.push(h);
+		const catalog = h.session.getToolDefinition("capability_catalog");
+		const theme = { fg: (_name: string, text: string) => text, bold: (text: string) => text } as never;
+		const draw = (args: unknown) =>
+			(catalog!.renderCall!(args as never, theme, {} as never) as { render(width: number): string[] }).render(120).join("\n");
+
+		expect(draw({ query: "ponytail-debt", kind: "skill" })).toContain('"ponytail-debt"');
+		expect(draw({ query: "ponytail-debt", kind: "skill" })).toContain("skill");
+		expect(draw({})).toContain("(all)");
+	});
+
 	it("activates a discovered tool for the run and resets after agent_settled", async () => {
 		const h = await createGatewaySession({ enabled: true });
 		harnesses.push(h);
@@ -194,26 +225,35 @@ describe("capability gateway integration", () => {
 		expect(h.session.getActiveToolNames()).toContain("grep_app_search");
 	});
 
-	it("does not auto-load skills from fuzzy matching", async () => {
+	it("does not inject fuzzy skill recommendations", async () => {
 		const h = await createGatewaySession({
 			enabled: true,
 			withSkill: true,
 			extensions: [GATEWAY_DIR, GREP_APP_DIR],
 		});
 		harnesses.push(h);
-		const runner = h.session.extensionRunner;
-		const result = await runner.emitBeforeAgentStart(
+		const result = await h.session.extensionRunner.emitBeforeAgentStart(
 			"do research on this topic",
 			undefined,
 			h.session.systemPrompt,
 			{ cwd: process.cwd() } as never,
 		);
-		// A recommendation message is injected, but the skill body is not loaded
-		// into the prompt and the skill is not auto-activated.
-		expect(result?.messages?.[0]?.content).toContain("research");
+		expect(result).toBeUndefined();
 		expect(h.session.systemPrompt).not.toContain("Research instructions body.");
 	});
 
+	it("does not inject catalog hints for ambiguous tool matches", async () => {
+		const h = await createGatewaySession({ enabled: true, extensions: [GATEWAY_DIR, GREP_APP_DIR] });
+		harnesses.push(h);
+		const result = await h.session.extensionRunner.emitBeforeAgentStart(
+			"grep app",
+			undefined,
+			h.session.systemPrompt,
+			{ cwd: process.cwd() } as never,
+		);
+		expect(result).toBeUndefined();
+	});
+
 	it("does not recommend capability_skill_show for an inline-loaded $skill", async () => {
 		const h = await createGatewaySession({
 			enabled: true,

package/dist/extensions/capability-gateway/package.json

@@ -10,6 +10,7 @@
 	"peerDependencies": {
 		"@selesai/code": "*",
 		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	}
 }

package/dist/extensions/tps.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { calculateReliableTps, type TpsTiming } from "./tps.ts";
+import { calculateLiveTps, calculateReliableTps, type TpsTiming } from "./tps.ts";
 
 function timing(overrides: Partial<TpsTiming> = {}): TpsTiming {
 	return {
@@ -15,6 +15,14 @@ function timing(overrides: Partial<TpsTiming> = {}): TpsTiming {
 	};
 }
 
+describe("calculateLiveTps", () => {
+	it("waits for a usable sample and rejects implausible rates", () => {
+		expect(calculateLiveTps(60, 0.2)).toBeNull();
+		expect(calculateLiveTps(100, 200)).toBe(500);
+		expect(calculateLiveTps(10_001, 1_000)).toBeNull();
+	});
+});
+
 describe("calculateReliableTps", () => {
 	it("uses active stream time for sufficiently sampled output", () => {
 		expect(calculateReliableTps(100, timing())).toEqual({

package/dist/extensions/tps.ts

@@ -75,6 +75,12 @@ export function calculateReliableTps(outputTokens: number, timing: TpsTiming): R
 	return { tps, effectiveMs, isPrimary };
 }
 
+export function calculateLiveTps(tokens: number, elapsedMs: number): number | null {
+	if (tokens <= 0 || elapsedMs < MIN_GENERATION_MS) return null;
+	const tps = Math.round(tokens / (elapsedMs / 1000));
+	return tps <= MAX_PLAUSIBLE_TPS ? tps : null;
+}
+
 export default function tpsExtension(pi: ExtensionAPI): void {
 	setupTpsTracker(pi);
 }
@@ -223,11 +229,11 @@ export function setupTpsTracker(pi: ExtensionAPI): void {
 
 		streamStart ??= now;
 		estimatedStreamedTokens += Math.max(0, streamEvent.delta.length / 4);
-		const elapsed = (now - streamStart) / 1000;
 		const officialTokens = generatedTokensFromUsage(asRecord(event.message.usage));
 		const currentTokens = officialTokens > 0 ? officialTokens : estimatedStreamedTokens;
-		if (elapsed > 0 && currentTokens > 0) {
-			ctx.ui.setStatus("tps", ctx.ui.theme.fg("accent", `${Math.round(currentTokens / elapsed)} tok/s`));
+		const tps = calculateLiveTps(currentTokens, now - streamStart);
+		if (tps !== null) {
+			ctx.ui.setStatus("tps", ctx.ui.theme.fg("accent", `${tps} tok/s`));
 		}
 	});
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.20",
+  "version": "0.13.22",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {