@selesai/code 0.8.4 → 0.8.6

package/dist/extensions/handoff-new.test.ts

@@ -1,10 +1,28 @@
 // Tests for /handoff-new. These import runtime values from "@selesai/code",
-// which is this package itself and only resolves against a built dist.
-// Run with the resolve hook that maps @selesai/code -> src/index.ts:
-//   node --import ./src/extensions/test-resolve-hook.mjs --test src/extensions/handoff-new.test.ts
-import test from "node:test";
-import assert from "node:assert/strict";
+// which is this package itself and only resolves against a built dist
+// (vitest.config.ts aliases @selesai/code -> dist/index.js).
+import { describe, expect, it, vi } from "vitest";
 
+vi.mock("@selesai/code", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@selesai/code")>();
+	return {
+		...actual,
+		BorderedLoader: vi.fn().mockImplementation(function (this: any, _tui: any, _theme: any, _label: string) {
+			this.signal = new AbortController().signal;
+			this.onAbort = null;
+		}),
+	};
+});
+
+vi.mock("@earendil-works/pi-ai/compat", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@earendil-works/pi-ai/compat")>();
+	return {
+		...actual,
+		complete: vi.fn(),
+	};
+});
+
+import { complete } from "@earendil-works/pi-ai/compat";
 import handoffNewExtension, {
 	DEFAULT_GOAL,
 	buildAiContext,
@@ -28,179 +46,351 @@ function createPiHarness() {
 	return { commands };
 }
 
-test("registers handoff-new only", () => {
-	const { commands } = createPiHarness();
-	assert.ok(commands.has("handoff-new"));
-	assert.equal(commands.has("handover-new"), false);
-});
+describe("handoff-new extension", () => {
+	it("registers handoff-new only", () => {
+		const { commands } = createPiHarness();
+		expect(commands.has("handoff-new")).toBe(true);
+		expect(commands.has("handover-new")).toBe(false);
+	});
 
-// ---- pure helpers ----
+	// ---- pure helpers ----
 
-function userEntry(text: string, id = "u1"): SessionEntry {
-	return {
-		id,
-		type: "message",
-		message: { role: "user", content: [{ type: "text", text }], timestamp: 100 },
-		parentId: "root",
-		timestamp: 100,
-	} as any as SessionEntry;
-}
+	function userEntry(text: string, id = "u1"): SessionEntry {
+		return {
+			id,
+			type: "message",
+			message: { role: "user", content: [{ type: "text", text }], timestamp: 100 },
+			parentId: "root",
+			timestamp: 100,
+		} as any as SessionEntry;
+	}
 
-function compactionEntry(id: string, firstKeptEntryId: string): SessionEntry {
-	return {
-		id,
-		type: "compaction",
-		summary: "compacted summary",
-		tokensBefore: 1000,
-		firstKeptEntryId,
-		timestamp: 50,
-	} as any as SessionEntry;
-}
+	function compactionEntry(id: string, firstKeptEntryId: string): SessionEntry {
+		return {
+			id,
+			type: "compaction",
+			summary: "compacted summary",
+			tokensBefore: 1000,
+			firstKeptEntryId,
+			timestamp: 50,
+		} as any as SessionEntry;
+	}
 
-test("entryToMessage: message entry -> message", () => {
-	const e = userEntry("hi");
-	assert.deepEqual(entryToMessage(e), (e as any).message);
-});
+	it("entryToMessage: message entry -> message", () => {
+		const e = userEntry("hi");
+		expect(entryToMessage(e)).toEqual((e as any).message);
+	});
 
-test("entryToMessage: compaction entry -> compactionSummary", () => {
-	const e = compactionEntry("c1", "k1");
-	const m: any = entryToMessage(e);
-	assert.equal(m.role, "compactionSummary");
-	assert.equal(m.summary, "compacted summary");
-});
+	it("entryToMessage: compaction entry -> compactionSummary", () => {
+		const e = compactionEntry("c1", "k1");
+		const m: any = entryToMessage(e);
+		expect(m.role).toBe("compactionSummary");
+		expect(m.summary).toBe("compacted summary");
+	});
 
-test("entryToMessage: other entry types -> undefined", () => {
-	assert.equal(entryToMessage({ type: "label", id: "l1" } as any as SessionEntry), undefined);
-});
+	it("entryToMessage: other entry types -> undefined", () => {
+		expect(entryToMessage({ type: "label", id: "l1" } as any as SessionEntry)).toBeUndefined();
+	});
 
-test("getHandoffMessages: no compaction returns all messages", () => {
-	const branch = [userEntry("a", "1"), userEntry("b", "2")];
-	assert.equal(getHandoffMessages(branch).length, 2);
-});
+	it("getHandoffMessages: no compaction returns all messages", () => {
+		const branch = [userEntry("a", "1"), userEntry("b", "2")];
+		expect(getHandoffMessages(branch)).toHaveLength(2);
+	});
 
-test("getHandoffMessages: compaction prepends summary + kept slice + after", () => {
-	const branch = [
-		userEntry("old-kept", "k1"),
-		compactionEntry("c1", "k1"),
-		userEntry("after", "a1"),
-	];
-	const msgs = getHandoffMessages(branch);
-	assert.equal(msgs.length, 3);
-	assert.equal((msgs[0] as any).role, "compactionSummary");
-	assert.equal((msgs[1] as any).content[0].text, "old-kept");
-	assert.equal((msgs[2] as any).content[0].text, "after");
-});
+	it("getHandoffMessages: compaction prepends summary + kept slice + after", () => {
+		const branch = [
+			userEntry("old-kept", "k1"),
+			compactionEntry("c1", "k1"),
+			userEntry("after", "a1"),
+		];
+		const msgs = getHandoffMessages(branch);
+		expect(msgs).toHaveLength(3);
+		expect((msgs[0] as any).role).toBe("compactionSummary");
+		expect((msgs[1] as any).content[0].text).toBe("old-kept");
+		expect((msgs[2] as any).content[0].text).toBe("after");
+	});
 
-test("buildAiContext: embeds conversation + goal into one user turn", () => {
-	const ctx = buildAiContext("conv-text", "my-goal");
-	assert.ok(ctx.systemPrompt.length > 0);
-	assert.equal(ctx.messages.length, 1);
-	const text = (ctx.messages[0].content[0] as any).text;
-	assert.ok(text.includes("conv-text"));
-	assert.ok(text.includes("my-goal"));
-});
+	it("getHandoffMessages: compaction with unknown firstKeptEntryId keeps only summary + after", () => {
+		const branch = [
+			userEntry("old-kept", "k1"),
+			compactionEntry("c1", "missing-id"),
+			userEntry("after", "a1"),
+		];
+		const msgs = getHandoffMessages(branch);
+		expect(msgs).toHaveLength(2);
+		expect((msgs[0] as any).role).toBe("compactionSummary");
+		expect((msgs[1] as any).content[0].text).toBe("after");
+	});
 
-// ---- handler ----
-
-function createCtx(opts: {
-	branch?: SessionEntry[];
-	model?: any;
-	customResult?: string | null;
-	mode?: string;
-} = {}) {
-	const calls: { newSession: any; userMessage: string | null; notify: { msg: string; kind: string }[] } = {
-		newSession: null,
-		userMessage: null,
-		notify: [],
-	};
-	const ctx: any = {
-		mode: opts.mode ?? "tui",
-		model: opts.model === undefined ? { provider: "test", id: "m" } : opts.model,
-		sessionManager: {
-			getBranch: () => opts.branch === undefined ? [userEntry("we decided to build X")] : opts.branch,
-			getSessionFile: () => "/tmp/old.json",
-		},
-		modelRegistry: {
-			async getApiKeyAndHeaders() {
-				return { ok: true, apiKey: "key", headers: {} };
+	it("buildAiContext: embeds conversation + goal into one user turn", () => {
+		const ctx = buildAiContext("conv-text", "my-goal");
+		expect(ctx.systemPrompt.length).toBeGreaterThan(0);
+		expect(ctx.messages).toHaveLength(1);
+		const text = (ctx.messages[0].content[0] as any).text;
+		expect(text).toContain("conv-text");
+		expect(text).toContain("my-goal");
+	});
+
+	// ---- handler ----
+
+	function createCtx(opts: {
+		branch?: SessionEntry[];
+		model?: any;
+		customResult?: string | null;
+		mode?: string;
+	} = {}) {
+		const calls: { newSession: any; userMessage: string | null; notify: { msg: string; kind: string }[] } = {
+			newSession: null,
+			userMessage: null,
+			notify: [],
+		};
+		const ctx: any = {
+			mode: opts.mode ?? "tui",
+			model: opts.model === undefined ? { provider: "test", id: "m" } : opts.model,
+			sessionManager: {
+				getBranch: () => (opts.branch === undefined ? [userEntry("we decided to build X")] : opts.branch),
+				getSessionFile: () => "/tmp/old.json",
 			},
-		},
-		ui: {
-			notify: (msg: string, kind: string) => calls.notify.push({ msg, kind }),
-			custom: async <T>(_factory: any): Promise<T> => (opts.customResult === undefined ? "HANDOFF PROMPT" : opts.customResult) as unknown as T,
-		},
-		async sendUserMessage(text: string) {
-			calls.userMessage = text;
-		},
-		async newSession(options: any) {
+			modelRegistry: {
+				async getApiKeyAndHeaders() {
+					return { ok: true, apiKey: "key", headers: {} };
+				},
+			},
+			ui: {
+				notify: (msg: string, kind: string) => calls.notify.push({ msg, kind }),
+				custom: async <T>(_factory: any): Promise<T> => (opts.customResult === undefined ? "HANDOFF PROMPT" : opts.customResult) as unknown as T,
+			},
+			async sendUserMessage(text: string) {
+				calls.userMessage = text;
+			},
+			async newSession(options: any) {
+				calls.newSession = options;
+				if (options?.withSession) {
+					await options.withSession(ctx);
+				}
+				return { cancelled: false };
+			},
+		};
+		return { ctx, calls };
+	}
+
+	it("happy path: newSession called with parentSession, handoff submitted", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx();
+		await commands.get("handoff-new")!.handler("continue the fix", ctx);
+		expect(calls.newSession.parentSession).toBe("/tmp/old.json");
+		expect(calls.userMessage).toBe("HANDOFF PROMPT");
+		expect(calls.newSession.cancelled).toBeUndefined();
+	});
+
+	it("no goal arg uses DEFAULT_GOAL", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx();
+		await commands.get("handoff-new")!.handler("   ", ctx);
+		// happy path still completes; default goal only affects the AI prompt text.
+		expect(calls.userMessage).toBe("HANDOFF PROMPT");
+	});
+
+	it("non-tui mode fails cleanly, no new session", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ mode: "rpc" });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /interactive mode/.test(n.msg))).toBe(true);
+	});
+
+	it("no model fails cleanly", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ model: null });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /No model/.test(n.msg))).toBe(true);
+	});
+
+	it("empty conversation fails cleanly", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ branch: [] });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /No conversation/.test(n.msg))).toBe(true);
+	});
+
+	it("custom null (cancelled) does not open new session", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ customResult: null });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
+
+	it("empty generated handoff does not open a blank session", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx({ customResult: "  " });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /returned no text/.test(n.msg))).toBe(true);
+	});
+
+	it("new session cancelled notifies", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createCtx();
+		ctx.newSession = async (options: any) => {
 			calls.newSession = options;
-			if (options?.withSession) {
-				await options.withSession(ctx);
-			}
-			return { cancelled: false };
-		},
-	};
-	return { ctx, calls };
-}
+			if (options?.withSession) await options.withSession(ctx);
+			return { cancelled: true };
+		};
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.notify.some((n) => /New session cancelled/.test(n.msg))).toBe(true);
+	});
 
-test("happy path: newSession called with parentSession, handoff submitted", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx();
-	await commands.get("handoff-new")!.handler("continue the fix", ctx);
-	assert.equal(calls.newSession.parentSession, "/tmp/old.json");
-	assert.equal(calls.userMessage, "HANDOFF PROMPT");
-	assert.equal(calls.newSession.cancelled, undefined);
-});
+	// ---- custom factory (BorderedLoader + complete) ----
 
-test("no goal arg uses DEFAULT_GOAL", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx();
-	await commands.get("handoff-new")!.handler("   ", ctx);
-	// happy path still completes; default goal only affects the AI prompt text.
-	assert.equal(calls.userMessage, "HANDOFF PROMPT");
-});
+	function createFactoryCtx(opts: {
+		auth?: { ok: boolean; apiKey?: string; error?: string };
+		completeResult?: any;
+		completeError?: Error;
+	}) {
+		const calls: { newSession: any; userMessage: string | null; notify: { msg: string; kind: string }[] } = {
+			newSession: null,
+			userMessage: null,
+			notify: [],
+		};
+		let capturedFactory: ((tui: any, theme: any, kb: any, done: (v: unknown) => void) => unknown) | null = null;
+		const ctx: any = {
+			mode: "tui",
+			model: { provider: "test", id: "m" },
+			sessionManager: {
+				getBranch: () => [userEntry("we decided to build X")],
+				getSessionFile: () => "/tmp/old.json",
+			},
+			modelRegistry: {
+				async getApiKeyAndHeaders() {
+					return opts.auth ?? { ok: true, apiKey: "key", headers: {} };
+				},
+			},
+			ui: {
+				notify: (msg: string, kind: string) => calls.notify.push({ msg, kind }),
+				custom: async <T>(factory: any): Promise<T> => {
+					capturedFactory = factory;
+					return new Promise<T>((resolve) => {
+						const loader = factory({}, {}, {}, resolve);
+						if (opts.completeError) {
+							// The factory's async IIFE catches errors and calls done(null).
+							// complete is mocked to reject; the catch handler runs synchronously
+							// after the microtask queue drains.
+						}
+					});
+				},
+			},
+			async sendUserMessage(text: string) {
+				calls.userMessage = text;
+			},
+			async newSession(options: any) {
+				calls.newSession = options;
+				if (options?.withSession) {
+					await options.withSession(ctx);
+				}
+				return { cancelled: false };
+			},
+		};
+		return { ctx, calls, getFactory: () => capturedFactory };
+	}
 
-test("non-tui mode fails cleanly, no new session", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ mode: "rpc" });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /interactive mode/.test(n.msg)));
-});
+	it("factory: complete returns text content and submits the handoff", async () => {
+		(complete as any).mockResolvedValueOnce({
+			stopReason: "done",
+			content: [
+				{ type: "text", text: "Handoff part one" },
+				{ type: "image", mimeType: "image/png" },
+				{ type: "text", text: "Handoff part two" },
+			],
+		});
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({});
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.userMessage).toBe("Handoff part one\nHandoff part two");
+		expect(calls.newSession).not.toBeNull();
+	});
 
-test("no model fails cleanly", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ model: null });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /No model/.test(n.msg)));
-});
+	it("factory: aborted stop reason returns null and notifies Cancelled", async () => {
+		(complete as any).mockResolvedValueOnce({ stopReason: "aborted", content: [] });
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({});
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
 
-test("empty conversation fails cleanly", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ branch: [] });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /No conversation/.test(n.msg)));
-});
+	it("factory: missing API key throws and notifies Cancelled", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({ auth: { ok: true, error: "no key" } });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
 
-test("custom null (cancelled) does not open new session", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ customResult: null });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /Cancelled/.test(n.msg)));
-});
+	it("factory: auth error throws and notifies Cancelled", async () => {
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({ auth: { ok: false, error: "auth failed" } });
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
 
-test("empty generated handoff does not open a blank session", async () => {
-	const { commands } = createPiHarness();
-	const { ctx, calls } = createCtx({ customResult: "  " });
-	await commands.get("handoff-new")!.handler("goal", ctx);
-	assert.equal(calls.newSession, null);
-	assert.ok(calls.notify.some((n) => /returned no text/.test(n.msg)));
-});
+	it("factory: complete rejection is caught and notifies Cancelled", async () => {
+		(complete as any).mockRejectedValueOnce(new Error("network down"));
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({});
+		await commands.get("handoff-new")!.handler("goal", ctx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
 
-// sanity: DEFAULT_GOAL exported and non-empty (used by handler)
-test("DEFAULT_GOAL is non-empty", () => {
-	assert.ok(DEFAULT_GOAL.length > 0);
-});
+	it("factory: loader onAbort resolves null", async () => {
+		(complete as any).mockResolvedValueOnce({ stopReason: "done", content: [{ type: "text", text: "x" }] });
+		const { commands } = createPiHarness();
+		const { ctx, calls } = createFactoryCtx({});
+		// Drive the factory manually: capture it, call onAbort, then let the
+		// async IIFE finish.
+		let factory: any = null;
+		const customCtx: any = {
+			mode: "tui",
+			model: { provider: "test", id: "m" },
+			sessionManager: {
+				getBranch: () => [userEntry("we decided to build X")],
+				getSessionFile: () => "/tmp/old.json",
+			},
+			modelRegistry: {
+				async getApiKeyAndHeaders() {
+					return { ok: true, apiKey: "key", headers: {} };
+				},
+			},
+			ui: {
+				notify: (msg: string, kind: string) => calls.notify.push({ msg, kind }),
+				custom: async <T>(f: any): Promise<T> => {
+					factory = f;
+					return new Promise<T>((resolve) => {
+						const loader = f({}, {}, {}, resolve);
+						loader.onAbort();
+					});
+				},
+			},
+			async sendUserMessage(text: string) {
+				calls.userMessage = text;
+			},
+			async newSession(options: any) {
+				calls.newSession = options;
+				if (options?.withSession) await options.withSession(customCtx);
+				return { cancelled: false };
+			},
+		};
+		await commands.get("handoff-new")!.handler("goal", customCtx);
+		expect(calls.newSession).toBeNull();
+		expect(calls.notify.some((n) => /Cancelled/.test(n.msg))).toBe(true);
+	});
+
+	// sanity: DEFAULT_GOAL exported and non-empty (used by handler)
+	it("DEFAULT_GOAL is non-empty", () => {
+		expect(DEFAULT_GOAL.length).toBeGreaterThan(0);
+	});
+});

package/dist/extensions/handoff-new.ts

@@ -56,6 +56,9 @@ export function getHandoffMessages(branch: SessionEntry[]): AgentMessage[] {
 	}
 
 	const compaction = branch[compactionIndex];
+	// compactionIndex is only set when branch[i].type === "compaction", so the
+	// else branch is unreachable.
+	/* v8 ignore next 1 */
 	const firstKeptIndex =
 		compaction.type === "compaction" ? branch.findIndex((entry) => entry.id === compaction.firstKeptEntryId) : -1;
 	const compactedBranch = [

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

@@ -108,4 +108,97 @@ describe("inline-skills", () => {
 		expect(result).toMatchObject({ action: "transform", text: expect.stringMatching(/<skill[\s\S]*Use \$research now$/) });
 		expect(handlers.get("input")!({ text: "$research", source: "extension" })).toEqual({ action: "continue" });
 	});
+
+	it("delegates applyCompletion and shouldTriggerFileCompletion to the base provider", async () => {
+		const pi = createPi([skill("research", "/skills/research/SKILL.md")]);
+		const base = {
+			getSuggestions: vi.fn(async () => null),
+			applyCompletion: vi.fn(() => "applied"),
+			shouldTriggerFileCompletion: vi.fn(() => false),
+		} as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		expect(provider.applyCompletion(["a"], 0, 1, {} as any, "$")).toBe("applied");
+		expect(base.applyCompletion).toHaveBeenCalledWith(["a"], 0, 1, {}, "$");
+		expect(provider.shouldTriggerFileCompletion(["a"], 0, 1)).toBe(false);
+		expect(base.shouldTriggerFileCompletion).toHaveBeenCalledWith(["a"], 0, 1);
+	});
+
+	it("shouldTriggerFileCompletion defaults to true when the base provider lacks it", () => {
+		const pi = createPi([skill("research", "/skills/research/SKILL.md")]);
+		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		expect(provider.shouldTriggerFileCompletion(["a"], 0, 1)).toBe(true);
+	});
+
+	it("falls back to the base provider when no $ token is present", async () => {
+		const pi = createPi([skill("research", "/skills/research/SKILL.md")]);
+		const base = { getSuggestions: vi.fn(async () => "base-result"), applyCompletion: vi.fn() } as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		expect(await provider.getSuggestions(["plain text"], 0, 5, {} as any)).toBe("base-result");
+		expect(base.getSuggestions).toHaveBeenCalledWith(["plain text"], 0, 5, {});
+	});
+
+	it("handles a missing line and a bare $ token", async () => {
+		const pi = createPi([skill("research", "/skills/research/SKILL.md")]);
+		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		// cursorLine beyond the array → lines[cursorLine] is undefined → "" slice.
+		expect(await provider.getSuggestions([], 3, 0, {} as any)).toBeNull();
+		// Bare "$" at end of line → empty token → all skills match (includes("")).
+		const bare = await provider.getSuggestions(["draft $"], 0, 7, {} as any);
+		expect(bare).toEqual({
+			prefix: "$",
+			items: [{ value: "$research", label: "$research", description: "research description" }],
+		});
+	});
+
+	it("falls back to the base provider when no skills match the token", async () => {
+		const pi = createPi([skill("research", "/skills/research/SKILL.md")]);
+		const base = { getSuggestions: vi.fn(async () => "base-result"), applyCompletion: vi.fn() } as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		expect(await provider.getSuggestions(["$zzz"], 0, 4, {} as any)).toBe("base-result");
+	});
+
+	it("skips skills whose files fail to read", () => {
+		const pi = createPi([skill("missing", "/nonexistent/SKILL.md")]);
+		const text = expandInlineSkills("Use $missing now", pi);
+		expect(text).toBe("Use $missing now");
+	});
+
+	it("session_start provider callback wraps the current provider", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "inline-skills-"));
+		tempDirs.push(dir);
+		const file = join(dir, "research.md");
+		writeFileSync(file, "---\ndescription: Research\n---\nResearch instructions.\n");
+		const handlers = new Map<string, Function>();
+		const pi = {
+			getCommands: vi.fn(() => [skill("research", file)]),
+			on: vi.fn((event: string, handler: Function) => handlers.set(event, handler)),
+		} as unknown as ExtensionAPI;
+		let captured: any = null;
+		inlineSkillsExtension(pi);
+		handlers.get("session_start")!({}, { ui: { addAutocompleteProvider: (cb: any) => (captured = cb) } } as unknown as ExtensionContext);
+
+		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
+		const provider = captured(base);
+		expect(await provider.getSuggestions(["$res"], 0, 4, {} as any)).toEqual({
+			prefix: "$res",
+			items: [{ value: "$research", label: "$research", description: "research description" }],
+		});
+	});
+
+	it("input without skill tokens passes through unchanged", () => {
+		const handlers = new Map<string, Function>();
+		const pi = {
+			getCommands: vi.fn(() => []),
+			on: vi.fn((event: string, handler: Function) => handlers.set(event, handler)),
+		} as unknown as ExtensionAPI;
+		inlineSkillsExtension(pi);
+		expect(handlers.get("input")!({ text: "plain text", source: "interactive" })).toEqual({ action: "continue" });
+	});
 });