comisai 1.0.4

package/node_modules/@comis/skills/dist/prompt/sanitizer.js

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Content sanitization module for prompt skill bodies.
+ *
+ * Defends against hidden content injection (HTML comments, invisible Unicode)
+ * and enforces body size limits before skill content reaches the system prompt.
+ *
+ * All functions are pure -- no event bus emission, no config reads, no side effects.
+ * Returns audit metadata (comment count, truncation flag, tag block detection)
+ * for the caller to emit events.
+ *
+ * Sanitization order: strip HTML comments -> NFKC normalize -> strip zero-width -> enforce size.
+ */
+import { stripInvisible } from "@comis/core";
+/**
+ * Re-export ZERO_WIDTH_REGEX from the shared module for backward compatibility.
+ * Previously defined locally; now sourced from @comis/core/security/injection-patterns.
+ */
+export { ZERO_WIDTH_REGEX } from "@comis/core";
+/** Non-greedy regex for HTML comments. Avoids spanning across multiple comments. */
+export const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
+/** Truncation marker appended when body exceeds maxBodyLength. */
+export const TRUNCATION_MARKER = "\n[TRUNCATED]";
+/**
+ * Strip all HTML comments from text.
+ *
+ * Uses non-greedy regex to handle multiple separate comments correctly
+ * (stops at the first `-->` rather than the last).
+ *
+ * @param text - Raw text potentially containing HTML comments
+ * @returns The cleaned text and count of comments removed (for audit logging)
+ */
+export function stripHtmlComments(text) {
+    let count = 0;
+    // Reset lastIndex for global regex reuse across multiple calls
+    HTML_COMMENT_REGEX.lastIndex = 0;
+    const stripped = text.replace(HTML_COMMENT_REGEX, () => {
+        count++;
+        return "";
+    });
+    return { text: stripped, count };
+}
+/**
+ * Sanitize a prompt skill body through the full pipeline.
+ *
+ * Pipeline order (strict):
+ * 1. Strip HTML comments (hidden content defense)
+ * 2. NFKC normalization (fullwidth/ligature decomposition)
+ * 3. Strip zero-width/invisible characters (including tag block bypass)
+ * 4. Enforce body size (truncate at maxBodyLength with marker)
+ *
+ * Size enforcement applies to the FINAL sanitized output, not the raw input.
+ * This prevents unnecessary truncation when HTML comments inflate the raw size.
+ *
+ * @param body - Raw skill body content
+ * @param maxBodyLength - Maximum allowed characters for the final output
+ * @returns Sanitized body with audit metadata
+ */
+export function sanitizeSkillBody(body, maxBodyLength) {
+    // Step 1: Strip HTML comments (count for audit)
+    const { text: noComments, count: htmlCommentsStripped } = stripHtmlComments(body);
+    // Step 2: NFKC normalization (compatibility decomposition + canonical composition)
+    const normalized = noComments.normalize("NFKC");
+    // Step 3: Strip zero-width/invisible characters (including tag block bypass)
+    const { text: cleaned, tagBlockDetected } = stripInvisible(normalized);
+    // Step 4: Enforce body size
+    const truncated = cleaned.length > maxBodyLength;
+    const finalBody = truncated
+        ? cleaned.slice(0, maxBodyLength) + TRUNCATION_MARKER
+        : cleaned;
+    return { body: finalBody, htmlCommentsStripped, truncated, tagBlockDetected };
+}

package/node_modules/@comis/skills/dist/registry/diagnostics.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Diagnostic types for skill discovery.
+ *
+ * Provides structured diagnostics for collision handling, warnings, and errors
+ * that occur during filesystem skill discovery. Used by discoverSkills() to
+ * report issues without throwing exceptions.
+ *
+ * @module
+ */
+/** Details of a name collision between two skill files. */
+export interface ResourceCollision {
+    readonly resourceType: "skill";
+    readonly name: string;
+    readonly winnerPath: string;
+    readonly loserPath: string;
+}
+/** A diagnostic emitted during discovery (warning, error, or collision). */
+export interface ResourceDiagnostic {
+    readonly type: "warning" | "error" | "collision";
+    readonly message: string;
+    readonly path?: string;
+    readonly collision?: ResourceCollision;
+}

package/node_modules/@comis/skills/dist/registry/diagnostics.js

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Diagnostic types for skill discovery.
+ *
+ * Provides structured diagnostics for collision handling, warnings, and errors
+ * that occur during filesystem skill discovery. Used by discoverSkills() to
+ * report issues without throwing exceptions.
+ *
+ * @module
+ */
+export {};

package/node_modules/@comis/skills/dist/registry/discovery.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Filesystem discovery for prompt skill manifests (SKILL.md / root .md files).
+ *
+ * Scans configured paths for skill files using dual-mode matching:
+ * - Root `.md` files in the skills directory root
+ * - Recursive `SKILL.md` files in subdirectories
+ *
+ * All discovered skills are type "prompt".
+ *
+ * Features:
+ * - `.gitignore`, `.ignore`, `.fdignore` pattern support via `ignore` package
+ * - First-loaded-wins collision handling with diagnostics
+ * - Symlink deduplication via `realpathSync`
+ * - Extracts extended metadata including invocation controls and argument hints
+ *
+ * Uses synchronous fs operations to prevent TOCTOU races.
+ *
+ * @module
+ */
+import type { ResourceDiagnostic } from "./diagnostics.js";
+/** Minimal pino-compatible logger for discovery warnings. */
+export interface DiscoveryLogger {
+    warn(obj: Record<string, unknown>, msg: string): void;
+}
+/**
+ * Source of a discovered skill: where in the discovery path order it was found.
+ * "bundled" = first discovery path (highest priority), typically agent workspace skills.
+ * "workspace" = middle discovery paths. "local" = last discovery path.
+ * Note: "bundled" does not necessarily mean shipped with the repo -- it means
+ * the highest-priority discovery path (index 0).
+ */
+export type SkillSource = "bundled" | "workspace" | "local";
+/** Metadata extracted from a SKILL.md or root .md frontmatter during discovery. */
+export interface SkillMetadata {
+    /** Unique skill name (from frontmatter) */
+    readonly name: string;
+    /** Human-readable description (from frontmatter) */
+    readonly description: string;
+    /** Absolute path to the skill directory containing the manifest file */
+    readonly path: string;
+    /** Source category based on discovery path order */
+    readonly source: SkillSource;
+    /** Skill type: always "prompt" for Markdown instruction skills */
+    readonly type: "prompt";
+    /** Whether users can invoke this skill via /skill:name */
+    readonly userInvocable: boolean;
+    /** When true, skill is hidden from model's available skills listing */
+    readonly disableModelInvocation: boolean;
+    /** Optional hint text shown to users (e.g., "[name]") */
+    readonly argumentHint?: string;
+    /** Absolute path to the actual manifest file (.md or SKILL.md) */
+    readonly filePath: string;
+    /** Platform constraints. undefined = runs everywhere. */
+    readonly os?: string[];
+    /** Binary and env var prerequisites. */
+    readonly requires?: {
+        readonly bins: string[];
+        readonly env: string[];
+    };
+    /** Unique programmatic key (slug format). Used as display name when present. */
+    readonly skillKey?: string;
+    /** Main environment variable for grouping (display hint). */
+    readonly primaryEnv?: string;
+    /** Dispatch mode tag (metadata-only in this phase). */
+    readonly commandDispatch?: string;
+}
+/** Result of skill discovery: skills found plus any diagnostics (collisions, warnings). */
+export interface DiscoveryResult {
+    readonly skills: SkillMetadata[];
+    readonly diagnostics: ResourceDiagnostic[];
+}
+/**
+ * Discover prompt skills from filesystem paths with recursive scanning and dual-mode matching.
+ *
+ * For each discovery path:
+ * - Root level: matches any `.md` file (prompt skills as root files)
+ * - Subdirectories: matches only `SKILL.md` files (prompt skills in subdirs)
+ * - Skips hidden directories (`.name`) and `node_modules`
+ * - Respects `.gitignore`, `.ignore`, and `.fdignore` files
+ *
+ * All discovered skills are type "prompt" regardless of frontmatter.
+ *
+ * Paths are processed in order. If two skills have the same name, the first
+ * path (lower index) wins. This enables priority: bundled > workspace > local.
+ *
+ * Missing paths are silently skipped (not all discovery paths may exist).
+ * Malformed skill files are logged as warnings and skipped.
+ * Symlinked files pointing to the same real path are silently deduplicated.
+ *
+ * @param paths - Directories to scan for skill files
+ * @param logger - Optional structured logger for discovery warnings
+ * @returns DiscoveryResult with deduplicated skills and diagnostics
+ */
+export declare function discoverSkills(paths: string[], logger?: DiscoveryLogger): DiscoveryResult;

package/node_modules/@comis/skills/dist/registry/discovery.js

@@ -0,0 +1,332 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Filesystem discovery for prompt skill manifests (SKILL.md / root .md files).
+ *
+ * Scans configured paths for skill files using dual-mode matching:
+ * - Root `.md` files in the skills directory root
+ * - Recursive `SKILL.md` files in subdirectories
+ *
+ * All discovered skills are type "prompt".
+ *
+ * Features:
+ * - `.gitignore`, `.ignore`, `.fdignore` pattern support via `ignore` package
+ * - First-loaded-wins collision handling with diagnostics
+ * - Symlink deduplication via `realpathSync`
+ * - Extracts extended metadata including invocation controls and argument hints
+ *
+ * Uses synchronous fs operations to prevent TOCTOU races.
+ *
+ * @module
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import ignore from "ignore";
+import { parseFrontmatter } from "../manifest/parser.js";
+// ---------------------------------------------------------------------------
+// Ignore helpers
+// ---------------------------------------------------------------------------
+/** Ignore file names to load at each directory level. */
+const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
+/** Convert a path to POSIX-style forward slashes (required by `ignore` package). */
+function toPosixPath(p) {
+    return p.split(path.sep).join("/");
+}
+/**
+ * Prefix an ignore pattern with a directory-relative scope.
+ * Handles comments, negation, anchoring, and prefix scoping.
+ *
+ * @returns Prefixed pattern string, or null if the line should be skipped.
+ */
+function prefixIgnorePattern(line, prefix) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("#") && !trimmed.startsWith("\\#"))
+        return null;
+    let pattern = line;
+    let negated = false;
+    if (pattern.startsWith("!")) {
+        negated = true;
+        pattern = pattern.slice(1);
+    }
+    else if (pattern.startsWith("\\!")) {
+        pattern = pattern.slice(1);
+    }
+    if (pattern.startsWith("/")) {
+        pattern = pattern.slice(1);
+    }
+    const prefixed = prefix ? `${prefix}${pattern}` : pattern;
+    return negated ? `!${prefixed}` : prefixed;
+}
+/**
+ * Load ignore rules from `.gitignore`, `.ignore`, and `.fdignore` files
+ * in the given directory, prefixing patterns with the relative path from root.
+ */
+function addIgnoreRules(ig, dir, rootDir) {
+    const relativeDir = path.relative(rootDir, dir);
+    const prefix = relativeDir ? `${toPosixPath(relativeDir)}/` : "";
+    for (const filename of IGNORE_FILE_NAMES) {
+        // eslint-disable-next-line no-restricted-syntax -- Trusted: dir from config, filename from constant
+        const ignorePath = path.join(dir, filename);
+        if (!fs.existsSync(ignorePath))
+            continue;
+        try {
+            const content = fs.readFileSync(ignorePath, "utf-8");
+            const patterns = content
+                .split(/\r?\n/)
+                .map((line) => prefixIgnorePattern(line, prefix))
+                .filter((line) => Boolean(line));
+            if (patterns.length > 0)
+                ig.add(patterns);
+        }
+        catch {
+            /* skip unreadable ignore files */
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Determine source category based on the index of the discovery path.
+ * First path (index 0) = "bundled" (highest priority, e.g., agent workspace skills),
+ * last path = "local", everything in between = "workspace".
+ */
+function resolveSource(pathIndex, totalPaths) {
+    if (totalPaths === 1)
+        return "bundled";
+    if (pathIndex === 0)
+        return "bundled";
+    if (pathIndex === totalPaths - 1)
+        return "local";
+    return "workspace";
+}
+/**
+ * Try to extract metadata from a skill file's YAML frontmatter.
+ * Returns null if the file cannot be read or the frontmatter is invalid.
+ *
+ * Only parses the frontmatter block -- does not validate the full manifest schema.
+ * This keeps discovery fast and lightweight (Level 1 progressive disclosure).
+ */
+function extractMetadataFromSkillMd(skillMdPath) {
+    let content;
+    try {
+        content = fs.readFileSync(skillMdPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const fmResult = parseFrontmatter(content);
+    if (!fmResult.ok) {
+        return null;
+    }
+    const obj = fmResult.value.frontmatter;
+    if (typeof obj["name"] !== "string" || typeof obj["description"] !== "string") {
+        return null;
+    }
+    // All skills are type "prompt"
+    const type = "prompt";
+    const userInvocable = typeof obj["userInvocable"] === "boolean" ? obj["userInvocable"] : true;
+    const disableModelInvocation = typeof obj["disableModelInvocation"] === "boolean"
+        ? obj["disableModelInvocation"]
+        : false;
+    const argumentHint = typeof obj["argumentHint"] === "string" ? obj["argumentHint"] : undefined;
+    // --- Comis namespace support ---
+    // Read from comis: namespace block only
+    const ns = (typeof obj["comis"] === "object" && obj["comis"] !== null && !Array.isArray(obj["comis"]))
+        ? obj["comis"]
+        : undefined;
+    // os field -- coerce string to array, normalize lowercase
+    const rawOs = ns?.["os"];
+    const os = typeof rawOs === "string"
+        ? [rawOs.toLowerCase()]
+        : Array.isArray(rawOs)
+            ? rawOs.filter((v) => typeof v === "string").map((v) => v.toLowerCase())
+            : undefined;
+    // requires field -- validate strict shape (bins + env only)
+    const rawRequires = ns?.["requires"];
+    let requires;
+    if (rawRequires && typeof rawRequires === "object" && !Array.isArray(rawRequires)) {
+        const r = rawRequires;
+        const bins = Array.isArray(r["bins"]) ? r["bins"].filter((v) => typeof v === "string") : [];
+        const env = Array.isArray(r["env"]) ? r["env"].filter((v) => typeof v === "string") : [];
+        requires = { bins, env };
+    }
+    // skill-key field -- coerce to valid slug
+    const rawSkillKey = ns?.["skill-key"];
+    const skillKey = typeof rawSkillKey === "string"
+        ? rawSkillKey.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "") || undefined
+        : undefined;
+    // primary-env field
+    const rawPrimaryEnv = ns?.["primary-env"];
+    const primaryEnv = typeof rawPrimaryEnv === "string" ? rawPrimaryEnv : undefined;
+    // command-dispatch field
+    const rawCommandDispatch = ns?.["command-dispatch"];
+    const commandDispatch = typeof rawCommandDispatch === "string" ? rawCommandDispatch : undefined;
+    return { name: obj["name"], description: obj["description"], type, userInvocable, disableModelInvocation, argumentHint, os, requires, skillKey, primaryEnv, commandDispatch };
+}
+/**
+ * Recursive internal helper for discovering skills within a directory tree.
+ *
+ * @param dir - Current directory to scan
+ * @param source - Source category for skills found here
+ * @param includeRootFiles - If true, match any .md file (root level); if false, match only SKILL.md
+ * @param skillMap - Accumulator map for deduplication (first-loaded-wins)
+ * @param diagnostics - Accumulator for collision and warning diagnostics
+ * @param realPathSet - Set of resolved real paths for symlink deduplication
+ * @param ig - Ignore matcher instance for gitignore-style filtering
+ * @param rootDir - Root directory for relative path computation (for ignore patterns)
+ * @param logger - Optional structured logger for discovery warnings
+ */
+function discoverSkillsFromDir(dir, source, includeRootFiles, skillMap, diagnostics, realPathSet, ig, rootDir, logger, skillKeyMap) {
+    // Load ignore rules for this directory level
+    addIgnoreRules(ig, dir, rootDir);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        // Skip hidden entries and node_modules
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+            continue;
+        // eslint-disable-next-line no-restricted-syntax -- Trusted: dir from config, entry.name from readdirSync
+        const fullPath = path.join(dir, entry.name);
+        // Resolve symlinks to determine actual type
+        let isDirectory = entry.isDirectory();
+        let isFile = entry.isFile();
+        if (entry.isSymbolicLink()) {
+            try {
+                const stats = fs.statSync(fullPath);
+                isDirectory = stats.isDirectory();
+                isFile = stats.isFile();
+            }
+            catch {
+                // Broken symlink -- skip gracefully
+                continue;
+            }
+        }
+        // Check ignore rules (append "/" for directories per gitignore spec)
+        const relPath = toPosixPath(path.relative(rootDir, fullPath));
+        if (relPath && ig.ignores(isDirectory ? `${relPath}/` : relPath))
+            continue;
+        if (isDirectory) {
+            // Recurse into subdirectories with includeRootFiles=false
+            discoverSkillsFromDir(fullPath, source, false, skillMap, diagnostics, realPathSet, ig, rootDir, logger, skillKeyMap);
+            continue;
+        }
+        if (!isFile)
+            continue;
+        // Dual-mode file matching:
+        // Root level (includeRootFiles=true): match any .md file
+        // Subdirectory level (includeRootFiles=false): match only SKILL.md
+        const isRootMd = includeRootFiles && entry.name.endsWith(".md");
+        const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
+        if (!isRootMd && !isSkillMd)
+            continue;
+        // Symlink deduplication: resolve to real path
+        let realPath;
+        try {
+            realPath = fs.realpathSync(fullPath);
+        }
+        catch {
+            realPath = fullPath;
+        }
+        // Silent skip if same real file already loaded (same file via different symlink)
+        if (realPathSet.has(realPath))
+            continue;
+        const metadata = extractMetadataFromSkillMd(fullPath);
+        if (metadata === null) {
+            logger?.warn({ skillPath: fullPath, hint: "Check skill file has valid YAML frontmatter with name and description fields", errorKind: "validation" }, "Skipping malformed skill file");
+            continue;
+        }
+        // Determine the skill directory:
+        // For root .md files: the directory containing the file
+        // For subdirectory SKILL.md: the directory containing SKILL.md
+        const skillDir = isRootMd ? dir : path.dirname(fullPath);
+        // First-loaded-wins: keep existing, emit collision diagnostic for duplicate
+        const existing = skillMap.get(metadata.name);
+        if (existing) {
+            const collision = {
+                resourceType: "skill",
+                name: metadata.name,
+                winnerPath: existing.path,
+                loserPath: skillDir,
+            };
+            diagnostics.push({
+                type: "collision",
+                message: `name "${metadata.name}" collision`,
+                path: skillDir,
+                collision,
+            });
+        }
+        else {
+            const skillMeta = {
+                name: metadata.name,
+                description: metadata.description,
+                path: skillDir,
+                source,
+                type: metadata.type,
+                userInvocable: metadata.userInvocable,
+                disableModelInvocation: metadata.disableModelInvocation,
+                argumentHint: metadata.argumentHint,
+                filePath: fullPath,
+                os: metadata.os,
+                requires: metadata.requires,
+                skillKey: metadata.skillKey,
+                primaryEnv: metadata.primaryEnv,
+                commandDispatch: metadata.commandDispatch,
+            };
+            skillMap.set(metadata.name, skillMeta);
+            realPathSet.add(realPath);
+            // Skill-key collision detection (last-loaded-wins)
+            if (skillKeyMap && metadata.skillKey) {
+                const existingByKey = skillKeyMap.get(metadata.skillKey);
+                if (existingByKey) {
+                    logger?.warn({ skillKey: metadata.skillKey, existingPath: existingByKey.filePath, newPath: fullPath, hint: "Two skills share the same skill-key; last-loaded wins", errorKind: "config" }, "Skill-key collision detected");
+                }
+                skillKeyMap.set(metadata.skillKey, skillMeta);
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Discover prompt skills from filesystem paths with recursive scanning and dual-mode matching.
+ *
+ * For each discovery path:
+ * - Root level: matches any `.md` file (prompt skills as root files)
+ * - Subdirectories: matches only `SKILL.md` files (prompt skills in subdirs)
+ * - Skips hidden directories (`.name`) and `node_modules`
+ * - Respects `.gitignore`, `.ignore`, and `.fdignore` files
+ *
+ * All discovered skills are type "prompt" regardless of frontmatter.
+ *
+ * Paths are processed in order. If two skills have the same name, the first
+ * path (lower index) wins. This enables priority: bundled > workspace > local.
+ *
+ * Missing paths are silently skipped (not all discovery paths may exist).
+ * Malformed skill files are logged as warnings and skipped.
+ * Symlinked files pointing to the same real path are silently deduplicated.
+ *
+ * @param paths - Directories to scan for skill files
+ * @param logger - Optional structured logger for discovery warnings
+ * @returns DiscoveryResult with deduplicated skills and diagnostics
+ */
+export function discoverSkills(paths, logger) {
+    const skillMap = new Map();
+    const diagnostics = [];
+    const realPathSet = new Set();
+    const skillKeyMap = new Map();
+    for (let i = 0; i < paths.length; i++) {
+        const basePath = paths[i];
+        const source = resolveSource(i, paths.length);
+        const ig = ignore();
+        discoverSkillsFromDir(basePath, source, true, skillMap, diagnostics, realPathSet, ig, basePath, logger, skillKeyMap);
+    }
+    return { skills: Array.from(skillMap.values()), diagnostics };
+}

package/node_modules/@comis/skills/dist/registry/eligibility.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Runtime eligibility evaluation for prompt skills.
+ *
+ * Determines whether a skill's OS, binary, and environment prerequisites
+ * are satisfied on the current machine. Used by skill-registry to exclude
+ * ineligible skills from agent system prompts.
+ *
+ * Security: Uses safePath() for binary path construction (not path.join),
+ * SecretManager for env var checks (not process.env), fs.accessSync for
+ * binary detection (no subprocess spawning).
+ *
+ * @module
+ */
+import type { SecretManager } from "@comis/core";
+/** Context providing runtime environment checks for skill eligibility. */
+export interface RuntimeEligibilityContext {
+    /** Current OS platform (e.g., "linux", "darwin", "win32"). */
+    readonly platform: string;
+    /** Check whether a binary is available on PATH. */
+    hasBin(name: string): boolean;
+    /** Check whether an environment variable is set. */
+    hasEnv(key: string): boolean;
+    /** Pre-populate the binary availability cache for a set of binary names. */
+    populateBinaryCache(binNames: string[]): void;
+}
+/** Result of evaluating a skill's runtime eligibility. */
+export interface EligibilityResult {
+    /** Whether the skill is eligible to run on this machine. */
+    readonly eligible: boolean;
+    /** Human-readable reason for ineligibility (only set when eligible is false). */
+    readonly reason?: string;
+}
+/**
+ * Create a RuntimeEligibilityContext backed by the given SecretManager.
+ *
+ * Reads PATH from SecretManager (not process.env), splits it into
+ * directories, and provides binary/env checks delegating to the
+ * appropriate secure primitives.
+ *
+ * @param secretManager - SecretManager for env var and PATH access
+ * @returns RuntimeEligibilityContext ready for use in evaluateSkillEligibility
+ */
+export declare function createRuntimeEligibilityContext(secretManager: SecretManager): RuntimeEligibilityContext;
+/**
+ * Evaluate whether a skill is eligible to run on the current machine.
+ *
+ * Checks OS platform, required binaries, and required env vars in that
+ * order (fail-fast). Returns eligible:true when all constraints pass or
+ * when the skill has no constraints.
+ *
+ * @param metadata - Skill metadata with optional os and requires fields
+ * @param ctx - Runtime eligibility context for environment checks
+ * @returns EligibilityResult indicating eligible/ineligible with reason
+ */
+export declare function evaluateSkillEligibility(metadata: {
+    os?: string[];
+    requires?: {
+        bins: string[];
+        env: string[];
+    };
+}, ctx: RuntimeEligibilityContext): EligibilityResult;