@fungi.computer/truffle 0.0.0-stage → 0.1.1

package/dist/local-login.d.ts

@@ -0,0 +1,55 @@
+import type { AuthInteraction, Provider } from "@earendil-works/pi-ai";
+import type { WhistleInteraction } from "@fungi.computer/whistle";
+import type { PrivateLocalServiceManager } from "./private-local-service.js";
+/** Display order for popular model providers; labels remain owned by Pi. */
+export declare const localPopularProviderIds: readonly string[];
+/** One sign-in method, in the provider registry's vocabulary. */
+export type LocalLoginMethod = Readonly<{
+    kind: "api_key" | "subscription";
+    label: string;
+}>;
+/** One provider Local can sign in to, derived from Pi's provider data. */
+export type LocalLoginProvider = Readonly<{
+    id: string;
+    name: string;
+    methods: readonly LocalLoginMethod[];
+}>;
+/**
+ * Describe Pi's providers as registry data. Pi's OAuth sign-in is the
+ * provider's consumer subscription; ambient-only API keys (no interactive
+ * setup) are not offered. Callers pass the policy-filtered collection from
+ * `createPrivateModels`.
+ */
+export declare function localLoginProviders(providers: readonly Provider[]): readonly LocalLoginProvider[];
+/**
+ * Present Pi's provider sign-in through a Whistle interaction. `option`
+ * answers Pi's own method question (e.g. `device_code`) without asking. If
+ * the flow's first event -- a prompt or a notification -- is not a `select`
+ * offering that option, the flow never asks the question at all (e.g.
+ * Anthropic, which has only one sign-in method); cancel before relaying
+ * anything to the host, so no browser URL or other handoff is ever shown
+ * for a method the provider silently ignored.
+ */
+export declare function authInteractionFor(interaction: WhistleInteraction, option?: string): AuthInteraction;
+/** The Local credential owner behind provider-agnostic account commands. */
+export declare function localAccountOwner(manager: Pick<PrivateLocalServiceManager, "auth">, providers: () => readonly Provider[]): {
+    popularProviderIds: readonly string[];
+    access: (signal: AbortSignal) => Promise<Readonly<{
+        providerId: string;
+        providerName: string;
+        state: "configured";
+        type: import("@earendil-works/pi-ai").AuthType;
+    }>[]>;
+    providers: () => Promise<readonly Readonly<{
+        id: string;
+        name: string;
+        methods: readonly LocalLoginMethod[];
+    }>[]>;
+    login: (request: Readonly<{
+        providerId: string;
+        method: LocalLoginMethod["kind"];
+        option?: string;
+    }>, interaction: WhistleInteraction) => Promise<void>;
+    logout: (providerId: string, interaction: WhistleInteraction) => Promise<void>;
+    status: (signal: AbortSignal) => Promise<string>;
+};

package/dist/local-login.js

@@ -0,0 +1,167 @@
+/** Display order for popular model providers; labels remain owned by Pi. */
+export const localPopularProviderIds = Object.freeze([
+    "fungi",
+    "openai",
+    "anthropic",
+    "deepseek",
+    "kimi-coding",
+    "openrouter",
+]);
+/**
+ * Describe Pi's providers as registry data. Pi's OAuth sign-in is the
+ * provider's consumer subscription; ambient-only API keys (no interactive
+ * setup) are not offered. Callers pass the policy-filtered collection from
+ * `createPrivateModels`.
+ */
+export function localLoginProviders(providers) {
+    return providers.flatMap((provider) => {
+        const methods = [];
+        if (provider.auth.apiKey?.login !== undefined)
+            methods.push({ kind: "api_key", label: provider.auth.apiKey.name });
+        if (provider.auth.oauth !== undefined)
+            methods.push({
+                kind: "subscription",
+                label: provider.auth.oauth.loginLabel ?? provider.auth.oauth.name,
+            });
+        return methods.length === 0
+            ? []
+            : [{ id: provider.id, name: provider.name, methods }];
+    });
+}
+function notice(event) {
+    switch (event.type) {
+        case "auth_url":
+            return event.instructions === undefined
+                ? { type: "handoff", url: event.url }
+                : { type: "handoff", url: event.url, message: event.instructions };
+        case "device_code":
+            return {
+                type: "handoff",
+                url: event.verificationUri,
+                code: event.userCode,
+            };
+        case "info":
+            return event.links === undefined
+                ? { type: "info", message: event.message }
+                : {
+                    type: "info",
+                    message: event.message,
+                    links: event.links.map((link) => link.label === undefined
+                        ? { url: link.url }
+                        : { url: link.url, label: link.label }),
+                };
+        case "progress":
+            return { type: "progress", message: event.message };
+    }
+}
+async function ask(interaction, prompt) {
+    const options = prompt.signal === undefined ? {} : { signal: prompt.signal };
+    switch (prompt.type) {
+        case "select":
+            return interaction.prompt({
+                type: "choice",
+                message: prompt.message,
+                options: prompt.options.map((option) => option.description === undefined
+                    ? { value: option.id, label: option.label }
+                    : {
+                        value: option.id,
+                        label: option.label,
+                        description: option.description,
+                    }),
+            }, options);
+        case "manual_code": {
+            // Generic across every provider that falls back to a pasted code or
+            // redirect URL (OpenAI, Anthropic): the provider's own
+            // message explains what to paste; this adds the SSH hint once, here,
+            // instead of baking it into one provider's registry label.
+            const message = `${prompt.message} If you're connecting over SSH, paste the URL here instead of opening a browser.`;
+            return interaction.prompt(prompt.placeholder === undefined
+                ? { type: "text", message }
+                : { type: "text", message, placeholder: prompt.placeholder }, options);
+        }
+        case "secret":
+        case "text":
+            return interaction.prompt(prompt.placeholder === undefined
+                ? {
+                    type: "text",
+                    message: prompt.message,
+                    secret: prompt.type === "secret",
+                }
+                : {
+                    type: "text",
+                    message: prompt.message,
+                    placeholder: prompt.placeholder,
+                    secret: prompt.type === "secret",
+                }, options);
+    }
+}
+const methodNotOffered = "The provider did not offer that sign-in method";
+/**
+ * Present Pi's provider sign-in through a Whistle interaction. `option`
+ * answers Pi's own method question (e.g. `device_code`) without asking. If
+ * the flow's first event -- a prompt or a notification -- is not a `select`
+ * offering that option, the flow never asks the question at all (e.g.
+ * Anthropic, which has only one sign-in method); cancel before relaying
+ * anything to the host, so no browser URL or other handoff is ever shown
+ * for a method the provider silently ignored.
+ */
+export function authInteractionFor(interaction, option) {
+    let preset = option;
+    return {
+        signal: interaction.signal,
+        prompt: (prompt) => {
+            if (preset === undefined)
+                return ask(interaction, prompt);
+            if (prompt.type !== "select") {
+                preset = undefined;
+                return Promise.reject(new Error(methodNotOffered));
+            }
+            const chosen = prompt.options.find((one) => one.id === preset);
+            preset = undefined;
+            if (chosen === undefined)
+                return Promise.reject(new Error(methodNotOffered));
+            return Promise.resolve(chosen.id);
+        },
+        notify: (event) => {
+            if (preset !== undefined) {
+                preset = undefined;
+                throw new Error(methodNotOffered);
+            }
+            interaction.notify(notice(event));
+        },
+    };
+}
+/** The Local credential owner behind provider-agnostic account commands. */
+export function localAccountOwner(manager, providers) {
+    const access = async (signal) => {
+        const result = await manager.auth({ command: "status" }, {
+            signal,
+            prompt: () => Promise.reject(new Error("Account status cannot prompt")),
+            notify: () => undefined,
+        });
+        if (result.kind !== "status")
+            throw new Error("Account status returned a non-status result");
+        return result.providers.filter((provider) => provider.state === "configured");
+    };
+    return {
+        popularProviderIds: localPopularProviderIds,
+        access,
+        providers: () => Promise.resolve(localLoginProviders(providers())),
+        login: async (request, interaction) => {
+            await manager.auth({
+                command: "login",
+                provider: request.providerId,
+                authType: request.method === "subscription" ? "oauth" : "api_key",
+            }, authInteractionFor(interaction, request.option));
+        },
+        logout: async (providerId, interaction) => {
+            await manager.auth({ command: "logout", provider: providerId }, authInteractionFor(interaction));
+        },
+        status: async (signal) => {
+            const configured = (await access(signal)).map((provider) => `${provider.providerName}: configured (${provider.type})`);
+            return configured.length === 0
+                ? "No model provider is signed in. Use /login to add one."
+                : configured.join("\n");
+        },
+    };
+}

package/dist/local-models.d.ts

@@ -0,0 +1,14 @@
+import { type MutableModels, type ThinkingLevel } from "@earendil-works/pi-ai";
+/** Register Pi's standalone OAuth modules on the same instance Local uses. */
+export declare function registerPrivateBundledModelOAuthFlows(): void;
+/** Create the private local Pi collection with Pi's policy-permitted providers. */
+export declare function createPrivateModels(credentialPath?: string): MutableModels;
+export type PrivateLocalModelChoice = Readonly<{
+    providerId: string;
+    providerName: string;
+    id: string;
+    name: string;
+    reasoning: readonly ThinkingLevel[];
+}>;
+/** Refresh configured dynamic catalogs before exposing the bounded owner picker. */
+export declare function listPrivateModels(credentialPath?: string): Promise<readonly PrivateLocalModelChoice[]>;

package/dist/local-models.js

@@ -0,0 +1,77 @@
+import { createModels, getSupportedThinkingLevels, } from "@earendil-works/pi-ai";
+import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
+import { registerBunOAuthFlows } from "@earendil-works/pi-ai/bun-oauth";
+import { loginAllowed, subscriptionKillSwitchFrom, } from "@fungi.computer/veil/model-credentials";
+import { createFungiAccountCredentialStore } from "./private-fungi-account.js";
+import { createFungiModelProvider } from "./private-fungi-model-provider.js";
+/** Register Pi's standalone OAuth modules on the same instance Local uses. */
+export function registerPrivateBundledModelOAuthFlows() {
+    registerBunOAuthFlows();
+}
+/** Local credentials belong to the one person who owns this machine. */
+const allowedHere = (providerId, method) => loginAllowed({ providerId, method, host: "local", scope: "user" }, 
+// FUNGI_SUBSCRIPTION_KILL=anthropic,openai turns logins off without a release.
+subscriptionKillSwitchFrom(process.env.FUNGI_SUBSCRIPTION_KILL));
+/** Keep only the login methods Veil's provider policy allows on this machine. */
+function locallyPermitted(provider) {
+    const apiKey = allowedHere(provider.id, "api_key")
+        ? provider.auth.apiKey
+        : undefined;
+    const oauth = allowedHere(provider.id, "subscription")
+        ? provider.auth.oauth
+        : undefined;
+    if (apiKey === undefined && oauth === undefined)
+        return undefined;
+    const auth = {};
+    if (apiKey !== undefined)
+        auth.apiKey = apiKey;
+    if (oauth !== undefined)
+        auth.oauth = oauth;
+    return { ...provider, auth };
+}
+/** Create the private local Pi collection with Pi's policy-permitted providers. */
+export function createPrivateModels(credentialPath) {
+    const options = {};
+    if (credentialPath !== undefined)
+        options.credentialPath = credentialPath;
+    const credentials = createFungiAccountCredentialStore(options);
+    const models = createModels({ credentials });
+    for (const provider of builtinProviders()) {
+        const permitted = locallyPermitted(provider);
+        if (permitted !== undefined)
+            models.setProvider(permitted);
+    }
+    const fungi = locallyPermitted(createFungiModelProvider(options));
+    if (fungi !== undefined)
+        models.setProvider(fungi);
+    return models;
+}
+/** Refresh configured dynamic catalogs before exposing the bounded owner picker. */
+export async function listPrivateModels(credentialPath) {
+    const models = createPrivateModels(credentialPath);
+    const result = await models.refresh();
+    if (result.aborted)
+        throw new Error("Model catalog refresh was cancelled");
+    const fungiFailure = result.errors.get("fungi");
+    if (fungiFailure !== undefined)
+        throw fungiFailure;
+    if (result.errors.size > 0)
+        throw new AggregateError([...result.errors.values()], "Could not refresh model catalogs");
+    return Object.freeze(models
+        .getProviders()
+        .flatMap((provider) => models.getModels(provider.id).map((model) => ({
+        providerId: provider.id,
+        providerName: provider.name,
+        id: model.id,
+        name: model.name,
+        reasoning: getSupportedThinkingLevels(model).filter((level) => level !== "off"),
+    })))
+        .sort((left, right) => left.providerName.localeCompare(right.providerName) ||
+        left.name.localeCompare(right.name) ||
+        left.providerId.localeCompare(right.providerId) ||
+        left.id.localeCompare(right.id))
+        .map((choice) => Object.freeze({
+        ...choice,
+        reasoning: Object.freeze(choice.reasoning),
+    })));
+}

package/dist/local-skill-source.d.ts

@@ -0,0 +1,6 @@
+import type { SkillSource } from "@fungi.computer/shiitake-extensions/skills/source";
+/** Discover project-first skills without widening the invocation Files jail. */
+export declare function createLocalSkillSource(options: Readonly<{
+    cwd: string;
+    home?: string;
+}>): SkillSource;

package/dist/local-skill-source.js

@@ -0,0 +1,357 @@
+import { open, opendir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+const maximumSkillCount = 64;
+const maximumCatalogBytes = 16_000;
+const maximumFileBytes = 128 * 1_024;
+const maximumDirectoryEntries = 512;
+const maximumSupportingDepth = 16;
+const maximumDiscoveryDepth = 16;
+const utf8 = new TextEncoder();
+const nameSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u);
+const frontmatterSchema = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    "disable-model-invocation": z
+        .unknown()
+        .default(false)
+        .transform((value) => value === true),
+});
+const fileSchema = z
+    .string()
+    .min(1)
+    .max(4_096)
+    .refine((file) => !isAbsolute(file) &&
+    !file.includes("\\") &&
+    !file.includes("\0") &&
+    file
+        .split("/")
+        .every((part) => part !== "" && part !== "." && part !== ".."), "Skill file must remain a relative path inside its skill directory");
+function absent(cause) {
+    return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+function contained(root, path) {
+    const within = relative(root, path);
+    if (isAbsolute(within) ||
+        within === ".." ||
+        within.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`))
+        throw new Error("Skill path escapes its directory");
+    return path;
+}
+async function readBounded(path, signal) {
+    signal.throwIfAborted();
+    const handle = await open(path, "r");
+    try {
+        if (!(await handle.stat()).isFile())
+            throw new Error("Skill path is not a regular file");
+        const bytes = Buffer.alloc(maximumFileBytes + 1);
+        let size = 0;
+        while (size < bytes.length) {
+            signal.throwIfAborted();
+            const page = await handle.read(bytes, size, bytes.length - size, size);
+            if (page.bytesRead === 0)
+                break;
+            size += page.bytesRead;
+        }
+        if (size > maximumFileBytes)
+            throw new Error("Skill file exceeds the 128 KiB bound");
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(0, size));
+    }
+    finally {
+        await handle.close();
+    }
+}
+class SkillSourceError extends Error {
+}
+function diagnostic(path, reason, message, cause = new Error(message)) {
+    return { path, reason, message, cause };
+}
+function explanation(cause, fallback) {
+    return cause instanceof SkillSourceError ? cause.message : fallback;
+}
+function parseSkill(content, directory) {
+    const normalized = content.replace(/\r\n?/gu, "\n");
+    const match = /^---\n([\s\S]*?)\n---(?:\n|$)/u.exec(normalized);
+    if (!match)
+        throw new SkillSourceError("SKILL.md requires YAML frontmatter");
+    let frontmatter;
+    try {
+        frontmatter = parseYaml(match[1] ?? "");
+    }
+    catch (cause) {
+        throw new SkillSourceError("Skill frontmatter is not valid YAML", {
+            cause,
+        });
+    }
+    const result = frontmatterSchema.safeParse(frontmatter);
+    if (!result.success)
+        throw new SkillSourceError("Skill frontmatter has invalid field types", {
+            cause: result.error,
+        });
+    const metadata = result.data;
+    if (metadata.description === undefined || metadata.description.trim() === "")
+        throw new SkillSourceError("description is required");
+    const name = metadata.name === ""
+        ? basename(directory)
+        : (metadata.name ?? basename(directory));
+    return {
+        metadata: { ...metadata, name, description: metadata.description },
+        body: normalized.slice(match[0].length),
+    };
+}
+async function discoveryRoots(cwd) {
+    const project = [join(cwd, ".fungi/skills")];
+    let ancestor = cwd;
+    for (;;) {
+        project.push(join(ancestor, ".agents/skills"));
+        try {
+            await stat(join(ancestor, ".git"));
+            break;
+        }
+        catch (cause) {
+            if (!absent(cause))
+                throw cause;
+        }
+        const parent = dirname(ancestor);
+        if (parent === ancestor)
+            break;
+        ancestor = parent;
+    }
+    return project;
+}
+async function configuredRoots(path, base, home, signal, diagnostics) {
+    const settingsSchema = z.object({
+        skills: z.array(z.string().trim().min(1)).max(64).default([]),
+    });
+    try {
+        const settings = settingsSchema.parse(JSON.parse(await readBounded(path, signal)));
+        return settings.skills.map((folder) => folder === "~"
+            ? home
+            : folder.startsWith("~/")
+                ? resolve(home, folder.slice(2))
+                : resolve(base, folder));
+    }
+    catch (cause) {
+        signal.throwIfAborted();
+        if (!absent(cause))
+            diagnostics.push(diagnostic(path, "invalid", "Local settings must be valid JSON with a skills list of extra folders", cause));
+        return [];
+    }
+}
+/** Discover project-first skills without widening the invocation Files jail. */
+export function createLocalSkillSource(options) {
+    const cwd = resolve(options.cwd);
+    const home = resolve(options.home ?? homedir());
+    const catalog = async (signal) => {
+        const skills = [];
+        const diagnostics = [];
+        const names = new Set();
+        const paths = new Set();
+        const projectExtras = await configuredRoots(join(cwd, ".fungi/settings.json"), cwd, home, signal, diagnostics);
+        const personalExtras = await configuredRoots(join(home, ".fungi/settings.json"), join(home, ".fungi"), home, signal, diagnostics);
+        const extras = new Set([...projectExtras, ...personalExtras]);
+        const roots = [
+            ...(await discoveryRoots(cwd)),
+            ...projectExtras,
+            join(home, ".fungi/skills"),
+            join(home, ".agents/skills"),
+            ...personalExtras,
+        ];
+        const visitedRoots = new Set();
+        for (const path of roots) {
+            signal.throwIfAborted();
+            let root;
+            try {
+                root = await realpath(path);
+            }
+            catch (cause) {
+                signal.throwIfAborted();
+                if (!absent(cause) || extras.has(path))
+                    diagnostics.push({
+                        path,
+                        reason: "unavailable",
+                        message: "Skill root is unavailable",
+                        cause,
+                    });
+                continue;
+            }
+            if (visitedRoots.has(root))
+                continue;
+            visitedRoots.add(root);
+            const visited = new Set();
+            let entries = 0;
+            let found = 0;
+            const before = diagnostics.length;
+            const walk = async (directory, depth) => {
+                signal.throwIfAborted();
+                if (depth > maximumDiscoveryDepth) {
+                    diagnostics.push(diagnostic(directory, "bound", "Skill discovery exceeds its 16-level depth bound"));
+                    return;
+                }
+                if (visited.has(directory))
+                    return;
+                visited.add(directory);
+                const skillPath = join(directory, "SKILL.md");
+                let location;
+                try {
+                    location = contained(directory, await realpath(skillPath));
+                }
+                catch (cause) {
+                    signal.throwIfAborted();
+                    if (!absent(cause)) {
+                        diagnostics.push({
+                            path: skillPath,
+                            reason: "invalid",
+                            message: "Skill file escapes its directory or cannot be read",
+                            cause,
+                        });
+                        return;
+                    }
+                }
+                if (location !== undefined) {
+                    found++;
+                    try {
+                        if (paths.has(location))
+                            return;
+                        paths.add(location);
+                        const { metadata } = parseSkill(await readBounded(location, signal), directory);
+                        if (!nameSchema.safeParse(metadata.name).success ||
+                            metadata.name !== basename(directory))
+                            diagnostics.push(diagnostic(skillPath, "warning", "Skill name should match its directory, use lowercase letters, digits and single hyphens, and be at most 64 characters"));
+                        if (metadata.description.length > 1_024)
+                            diagnostics.push(diagnostic(skillPath, "warning", "Skill description exceeds the recommended 1024 characters"));
+                        if (names.has(metadata.name)) {
+                            diagnostics.push(diagnostic(skillPath, "collision", "Earlier skill with this name wins"));
+                            return;
+                        }
+                        names.add(metadata.name);
+                        if (metadata["disable-model-invocation"]) {
+                            diagnostics.push(diagnostic(skillPath, "skipped", "Skill disables model invocation"));
+                            return;
+                        }
+                        const skill = {
+                            name: metadata.name,
+                            description: metadata.description,
+                            location,
+                        };
+                        if (skills.length >= maximumSkillCount ||
+                            utf8.encode(JSON.stringify([...skills, skill])).byteLength >
+                                maximumCatalogBytes) {
+                            diagnostics.push(diagnostic(skillPath, "bound", "Skill catalog exceeds its 64-skill or 16 KB bound"));
+                            return;
+                        }
+                        skills.push(skill);
+                    }
+                    catch (cause) {
+                        signal.throwIfAborted();
+                        diagnostics.push({
+                            path: skillPath,
+                            reason: "invalid",
+                            message: explanation(cause, "Skill metadata or file is invalid"),
+                            cause,
+                        });
+                    }
+                    return;
+                }
+                const children = [];
+                for await (const entry of await opendir(directory)) {
+                    signal.throwIfAborted();
+                    if (++entries > maximumDirectoryEntries)
+                        throw new SkillSourceError("Skill discovery exceeds its 512-entry bound");
+                    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                        if (entry.isDirectory() || entry.isSymbolicLink())
+                            diagnostics.push(diagnostic(join(directory, entry.name), "skipped", "Dot directories and node_modules are not searched"));
+                        continue;
+                    }
+                    children.push(entry.name);
+                }
+                for (const child of children.sort()) {
+                    const candidate = join(directory, child);
+                    try {
+                        const canonical = contained(root, await realpath(candidate));
+                        if ((await stat(canonical)).isDirectory())
+                            await walk(canonical, depth + 1);
+                    }
+                    catch (cause) {
+                        signal.throwIfAborted();
+                        if (cause instanceof SkillSourceError)
+                            throw cause;
+                        diagnostics.push(diagnostic(join(candidate, "SKILL.md"), "invalid", "Skill entry escapes its root or is unavailable", cause));
+                    }
+                }
+            };
+            try {
+                await walk(root, 0);
+                if (found === 0 && diagnostics.length === before)
+                    diagnostics.push(diagnostic(path, "empty", entries === 0
+                        ? "Skill root is empty"
+                        : "Skill root contains no SKILL.md files"));
+            }
+            catch (cause) {
+                signal.throwIfAborted();
+                diagnostics.push({
+                    path,
+                    reason: cause instanceof SkillSourceError ? "bound" : "unavailable",
+                    message: explanation(cause, "Skill root cannot be searched"),
+                    cause,
+                });
+            }
+        }
+        return { skills, diagnostics };
+    };
+    return {
+        catalog,
+        read: async (name, file, signal) => {
+            z.string().min(1).parse(name);
+            const found = (await catalog(signal)).skills.find((skill) => skill.name === name);
+            if (!found)
+                throw new Error(`Unknown or hidden skill: ${name}`);
+            const baseDirectory = dirname(found.location);
+            const selected = file === undefined ? "SKILL.md" : fileSchema.parse(file);
+            const path = contained(baseDirectory, await realpath(join(baseDirectory, selected)));
+            const content = await readBounded(path, signal);
+            if (selected !== "SKILL.md")
+                return {
+                    name,
+                    file: selected,
+                    content,
+                    baseDirectory,
+                    supportingFiles: [],
+                };
+            const parsed = parseSkill(content, baseDirectory);
+            if (parsed.metadata["disable-model-invocation"])
+                throw new Error(`Hidden skill: ${name}`);
+            const supportingFiles = [];
+            let entries = 0;
+            const walk = async (directory, depth) => {
+                if (depth > maximumSupportingDepth)
+                    throw new Error("Skill supporting files exceed depth bound");
+                for await (const entry of await opendir(directory)) {
+                    signal.throwIfAborted();
+                    if (++entries > maximumDirectoryEntries)
+                        throw new Error("Skill supporting files exceed entry bound");
+                    const path = contained(baseDirectory, await realpath(join(directory, entry.name)));
+                    // Directory symlinks are not traversed; direct reads still enforce realpath containment.
+                    if (entry.isDirectory())
+                        await walk(path, depth + 1);
+                    else if ((await stat(path)).isFile() && path !== found.location)
+                        supportingFiles.push(relative(baseDirectory, path));
+                }
+            };
+            await walk(baseDirectory, 0);
+            return {
+                name,
+                file: selected,
+                content: parsed.body,
+                baseDirectory,
+                supportingFiles: supportingFiles.sort(),
+            };
+        },
+    };
+}

package/dist/log-event.d.ts

@@ -0,0 +1,2 @@
+/** Retain the original Local failure without printing exception or input text. */
+export declare function logEvent(operation: string, cause: unknown): void;