@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/wrapped-editor-usage.integration.test.ts

@@ -0,0 +1,298 @@
+import { SessionManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const runtime = vi.hoisted(() => ({
+	hooks: undefined as undefined | Record<string, (...args: never[]) => unknown>,
+	editorEnabled: true,
+	config: undefined as import("../extensions/zentui/config").ZentuiConfig | undefined,
+}));
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		ensureConfigExists: () => {},
+		loadConfig: vi.fn(() => {
+			const config = structuredClone(actual.defaultConfig);
+			config.projectRefreshIntervalMs = 0;
+			config.components.editor.enabled = runtime.editorEnabled;
+			config.components.editor.style = "minimalist";
+			config.components.editor.styles.minimalist.showCost = true;
+			config.components.editor.styles.minimalist.showGit = false;
+			config.components.footer.style = "hidden";
+			config.components.userMessages.enabled = false;
+			config.components.selectorBorders.enabled = false;
+			config.components.workingLine.enabled = false;
+			runtime.config = config;
+			return config;
+		}),
+		saveEditorComponentPatch: vi.fn((patch: object) => {
+			Object.assign(runtime.config?.components.editor ?? {}, patch);
+			return runtime.config;
+		}),
+	};
+});
+vi.mock("../extensions/zentui/settings-command", () => ({
+	registerZentuiSettingsCommand(_pi: unknown, hooks: typeof runtime.hooks) {
+		runtime.hooks = hooks;
+	},
+}));
+vi.mock("../extensions/zentui/telemetry", () => ({
+	resolveFooterTelemetry: () => ({}),
+	FooterTelemetryController: class {
+		resolve() {
+			return {};
+		}
+		reset() {}
+	},
+}));
+vi.mock("../extensions/zentui/git", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/git")>();
+	return {
+		...actual,
+		readGitStatus: async () => ({ kind: "ok", status: actual.emptyGitStatus() }),
+	};
+});
+vi.mock("../extensions/zentui/runtime", () => ({
+	readRuntimeInfo: async () => ({ kind: "ok", runtime: undefined }),
+}));
+vi.mock("../extensions/zentui/package-version", () => ({
+	readPackageVersionResult: async () => ({ kind: "ok", result: null }),
+}));
+
+import zentui from "../extensions/zentui/index";
+
+type Editor = { render(width: number): string[]; setText(text: string): void };
+type Factory = (...args: never[]) => Editor;
+type Handler = (event: unknown, ctx: unknown) => unknown;
+
+function message(cost: number) {
+	return {
+		role: "assistant",
+		usage: { input: 10, output: 2, cacheRead: 0, cacheWrite: 0, cost: { total: cost } },
+		content: [],
+		stopReason: "stop",
+		timestamp: 1,
+	};
+}
+
+function harness() {
+	const manager = SessionManager.inMemory("/wrapped-editor-usage");
+	manager.appendMessage(message(1) as never);
+	const requestRender = vi.fn();
+	let factory: Factory | undefined;
+	let editor: Editor | undefined;
+	const theme = {
+		fg: (_: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+		getThinkingBorderColor: () => (text: string) => text,
+	} as unknown as Theme;
+	const setEditorComponent = vi.fn((value?: Factory) => {
+		factory = value;
+		// Pi publishes the factory before constructing the editor from it.
+		editor = value?.(
+			{ requestRender, terminal: { rows: 40, columns: 140 } } as never,
+			{
+				borderColor: (text: string) => text,
+				selectList: {
+					selectedPrefix: (text: string) => text,
+					selectedText: (text: string) => text,
+					description: (text: string) => text,
+					scrollInfo: (text: string) => text,
+					noMatch: (text: string) => text,
+				},
+			} as never,
+			{} as never,
+		);
+	});
+	const ctx = {
+		hasUI: true,
+		mode: "tui",
+		cwd: "/wrapped-editor-usage",
+		model: { id: "wrapped-model", provider: "test", contextWindow: 10_000 },
+		getContextUsage: () => undefined,
+		sessionManager: manager,
+		isIdle: () => true,
+		ui: {
+			theme,
+			setFooter: vi.fn(),
+			setEditorComponent,
+			getEditorComponent: () => factory,
+			getEditorText: () => "",
+			getExpandedEditorText: () => "",
+			setEditorText: vi.fn(),
+			setStatus: vi.fn(),
+		},
+	};
+	const handlers = new Map<string, Handler[]>();
+	zentui({
+		on(name: string, handler: Handler) {
+			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+		},
+		getThinkingLevel: () => "off",
+		registerCommand() {},
+		registerEntryRenderer() {},
+	} as never);
+	return {
+		ctx,
+		manager,
+		requestRender,
+		setEditorComponent,
+		/** Public Pi pattern: wrap whatever is installed without owning or replacing it. */
+		installForeignWrapper() {
+			const predecessor = ctx.ui.getEditorComponent();
+			if (!predecessor) throw new Error("no predecessor editor");
+			const wrapper: Factory = (tui, editorTheme, keybindings) =>
+				(predecessor as Factory)(tui, editorTheme, keybindings);
+			ctx.ui.setEditorComponent(wrapper);
+			return wrapper;
+		},
+		disableEditor() {
+			const hook = runtime.hooks?.setEditorComponent as
+				| ((patch: object, ctx: unknown) => void)
+				| undefined;
+			if (!hook) throw new Error("settings hooks were not registered");
+			runtime.editorEnabled = false;
+			hook({ enabled: false }, ctx);
+		},
+		enableEditor() {
+			const hook = runtime.hooks?.setEditorComponent as
+				| ((patch: object, ctx: unknown) => void)
+				| undefined;
+			if (!hook) throw new Error("settings hooks were not registered");
+			runtime.editorEnabled = true;
+			hook({ enabled: true }, ctx);
+		},
+		render: () => editor?.render(140).join("\n") ?? "",
+		async emit(name: string, event: unknown = {}) {
+			for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+		},
+	};
+}
+
+beforeEach(() => {
+	runtime.hooks = undefined;
+	runtime.editorEnabled = true;
+});
+afterEach(() => vi.restoreAllMocks());
+
+describe("minimalist editor wrapped by a predecessor-preserving foreign wrapper (#163)", () => {
+	it("keeps cost across refresh, updates after agent_end/agent_settled, and repaints", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		const wrapper = h.installForeignWrapper();
+		try {
+			expect(h.render()).toContain("$1.000");
+
+			// Refresh observes a foreign outer factory and clears installation ownership.
+			await h.emit("model_select");
+			expect(h.ctx.ui.getEditorComponent()).toBe(wrapper);
+			expect(h.render()).toContain("$1.000");
+			expect(h.render()).not.toContain("$0.000");
+
+			h.manager.appendMessage(message(0.21) as never);
+			h.requestRender.mockClear();
+			await h.emit("agent_end", { messages: [] });
+			expect(h.requestRender).toHaveBeenCalled();
+			await h.emit("agent_settled");
+			expect(h.render()).toContain("$1.210");
+			expect(h.render()).not.toContain("$0.000");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+
+	it("shows the replacement session's cost after a session switch", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		h.installForeignWrapper();
+		try {
+			await h.emit("model_select");
+			expect(h.render()).toContain("$1.000");
+
+			await h.emit("session_shutdown");
+			h.manager.newSession();
+			h.manager.appendMessage(message(7) as never);
+			await h.emit("session_start");
+			await h.emit("model_select");
+			expect(h.render()).toContain("$7.000");
+			expect(h.render()).not.toContain("$1.000");
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+
+	it("drops layered usage demand when the editor is disabled and restores it on re-enable", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		h.installForeignWrapper();
+		try {
+			await h.emit("model_select");
+			const entries = vi.spyOn(h.manager, "getEntries");
+			await h.emit("agent_end", { messages: [] });
+			expect(entries).toHaveBeenCalled();
+
+			entries.mockClear();
+			h.disableEditor();
+			await h.emit("agent_end", { messages: [] });
+			expect(entries).not.toHaveBeenCalled();
+
+			entries.mockClear();
+			h.enableEditor();
+			await h.emit("agent_end", { messages: [] });
+			expect(entries).toHaveBeenCalled();
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+
+	it("issues no layered repaint after the editor is disabled and resumes after re-enable", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		const wrapper = h.installForeignWrapper();
+		try {
+			// Baseline: the layered editor is live and repaints through the foreign wrapper.
+			h.requestRender.mockClear();
+			await h.emit("model_select");
+			expect(h.ctx.ui.getEditorComponent()).toBe(wrapper);
+			expect(h.requestRender).toHaveBeenCalled();
+
+			// Disabling clears layered ownership; no later event may reach the stale callback.
+			h.disableEditor();
+			expect(h.ctx.ui.getEditorComponent()).toBe(wrapper);
+			h.requestRender.mockClear();
+			await h.emit("model_select");
+			expect(h.requestRender).not.toHaveBeenCalled();
+
+			// Re-enabling reinstalls a repaint path even though the wrapper chain changed.
+			h.enableEditor();
+			h.requestRender.mockClear();
+			await h.emit("model_select");
+			expect(h.requestRender).toHaveBeenCalled();
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+
+	it("never removes or replaces the foreign wrapper during disable or shutdown cleanup", async () => {
+		const h = harness();
+		await h.emit("session_start");
+		const wrapper = h.installForeignWrapper();
+		try {
+			await h.emit("model_select");
+			h.setEditorComponent.mockClear();
+
+			h.disableEditor();
+			expect(h.ctx.ui.getEditorComponent()).toBe(wrapper);
+			expect(h.setEditorComponent).not.toHaveBeenCalled();
+
+			await h.emit("session_shutdown");
+			expect(h.ctx.ui.getEditorComponent()).toBe(wrapper);
+			expect(h.setEditorComponent).not.toHaveBeenCalled();
+		} finally {
+			await h.emit("session_shutdown");
+		}
+	});
+});

package/dist/extensions/pi-zentui/tsconfig.json

@@ -12,5 +12,5 @@
 		"allowImportingTsExtensions": true,
 		"types": ["node"]
 	},
-	"include": ["extensions/**/*.ts", "test/**/*.ts"]
+	"include": ["omp.ts", "extensions/**/*.ts", "test/**/*.ts"]
 }

package/dist/extensions/pi-zentui/vitest.host.config.ts

@@ -0,0 +1,33 @@
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vitest/config";
+
+const host = fileURLToPath(new URL("../../../", import.meta.url));
+
+// Vendored compatibility gate: use the real Selesai host, never a mixture of
+// upstream development dependencies and the fork's coding-agent classes.
+export default defineConfig({
+	test: {
+		environment: "node",
+		testTimeout: 30000,
+		env: { PI_OFFLINE: "1" },
+		exclude: ["**/node_modules/**"],
+	},
+	resolve: {
+		alias: [
+			{ find: "@earendil-works/pi-coding-agent", replacement: `${host}dist/index.js` },
+			{ find: "@selesai/code", replacement: `${host}dist/index.js` },
+			{
+				find: /^@earendil-works\/pi-ai\/(.+)$/,
+				replacement: `${host}node_modules/@earendil-works/pi-ai/dist/$1.js`,
+			},
+			{
+				find: "@earendil-works/pi-ai",
+				replacement: `${host}node_modules/@earendil-works/pi-ai/dist/index.js`,
+			},
+			{
+				find: "@earendil-works/pi-tui",
+				replacement: `${host}node_modules/@earendil-works/pi-tui/dist/index.js`,
+			},
+		],
+	},
+});

package/dist/extensions/question/index.ts

@@ -616,11 +616,7 @@ export default function questionExtension(pi: ExtensionAPI) {
 		description:
 			"Ask one or more typed questions in a terminal wizard. Supports select, multiselect, text, stable option values, Other answers, and partial atomic submission.",
 		promptSnippet: "Ask the user one or more typed questions when a decision is required.",
-		discovery: {
-			summary: "Ask the user one or more typed questions in a terminal wizard",
-			aliases: ["ask user", "user decision", "clarifying questions"],
-			category: "interaction",
-		},
+		exposure: "model-only",
 		promptGuidelines: [
 			"Use question only for decisions the user must make; inspect facts yourself.",
 			"Send one questions array containing independent decisions that can be answered together.",

package/dist/extensions/rtk.test.ts

@@ -65,15 +65,28 @@ function makePi() {
 	return { pi: pi as any, handlers };
 }
 
-// Registration is deferred off startup (the managed-binary probe may spawn a process),
-// so hook installation can outlast vi.waitFor's 1s default on a loaded machine.
+// Provisioning is deferred off startup; wait for verified rewrite readiness,
+// not synchronous hook registration, before testing enabled behaviour.
 function waitFor<T>(assertion: () => T | Promise<T>): Promise<T> {
 	return vi.waitFor(assertion, { timeout: 5_000 });
 }
 
 async function getToolCall(handlers: Map<string, Function[]>): Promise<Function> {
-	await waitFor(() => expect(handlers.has("tool_call")).toBe(true));
-	return handlers.get("tool_call")![0]!;
+	expect(handlers.has("tool_call")).toBe(true);
+	const handler = handlers.get("tool_call")![0]!;
+	await waitFor(async () => {
+		const event = { type: "tool_call", toolName: "bash", toolCallId: "ready", input: { command: "git status" } };
+		await handler(event, { signal: undefined });
+		expect(event.input.command).toBe("rtk git status");
+	});
+	return handler;
+}
+
+async function expectPassthrough(handlers: Map<string, Function[]>): Promise<void> {
+	expect(handlers.has("tool_call")).toBe(true);
+	const event = { type: "tool_call", toolName: "bash", toolCallId: "disabled", input: { command: "git status" } };
+	await handlers.get("tool_call")![0]!(event, { signal: undefined });
+	expect(event.input.command).toBe("git status");
 }
 
 let fakeDir: string;
@@ -131,7 +144,7 @@ posixOnly("rtk extension", () => {
 		}
 	});
 
-	it("does not register a hook for a wrong rtk binary (gain fails)", async () => {
+	it("leaves the hook in passthrough mode for a wrong rtk binary (gain fails)", async () => {
 		const wrongDir = fakeRtkDir("0.40.0", 1);
 		const previousPath = process.env.PATH;
 		process.env.PATH = `${join(wrongDir, "bin")}${previousPath ? ":" + previousPath : ""}`;
@@ -140,7 +153,7 @@ posixOnly("rtk extension", () => {
 			const { pi, handlers } = makePi();
 			rtkExtension(pi);
 			await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("rtk gain failed")));
-			expect(handlers.has("tool_call")).toBe(false);
+			await expectPassthrough(handlers);
 		} finally {
 			if (previousPath) process.env.PATH = previousPath;
 			rmSync(wrongDir, { recursive: true, force: true });
@@ -165,7 +178,7 @@ posixOnly("rtk extension", () => {
 		pi.exec = vi.fn(async () => ({ code: 1, stdout: "", stderr: "not found", killed: false }));
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed --version")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("disables the extension when the version is unparseable", async () => {
@@ -175,7 +188,7 @@ posixOnly("rtk extension", () => {
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "garbage output", stderr: "", killed: false }));
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("could not parse version")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("disables the extension when the version output is empty", async () => {
@@ -185,7 +198,7 @@ posixOnly("rtk extension", () => {
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "   ", stderr: "", killed: false }));
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("<empty output>")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("disables the extension when the version is too old", async () => {
@@ -195,7 +208,7 @@ posixOnly("rtk extension", () => {
 		pi.exec = vi.fn(async () => ({ code: 0, stdout: "rtk 0.22.0", stderr: "", killed: false }));
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("too old")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("warns and skips when ensureTool fails", async () => {
@@ -204,7 +217,7 @@ posixOnly("rtk extension", () => {
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("managed installation failed")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("warns with the stringified error when ensureTool rejects a non-Error", async () => {
@@ -213,7 +226,7 @@ posixOnly("rtk extension", () => {
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("plain string failure")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("warns and skips when ensureTool returns nothing", async () => {
@@ -222,7 +235,7 @@ posixOnly("rtk extension", () => {
 		const { pi, handlers } = makePi();
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("unavailable")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("warns and skips when probeRtk throws", async () => {
@@ -234,7 +247,7 @@ posixOnly("rtk extension", () => {
 		});
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("verification failed")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("warns with the stringified error when probeRtk throws a non-Error", async () => {
@@ -246,7 +259,7 @@ posixOnly("rtk extension", () => {
 		});
 		rtkExtension(pi);
 		await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("string failure")));
-		expect(handlers.has("tool_call")).toBe(false);
+		await expectPassthrough(handlers);
 	});
 
 	it("ignores non-bash tool calls and empty commands", async () => {

package/dist/extensions/rtk.ts

@@ -77,7 +77,27 @@ export default function (pi: ExtensionAPI) {
   // Provisioning may download the managed binary from GitHub (with 120s timeouts)
   // and probe system binaries. Running it in the extension factory would block the
   // whole startup on a slow/unreachable network, so defer it off the critical path.
-  // Bash commands issued before the hook registers simply pass through un-rewritten.
+  // Register synchronously: async late registration can target a stale extension
+  // scope after a session replacement. Commands before provisioning finishes
+  // still pass through unchanged, without waiting on a download.
+  let readyPath: string | undefined
+  pi.on("tool_call", async (event, ctx) => {
+    try {
+      if (!readyPath || !isToolCallEventType("bash", event)) return
+
+      const cmd = event.input.command
+      if (typeof cmd !== "string" || cmd.trim() === "") return
+      if (cmd.trimStart().startsWith("rtk ")) return
+      if (process.env.RTK_DISABLED === "1") return
+
+      const rewritten = await rewriteCommand(pi, readyPath, cmd, ctx.signal)
+      if (rewritten && rewritten !== cmd) event.input.command = rewritten
+    } catch (err) {
+      // Fail open: never block execution on an unexpected error.
+      console.warn("[rtk] unexpected error in tool_call handler; passing through command", err)
+    }
+  })
+
   void (async () => {
     let rtkPath: string | undefined
     try {
@@ -98,26 +118,6 @@ export default function (pi: ExtensionAPI) {
       return
     }
 
-    pi.on("tool_call", async (event, ctx) => {
-      try {
-        if (!isToolCallEventType("bash", event)) return
-
-        const cmd = event.input.command
-        if (typeof cmd !== "string" || cmd.trim() === "") return
-
-        if (cmd.trimStart().startsWith("rtk ")) return
-        if (process.env.RTK_DISABLED === "1") return
-
-        // Delegate to RTK.
-        const rewritten = await rewriteCommand(pi, rtkPath, cmd, ctx.signal)
-        if (rewritten && rewritten !== cmd) {
-          event.input.command = rewritten
-        }
-      } catch (err) {
-        // Fail open: never block execution on an unexpected error.
-        console.warn("[rtk] unexpected error in tool_call handler; passing through command", err)
-        return
-      }
-    })
+    readyPath = rtkPath
   })()
 }

package/dist/extensions/skills-index/index.test.ts

@@ -0,0 +1,99 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, expect, it } from "vitest";
+import { fauxProvider } from "@earendil-works/pi-ai/providers/faux";
+import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, type ResolvedSkillInfo } from "@selesai/code";
+import type { Skill } from "../../core/skills.ts";
+import { compactSkillIndex, eligibleSkills, showSkill } from "./index.ts";
+
+const roots: string[] = [];
+afterEach(() => { for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true }); });
+function rootDir() {
+	const root = mkdtempSync(join(tmpdir(), "selesai-skills-index-"));
+	roots.push(root);
+	return root;
+}
+function resolved(name: string, filePath: string, description = `${name} procedure`, disableModelInvocation = false): ResolvedSkillInfo {
+	return { name, filePath, description, scope: "user", disableModelInvocation };
+}
+function promptSkill(name: string): Skill {
+	return { name, description: `${name} procedure`, filePath: `/skills/${name}/SKILL.md`, baseDir: `/skills/${name}`,
+		sourceInfo: { path: `/skills/${name}/SKILL.md`, source: "user", scope: "user", origin: "top-level" }, disableModelInvocation: false };
+}
+
+it("keeps first eligible resolution and excludes model-ineligible entries", () => {
+	const first = resolved("review", "/first");
+	expect(eligibleSkills([resolved("hidden", "/hidden", "Hidden", true), first, resolved("review", "/second")])).toEqual([first]);
+});
+it("collapses only a nonempty index with an available show tool without mutating it", () => {
+	const skills = [promptSkill("review"), promptSkill("research")];
+	expect(compactSkillIndex(skills, false)).toBe(skills);
+	expect(compactSkillIndex([], true)).toEqual([]);
+	const index = compactSkillIndex(skills, true);
+	expect(index).toHaveLength(1);
+	expect(index[0].description).toContain("skill_show");
+	expect(index[0].description).not.toContain("capability_discover");
+	expect(skills).toHaveLength(2);
+});
+it("lists and filters metadata without opening files, bounds results, and supports Unicode", async () => {
+	const skills = [resolved("review", "/absent", "Check code"), resolved("日本語", "/absent", "日本語 手順")];
+	const list = await showSkill(skills, { limit: 1 });
+	expect(list.details).toMatchObject({ loaded: false, total: 2, truncated: true });
+	expect(list.content[0].text).toContain("Narrow query");
+	expect((await showSkill(skills, { query: "日本語 手順" })).content[0].text).toContain("日本語");
+	expect((await showSkill(skills, { query: "review missing" })).content[0].text).toBe("No eligible skills match.");
+});
+it("loads full instructions and reports relative-reference directory", async () => {
+	const path = join(rootDir(), "SKILL.md");
+	const body = "---\nname: review\ndescription: Review\n---\nRead examples/example.ts.\n";
+	writeFileSync(path, body);
+	const result = await showSkill([resolved("review", path)], { name: "review" });
+	expect(result.details).toMatchObject({ loaded: true, complete: true, filePath: path });
+	expect(result.content[0].text).toContain(body);
+	expect(result.content[0].text).toContain(join(path, ".."));
+});
+it("rejects arbitrary paths, disabled names, missing files, and cancellation", async () => {
+	const hidden = resolved("hidden", "/absent", "Hidden", true);
+	await expect(showSkill([hidden], { name: "hidden" })).rejects.toThrow("model-ineligible");
+	await expect(showSkill([], { name: "../../secret" })).rejects.toThrow("Unknown");
+	await expect(showSkill([resolved("missing", "/absent")], { name: "missing" })).rejects.toThrow();
+	const controller = new AbortController(); controller.abort();
+	await expect(showSkill([], {}, controller.signal)).rejects.toThrow();
+});
+it.each(["bytes", "lines"])("marks %s truncation honestly and supplies the original path", async (mode) => {
+	const path = join(rootDir(), "SKILL.md");
+	writeFileSync(path, mode === "bytes" ? "x".repeat(60_000) : "instruction\n".repeat(2100));
+	const result = await showSkill([resolved("large", path)], { name: "large" });
+	expect(result.details).toMatchObject({ loaded: true, complete: false, filePath: path });
+	expect(result.content[0].text).toContain("Instructions are incomplete");
+	expect(result.content[0].text).not.toContain("full instructions are embedded");
+	expect(Buffer.byteLength(result.content[0].text)).toBeLessThan(53_000);
+});
+
+it.each([false, true])("real SDK preserves loadout and resolved catalog (excluded show=%s)", async (excluded) => {
+	const root = rootDir(); const cwd = join(root, "project"); const agentDir = join(root, "agent");
+	mkdirSync(cwd); mkdirSync(join(agentDir, "skills", "review"), { recursive: true });
+	writeFileSync(join(agentDir, "skills", "review", "SKILL.md"), "---\nname: review\ndescription: Review code carefully\n---\nFull review instructions.\n");
+	const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false } });
+	const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: null, allowModelNetwork: false });
+	const faux = fauxProvider({ provider: "faux-skills-index", models: [{ id: "skills", contextWindow: 200_000 }] });
+	modelRuntime.registerProvider(faux.provider.id, { name: faux.provider.name, api: faux.api, apiKey: "faux", streamSimple: faux.provider.streamSimple, models: [...faux.models] });
+	await modelRuntime.refresh({ allowNetwork: false });
+	const model = modelRuntime.getModel(faux.provider.id, "skills"); if (!model) throw new Error("Missing faux model");
+	const loader = new DefaultResourceLoader({ cwd, agentDir, settingsManager, noExtensions: true, additionalExtensionPaths: [fileURLToPath(new URL("./index.ts", import.meta.url))], noContextFiles: true, noThemes: true, noPromptTemplates: true });
+	await loader.reload();
+	expect(loader.getExtensions().errors).toEqual([]);
+	const { session } = await createAgentSession({ cwd, agentDir, model, modelRuntime, resourceLoader: loader, sessionManager: SessionManager.inMemory(), settingsManager, ...(excluded ? { tools: ["read"] } : {}) });
+	try {
+		const baseline = session.getActiveToolNames();
+		await session.bindExtensions({});
+		expect(session.getActiveToolNames()).toEqual(baseline);
+		expect(session.systemPrompt).toContain(excluded ? "Review code carefully" : "skill_show");
+		expect(session.systemPrompt).not.toContain(excluded ? "<skills-index>" : "Review code carefully");
+		expect(loader.getSkills().skills.some((skill) => skill.name === "review")).toBe(true);
+		await session.extensionRunner.emit({ type: "agent_settled" });
+		expect(session.getActiveToolNames()).toEqual(baseline);
+	} finally { session.dispose(); }
+});