@oh-my-pi/pi-coding-agent 16.1.18 → 16.1.19

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary } from "@oh-my-pi/pi-utils";
+import { BUNDLED_PI_REGISTRY_KEYS } from "./legacy-pi-bundled-keys";
 
 const IS_COMPILED_BINARY = isCompiledBinary();
 
@@ -344,20 +345,34 @@ export function __validateLegacyPiPackageRootOverrides(
 	);
 }
 
-const LEGACY_PI_PACKAGE_ROOT_OVERRIDES = __validateLegacyPiPackageRootOverrides({
-	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
-	[`${CANONICAL_PI_SCOPE}/pi-coding-agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
-	...(IS_COMPILED_BINARY
-		? {
-				[`${CANONICAL_PI_SCOPE}/pi-agent-core`]: bundledRegistryVirtualSpecifier(
-					`${CANONICAL_PI_SCOPE}/pi-agent-core`,
-				),
-				[`${CANONICAL_PI_SCOPE}/pi-natives`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-natives`),
-				[`${CANONICAL_PI_SCOPE}/pi-tui`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-tui`),
-				[`${CANONICAL_PI_SCOPE}/pi-utils`]: bundledRegistryVirtualSpecifier(`${CANONICAL_PI_SCOPE}/pi-utils`),
-			}
-		: {}),
-});
+/**
+ * Compute the override map keyed by every canonical specifier the host serves
+ * directly: the pi-ai / pi-coding-agent roots (compat shims that re-attach
+ * legacy helpers) plus, in compiled-binary mode, every other canonical pi-*
+ * package root AND every non-wildcard subpath registered in the bundled
+ * registry (see `legacy-pi-bundled-keys.ts`). Subpath coverage is what stops
+ * `@(scope)/pi-ai/oauth` and friends from falling through to the extension's
+ * own — possibly absent — peer install when bunfs filesystem walks fail
+ * (issue #3442 follow-up to #3423). Exported as a test seam so the
+ * compiled-binary branch is verifiable from dev tests.
+ */
+export function __buildLegacyPiPackageRootOverrides(isCompiled: boolean): Record<string, string> {
+	const candidates: Record<string, string> = {
+		[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
+		[`${CANONICAL_PI_SCOPE}/pi-coding-agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
+	};
+	if (isCompiled) {
+		for (const key of BUNDLED_PI_REGISTRY_KEYS) {
+			// Shim-bearing roots above already mapped to their compat surface;
+			// the bundled typebox shim has a dedicated TYPEBOX_SHIM_PATH route.
+			if (key in candidates || key === TYPEBOX_BUNDLED_REGISTRY_KEY) continue;
+			candidates[key] = bundledRegistryVirtualSpecifier(key);
+		}
+	}
+	return __validateLegacyPiPackageRootOverrides(candidates);
+}
+
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES = __buildLegacyPiPackageRootOverrides(IS_COMPILED_BINARY);
 
 let isLegacyPiSpecifierShimInstalled = false;
 

package/src/internal-urls/local-protocol.ts

@@ -49,6 +49,121 @@ function getContentType(filePath: string): InternalResource["contentType"] {
 	return "text/plain";
 }
 
+const LOCAL_TEXT_SNIFF_BYTES = 8 * 1024;
+const LOCAL_TEXT_RESOURCE_MAX_BYTES = 1024 * 1024;
+const BINARY_FILE_EXTENSIONS = new Set([
+	".7z",
+	".avi",
+	".bmp",
+	".bz2",
+	".db",
+	".doc",
+	".docx",
+	".gif",
+	".gz",
+	".ico",
+	".jpeg",
+	".jpg",
+	".m4v",
+	".mkv",
+	".mov",
+	".mp4",
+	".pdf",
+	".png",
+	".ppt",
+	".pptx",
+	".rar",
+	".sqlite",
+	".tgz",
+	".webm",
+	".webp",
+	".wmv",
+	".xls",
+	".xlsx",
+	".xz",
+	".zip",
+]);
+
+function formatLocalByteSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	const kib = bytes / 1024;
+	if (kib < 1024) return `${kib.toFixed(1)} KiB`;
+	const mib = kib / 1024;
+	if (mib < 1024) return `${mib.toFixed(1)} MiB`;
+	return `${(mib / 1024).toFixed(1)} GiB`;
+}
+
+function buildNonTextLocalResource(url: InternalUrl, filePath: string, size: number, reason: string): InternalResource {
+	const content = `[Cannot read binary local:// file '${url.href}' (${formatLocalByteSize(size)}): ${reason}. This resource is not text. Use a metadata/key-frame/video-specific workflow instead.]`;
+	return {
+		url: url.href,
+		content,
+		contentType: "text/plain",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: filePath,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
+function buildLargeLocalTextResource(url: InternalUrl, filePath: string, size: number): InternalResource {
+	const content = `[Cannot materialize local:// file '${url.href}' as an internal text resource (${formatLocalByteSize(size)} exceeds ${formatLocalByteSize(LOCAL_TEXT_RESOURCE_MAX_BYTES)}). Use the read tool's filesystem path handling or a line selector so content is streamed with file-size safeguards.]`;
+	return {
+		url: url.href,
+		content,
+		contentType: "text/plain",
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: filePath,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
+async function readFilePrefix(filePath: string, maxBytes: number): Promise<Uint8Array> {
+	if (maxBytes <= 0) return new Uint8Array();
+	const handle = await fs.open(filePath, "r");
+	try {
+		const buffer = Buffer.allocUnsafe(maxBytes);
+		const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+		return buffer.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+
+function isUtf8Text(bytes: Uint8Array): boolean {
+	if (bytes.indexOf(0) !== -1) return false;
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function buildFileResource(
+	url: InternalUrl,
+	resolved: Extract<ResolvedLocalTarget, { kind: "file" }>,
+): Promise<InternalResource> {
+	if (BINARY_FILE_EXTENSIONS.has(path.extname(resolved.path).toLowerCase())) {
+		return buildNonTextLocalResource(url, resolved.path, resolved.size, "extension is a known binary/container type");
+	}
+	const sniffBytes = await readFilePrefix(resolved.path, Math.min(resolved.size, LOCAL_TEXT_SNIFF_BYTES));
+	if (!isUtf8Text(sniffBytes)) {
+		return buildNonTextLocalResource(url, resolved.path, resolved.size, "content is not valid UTF-8 text");
+	}
+	if (resolved.size > LOCAL_TEXT_RESOURCE_MAX_BYTES) {
+		return buildLargeLocalTextResource(url, resolved.path, resolved.size);
+	}
+	const content = await Bun.file(resolved.path).text();
+	return {
+		url: url.href,
+		content,
+		contentType: getContentType(resolved.path),
+		size: Buffer.byteLength(content, "utf-8"),
+		sourcePath: resolved.path,
+		notes: [LOCAL_WRITE_NOTE],
+	};
+}
+
 async function listFilesRecursively(rootPath: string): Promise<string[]> {
 	const pending = [""];
 	const files: string[] = [];
@@ -336,15 +451,7 @@ export class LocalProtocolHandler implements ProtocolHandler {
 			return buildDirectoryResource(url.href, resolved.path, [LOCAL_WRITE_NOTE]);
 		}
 
-		const content = await Bun.file(resolved.path).text();
-		return {
-			url: url.href,
-			content,
-			contentType: getContentType(resolved.path),
-			size: Buffer.byteLength(content, "utf-8"),
-			sourcePath: resolved.path,
-			notes: [LOCAL_WRITE_NOTE],
-		};
+		return buildFileResource(url, resolved);
 	}
 
 	async complete(_query?: string, context?: ResolveContext): Promise<UrlCompletion[]> {

package/src/internal-urls/skill-protocol.ts

@@ -13,7 +13,7 @@ import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { getActiveSkills } from "../extensibility/skills";
 import { buildDirectoryResource } from "./filesystem-resource";
-import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
 
 function getContentType(filePath: string): InternalResource["contentType"] {
 	const ext = path.extname(filePath).toLowerCase();
@@ -42,8 +42,8 @@ export class SkillProtocolHandler implements ProtocolHandler {
 	readonly scheme = "skill";
 	readonly immutable = true;
 
-	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const skills = getActiveSkills();
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const skills = context?.skills ?? getActiveSkills();
 
 		const skillName = url.rawHost || url.hostname;
 		if (!skillName) {

package/src/internal-urls/types.ts

@@ -5,6 +5,7 @@
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 
+import type { Skill } from "../extensibility/skills";
 import type { LocalProtocolOptions } from "./local-protocol";
 
 /**
@@ -90,6 +91,8 @@ export interface ResolveContext {
 	 * [#1608](https://github.com/can1357/oh-my-pi/issues/1608).
 	 */
 	localProtocolOptions?: LocalProtocolOptions;
+	/** Calling session's loaded skills. Prefer this over process-global skill state. */
+	skills?: readonly Skill[];
 }
 
 /**

package/src/modes/components/custom-editor.test.ts

@@ -93,15 +93,17 @@ describe("CustomEditor bracketed path paste", () => {
 		expect(extractBracketedImagePastePaths(bracketedPaste("/tmp/report.csv"))).toBeUndefined();
 	});
 
-	it("routes non-image path pastes through the file-path hook", async () => {
+	it("inserts non-image path pastes as literal text instead of attaching them", () => {
 		const { editor } = makeEditor();
-		const pasted = Promise.withResolvers<string>();
-		editor.onPasteFilePath = path => pasted.resolve(path);
+		let imagePathCalls = 0;
+		editor.onPasteImagePath = () => {
+			imagePathCalls++;
+		};
 
 		editor.handleInput(bracketedPaste("/tmp/report.csv"));
 
-		expect(await pasted.promise).toBe("/tmp/report.csv");
-		expect(editor.getText()).toBe("");
+		expect(editor.getText()).toBe("/tmp/report.csv");
+		expect(imagePathCalls).toBe(0);
 	});
 });
 

package/src/modes/components/custom-editor.ts

@@ -318,8 +318,6 @@ export class CustomEditor extends Editor {
 	onPasteImage?: () => Promise<boolean>;
 	/** Called when a bracketed paste contains one or more image-file paths. */
 	onPasteImagePath?: (path: string) => void | Promise<void>;
-	/** Called when a bracketed paste contains one or more non-image file paths. */
-	onPasteFilePath?: (path: string) => void | Promise<void>;
 	/** Called when the configured raw text-paste shortcut is pressed. */
 	onPasteTextRaw?: () => void;
 	/** Called when the configured dequeue shortcut is pressed. */
@@ -505,20 +503,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		const pastedPaths = extractBracketedPastePaths(data);
-		if (pastedPaths) {
-			const canHandlePaths = pastedPaths.every(path =>
-				isImagePath(path) ? this.onPasteImagePath !== undefined : this.onPasteFilePath !== undefined,
-			);
-			if (canHandlePaths) {
-				void (async () => {
-					for (const path of pastedPaths) {
-						if (isImagePath(path)) await this.onPasteImagePath?.(path);
-						else await this.onPasteFilePath?.(path);
-					}
-				})();
-				return;
-			}
+		const pastedImagePaths = extractBracketedImagePastePaths(data);
+		if (pastedImagePaths && this.onPasteImagePath) {
+			void (async () => {
+				for (const path of pastedImagePaths) await this.onPasteImagePath?.(path);
+			})();
+			return;
 		}
 
 		const parsedKey = parseKey(data);

package/src/modes/controllers/input-controller.ts

@@ -1,6 +1,5 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { type AutocompleteProvider, matchesKey, type SlashCommand } from "@oh-my-pi/pi-tui";
 import { $env, isEnoent, logger, sanitizeText } from "@oh-my-pi/pi-utils";
@@ -20,7 +19,6 @@ import { isTinyTitleLocalModelKey } from "../../tiny/models";
 import { isLowSignalTitleInput } from "../../tiny/text";
 import { tinyTitleClient } from "../../tiny/title-client";
 import type { TinyTitleProgressEvent } from "../../tiny/title-protocol";
-import { resolveReadPath } from "../../tools/path-utils";
 import { shortenPath, TRUNCATE_LENGTHS, truncateToWidth } from "../../tools/render-utils";
 import { copyToClipboard, readImageFromClipboard, readTextFromClipboard } from "../../utils/clipboard";
 import { EnhancedPasteController } from "../../utils/enhanced-paste";
@@ -104,20 +102,6 @@ function wrapPasteInAttachmentBlock(content: string): string {
 	return `<attachment>\n${content}\n</attachment>`;
 }
 
-const FILE_URI_REGEX = /^file:\/\//i;
-
-function pastedFileAttachmentExtension(sourcePath: string): string {
-	const ext = path.extname(sourcePath);
-	const bareExt = ext.slice(1);
-	if (!bareExt || bareExt.length > 32 || !/^[a-z0-9][a-z0-9._-]*$/i.test(bareExt)) return "";
-	return ext;
-}
-
-function resolvePastedFilePath(filePath: string, cwd: string): string {
-	if (FILE_URI_REGEX.test(filePath)) return fileURLToPath(filePath);
-	return resolveReadPath(filePath, cwd);
-}
-
 const TINY_TITLE_PROGRESS_DONE_TTL_MS = 3_000;
 // A cached model fires its file-load events in a short burst and then goes silent
 // while onnxruntime builds the session; a genuine download keeps streaming progress
@@ -392,7 +376,6 @@ export class InputController {
 		);
 		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
 		this.ctx.editor.onPasteImagePath = path => this.handleImagePathPaste(path);
-		this.ctx.editor.onPasteFilePath = path => this.handleFilePathPaste(path);
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteTextRaw",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteTextRaw"),
@@ -1261,37 +1244,6 @@ export class InputController {
 		}
 	}
 
-	async handleFilePathPaste(filePath: string): Promise<void> {
-		try {
-			const resolvedPath = resolvePastedFilePath(filePath, this.ctx.sessionManager.getCwd());
-			const stat = await Bun.file(resolvedPath).stat();
-			if (!stat.isFile()) {
-				this.ctx.editor.pasteText(filePath);
-				this.ctx.ui.requestRender();
-				this.ctx.showStatus("Pasted path is not a file");
-				return;
-			}
-
-			const reference = await this.#attachExistingFileAsLocal(resolvedPath);
-			this.ctx.editor.insertText(`${reference} `);
-			this.ctx.ui.requestRender();
-			this.ctx.showStatus(`Attached file as ${reference}`);
-		} catch (error) {
-			if (isEnoent(error)) {
-				this.ctx.editor.pasteText(filePath);
-				this.ctx.ui.requestRender();
-				this.ctx.showStatus("Pasted file path was not found");
-				return;
-			}
-			logger.warn("failed to attach pasted file path", {
-				error: error instanceof Error ? error.message : String(error),
-			});
-			this.ctx.editor.pasteText(filePath);
-			this.ctx.ui.requestRender();
-			this.ctx.showError("Failed to attach pasted file path — pasted path inline instead");
-		}
-	}
-
 	async handleImagePathPaste(path: string): Promise<void> {
 		try {
 			const image = await loadImageInput({
@@ -1462,29 +1414,6 @@ export class InputController {
 		this.ctx.ui.requestRender();
 	}
 
-	async #attachExistingFileAsLocal(sourcePath: string): Promise<string> {
-		const localRoot = resolveLocalRoot({
-			getArtifactsDir: () => this.ctx.sessionManager.getArtifactsDir(),
-			getSessionId: () => this.ctx.sessionManager.getSessionId(),
-		});
-		await fs.mkdir(localRoot, { recursive: true });
-		const ext = pastedFileAttachmentExtension(sourcePath);
-		let name: string;
-		let filePath: string;
-		do {
-			this.#attachmentCounter++;
-			name = `attachment-${this.#attachmentCounter}${ext}`;
-			filePath = path.join(localRoot, name);
-		} while (await Bun.file(filePath).exists());
-
-		try {
-			await fs.link(sourcePath, filePath);
-		} catch {
-			await fs.copyFile(sourcePath, filePath);
-		}
-		return `local://${name}`;
-	}
-
 	/**
 	 * Save a large paste to the session's `local://` store and insert a clean `local://attachment-N`
 	 * reference into the editor so the agent can `read` it on demand — instead of inlining the text or

package/src/session/messages.ts

@@ -482,65 +482,88 @@ export function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: Assis
  * - Custom extensions and tools
  */
 export function convertToLlm(messages: AgentMessage[]): Message[] {
-	return messages
-		.map((m): Message | undefined => {
-			switch (m.role) {
-				case "bashExecution":
-					if (m.excludeFromContext) {
-						return undefined;
-					}
-					return {
+	return messages.flatMap((m): Message[] => {
+		switch (m.role) {
+			case "bashExecution":
+				if (m.excludeFromContext) {
+					return [];
+				}
+				return [
+					{
 						role: "user",
 						content: [{ type: "text", text: bashExecutionToText(m) }],
 						attribution: "user",
 						timestamp: m.timestamp,
-					};
-				case "pythonExecution":
-					if (m.excludeFromContext) {
-						return undefined;
-					}
-					return {
+					},
+				];
+			case "pythonExecution":
+				if (m.excludeFromContext) {
+					return [];
+				}
+				return [
+					{
 						role: "user",
 						content: [{ type: "text", text: pythonExecutionToText(m) }],
 						attribution: "user",
 						timestamp: m.timestamp,
-					};
-				case "fileMention": {
-					const fileContents = m.files
-						.map(file => {
-							const inner = file.content ? `\n${file.content}\n` : "\n";
-							return `<file path="${file.path}">${inner}</file>`;
-						})
-						.join("\n");
-					const content: (TextContent | ImageContent)[] = [{ type: "text" as const, text: fileContents }];
-					for (const file of m.files) {
-						if (file.image) {
-							content.push(file.image);
-						}
-					}
-					return {
+					},
+				];
+			case "fileMention": {
+				// One `fileMention` can mix `@notes.md` (text) and `@screenshot.png` (image)
+				// in the same turn (`generateFileMentionMessages` packs every `@…` into a
+				// single message). Splitting by image presence keeps text-only mentions on
+				// the higher-priority `developer` slot while routing image attachments
+				// through `user`, the only Responses content slot that legitimately accepts
+				// `input_image` (Codex chatgpt.com /codex/responses rejects everything else
+				// with `Invalid value: 'input_image'`, #3443).
+				const wrap = (file: FileMentionMessage["files"][number]): string => {
+					const inner = file.content ? `\n${file.content}\n` : "\n";
+					return `<file path="${file.path}">${inner}</file>`;
+				};
+				const textFiles = m.files.filter(file => !file.image);
+				const imageFiles = m.files.filter(file => file.image);
+				const out: Message[] = [];
+				if (textFiles.length > 0) {
+					out.push({
 						role: "developer",
+						content: [{ type: "text" as const, text: textFiles.map(wrap).join("\n") }],
+						attribution: "user",
+						timestamp: m.timestamp,
+					});
+				}
+				if (imageFiles.length > 0) {
+					const content: (TextContent | ImageContent)[] = [
+						{ type: "text" as const, text: imageFiles.map(wrap).join("\n") },
+					];
+					for (const file of imageFiles) {
+						if (file.image) content.push(file.image);
+					}
+					out.push({
+						role: "user",
 						content,
 						attribution: "user",
 						timestamp: m.timestamp,
-					};
+					});
 				}
-				case "custom":
-				case "hookMessage":
-				case "branchSummary":
-				case "compactionSummary":
-				case "user":
-				case "developer":
-				case "assistant":
-				case "toolResult":
-					// Core roles share one transformer with agent-core —
-					// duplicating them here is how snapcompact frames once
-					// silently fell off the provider request.
-					return convertMessageToLlm(m);
-				default:
-					m satisfies never;
-					return undefined;
+				return out;
 			}
-		})
-		.filter(m => m !== undefined);
+			case "custom":
+			case "hookMessage":
+			case "branchSummary":
+			case "compactionSummary":
+			case "user":
+			case "developer":
+			case "assistant":
+			case "toolResult": {
+				// Core roles share one transformer with agent-core —
+				// duplicating them here is how snapcompact frames once
+				// silently fell off the provider request.
+				const converted = convertMessageToLlm(m);
+				return converted ? [converted] : [];
+			}
+			default:
+				m satisfies never;
+				return [];
+		}
+	});
 }

package/src/tools/ast-edit.ts

@@ -283,6 +283,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				settings: this.session.settings,
 				signal,
 				localProtocolOptions: this.session.localProtocolOptions,
+				skills: this.session.skills,
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;
 

package/src/tools/ast-grep.ts

@@ -185,6 +185,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				settings: this.session.settings,
 				signal,
 				localProtocolOptions: this.session.localProtocolOptions,
+				skills: this.session.skills,
 			});
 			const { searchPath: resolvedSearchPath, scopePath, isDirectory, multiTargets, globFilter } = scope;
 

package/src/tools/find.ts

@@ -166,6 +166,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					settings: this.session.settings,
 					signal,
 					localProtocolOptions: this.session.localProtocolOptions,
+					skills: this.session.skills,
 				});
 				if (!resource.sourcePath) {
 					throw new ToolError(`Cannot find internal URL without a backing file: ${rawPattern}`);

package/src/tools/path-utils.ts

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isEnoent } from "@oh-my-pi/pi-utils";
+import type { Skill } from "../extensibility/skills";
 import { InternalUrlRouter, type LocalProtocolOptions } from "../internal-urls";
 import { ToolError } from "./tool-errors";
 
@@ -986,6 +987,8 @@ export interface ToolScopeOptions {
 	signal?: AbortSignal;
 	/** Calling session's `local://` root mapping — pins resolutions to the calling session. */
 	localProtocolOptions?: LocalProtocolOptions;
+	/** Calling session's loaded skills — lets skill:// resolve without process-global state. */
+	skills?: readonly Skill[];
 }
 
 export interface ToolScopeResolution {
@@ -1042,6 +1045,7 @@ export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<To
 			settings: opts.settings,
 			signal: opts.signal,
 			localProtocolOptions: opts.localProtocolOptions,
+			skills: opts.skills,
 		});
 		if (!resource.sourcePath) {
 			throw new ToolError(`Cannot ${internalUrlAction} internal URL without a backing file: ${rawPath}`);