mustflow 2.99.2 → 2.103.10

package/dist/core/dependency-graph.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const DEPENDENCY_GRAPH_PACK_ID = 'code';
 export const DEPENDENCY_GRAPH_SCRIPT_ID = 'dependency-graph';
@@ -14,17 +15,7 @@ const MAX_ISSUES = 50;
 const MAX_CYCLES = 20;
 const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
 const RESOLVE_EXTENSIONS = [...SOURCE_EXTENSIONS, '.json'];
-const IGNORED_DIRECTORIES = [
-    '.git',
-    '.mustflow/cache',
-    '.mustflow/state',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.turbo',
-];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'dependency_graph_path_outside_root',
     'dependency_graph_unreadable_path',
@@ -64,8 +55,7 @@ function isSourceLanguage(language) {
     return language !== 'json' && language !== 'other';
 }
 function isIgnoredDirectory(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function makeFinding(code, severity, pathValue, message) {
     return { code, severity, path: pathValue, message };

package/dist/core/docs-link-integrity.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const LINK_INTEGRITY_PACK_ID = 'docs';
 export const LINK_INTEGRITY_SCRIPT_ID = 'link-integrity';
@@ -11,7 +12,7 @@ const MAX_ISSUES = 50;
 const DEFAULT_PATHS = ['README.md', 'schemas/README.md', 'docs-site/src/content/docs'];
 const PATH_FILTERS = ['*.md', '*.mdx'];
 const CHECKED_LINK_KINDS = ['local_file', 'local_anchor'];
-const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'build', 'coverage', '.astro']);
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'link_integrity_path_outside_root',
     'link_integrity_unreadable_path',
@@ -59,7 +60,7 @@ function addCandidate(candidates, findings, issues, policy, candidate) {
 }
 function collectDocumentsFromDirectory(projectRoot, absoluteDirectory, candidates, findings, issues, policy) {
     const relativeDirectory = normalizeRelativePath(path.relative(projectRoot, absoluteDirectory));
-    if (IGNORED_DIRECTORIES.has(path.basename(relativeDirectory)) || [...IGNORED_DIRECTORIES].some((entry) => relativeDirectory.startsWith(`${entry}/`))) {
+    if (isIgnoredDirectoryPath(relativeDirectory, IGNORED_DIRECTORIES)) {
         return;
     }
     let entries;
@@ -173,9 +174,26 @@ function splitTarget(target) {
     const anchor = rawAnchor === undefined ? null : decodeUriComponentSafe(rawAnchor);
     return { pathPart, anchor };
 }
+function stripHtmlTagText(value) {
+    let result = '';
+    let tagDepth = 0;
+    for (const char of value) {
+        if (char === '<') {
+            tagDepth += 1;
+            continue;
+        }
+        if (char === '>') {
+            tagDepth = Math.max(0, tagDepth - 1);
+            continue;
+        }
+        if (tagDepth === 0) {
+            result += char;
+        }
+    }
+    return result;
+}
 function slugHeading(value) {
-    return value
-        .replace(/<[^>]+>/gu, '')
+    return stripHtmlTagText(value)
         .replace(/[`*_~]/gu, '')
         .replace(/\[([^\]]+)\]\([^)]+\)/gu, '$1')
         .toLocaleLowerCase()
@@ -369,6 +387,7 @@ export function checkLinkIntegrity(projectRoot, options) {
         max_file_bytes: options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES,
         default_paths: [...DEFAULT_PATHS],
         path_filters: [...PATH_FILTERS],
+        ignored_directories: [...IGNORED_DIRECTORIES],
         checked_link_kinds: [...CHECKED_LINK_KINDS],
     };
     const findings = [];

package/dist/core/env-contract.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const ENV_CONTRACT_PACK_ID = 'repo';
 export const ENV_CONTRACT_SCRIPT_ID = 'env-contract';
@@ -36,17 +37,7 @@ const ENV_EXAMPLE_NAMES = [
     '.dev.vars.example',
 ];
 const SECRET_ENV_NAMES = ['.env', '.env.local', '.env.production', '.env.development', '.dev.vars'];
-const IGNORED_DIRECTORIES = [
-    '.git',
-    '.mustflow/cache',
-    '.mustflow/state',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.turbo',
-];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'env_contract_path_outside_root',
     'env_contract_unreadable_path',
@@ -66,8 +57,7 @@ function pushIssue(issues, issue) {
     }
 }
 function isIgnoredDirectory(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function isEnvExampleFile(relativePath) {
     const name = path.basename(relativePath).toLowerCase();

package/dist/core/export-diff.js

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { extractSymbols, languageForPath } from './code-outline.js';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const CODE_EXPORT_DIFF_SCRIPT_ID = 'export-diff';
 export const CODE_EXPORT_DIFF_SCRIPT_REF = `code/${CODE_EXPORT_DIFF_SCRIPT_ID}`;
@@ -10,7 +11,7 @@ const DEFAULT_BASE_REF = 'HEAD';
 const DEFAULT_MAX_FILES = 100;
 const DEFAULT_MAX_FILE_BYTES = 1024 * 1024;
 const SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
-const IGNORED_DIRECTORIES = ['.git', 'node_modules', 'dist', 'build', 'coverage', '.mustflow/cache', '.mustflow/state'];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'export_diff_git_unavailable',
     'export_diff_invalid_ref',
@@ -46,8 +47,7 @@ function makeFinding(code, severity, pathValue, message) {
     return { code, severity, path: pathValue, message };
 }
 function isIgnoredPath(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function isSupportedPath(relativePath) {
     return SUPPORTED_EXTENSIONS.includes(path.extname(relativePath).toLowerCase());

package/dist/core/ignored-directories.js

@@ -0,0 +1,40 @@
+export const DEFAULT_IGNORED_DIRECTORIES = [
+    '.git',
+    '.mustflow/cache',
+    '.mustflow/state',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.turbo',
+    '.astro',
+];
+function normalizeDirectoryPath(value) {
+    return value.replace(/\\/gu, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '') || '.';
+}
+function containsSegmentSequence(segments, sequence) {
+    if (sequence.length === 0 || sequence.length > segments.length) {
+        return false;
+    }
+    for (let index = 0; index <= segments.length - sequence.length; index += 1) {
+        if (sequence.every((segment, offset) => segments[index + offset] === segment)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isIgnoredDirectoryPath(relativePath, ignoredDirectories = DEFAULT_IGNORED_DIRECTORIES) {
+    const normalized = normalizeDirectoryPath(relativePath);
+    if (normalized === '.') {
+        return false;
+    }
+    const segments = normalized.split('/').filter((segment) => segment.length > 0);
+    return ignoredDirectories.some((entry) => {
+        const ignoredSegments = normalizeDirectoryPath(entry).split('/').filter((segment) => segment.length > 0);
+        if (ignoredSegments.length === 1) {
+            return segments.includes(ignoredSegments[0] ?? '');
+        }
+        return containsSegmentSequence(segments, ignoredSegments);
+    });
+}

package/dist/core/public-json-contracts.js

@@ -566,6 +566,22 @@ const PUBLIC_JSON_SCHEMA_CONTRACTS = [
             '--json',
         ],
     },
+    {
+        id: 'skill-import-report',
+        schemaFile: 'skill-import-report.schema.json',
+        producer: 'mf skill import <github-url> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: [
+            'mf',
+            'skill',
+            'import',
+            'https://github.com/example/agent-skills/blob/main/security-review/SKILL.md',
+            '--dry-run',
+            '--json',
+        ],
+        expectedExitCodes: [0, 1],
+    },
     {
         id: 'route-fixture',
         schemaFile: 'route-fixture.schema.json',

package/dist/core/reference-drift.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const REFERENCE_DRIFT_PACK_ID = 'docs';
 export const REFERENCE_DRIFT_SCRIPT_ID = 'reference-drift';
@@ -16,7 +17,7 @@ const CHECKED_REFERENCE_KINDS = [
     'schema_file',
     'repo_path',
 ];
-const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'build', 'coverage', '.astro']);
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'reference_drift_path_outside_root',
     'reference_drift_unreadable_path',
@@ -64,7 +65,7 @@ function addCandidate(candidates, findings, issues, policy, candidate) {
 }
 function collectDocumentsFromDirectory(projectRoot, absoluteDirectory, candidates, findings, issues, policy) {
     const relativeDirectory = normalizeRelativePath(path.relative(projectRoot, absoluteDirectory));
-    if (IGNORED_DIRECTORIES.has(path.basename(relativeDirectory)) || [...IGNORED_DIRECTORIES].some((entry) => relativeDirectory.startsWith(`${entry}/`))) {
+    if (isIgnoredDirectoryPath(relativeDirectory, IGNORED_DIRECTORIES)) {
         return;
     }
     let entries;
@@ -318,6 +319,7 @@ export function checkReferenceDrift(projectRoot, options) {
         max_file_bytes: options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES,
         default_paths: [...DEFAULT_PATHS],
         path_filters: [...PATH_FILTERS],
+        ignored_directories: [...IGNORED_DIRECTORIES],
         checked_reference_kinds: [...CHECKED_REFERENCE_KINDS],
     };
     const commandNames = new Set(options.commandNames);

package/dist/core/related-files.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const RELATED_FILES_PACK_ID = 'repo';
 export const RELATED_FILES_SCRIPT_ID = 'related-files';
@@ -12,17 +13,7 @@ const MAX_ISSUES = 50;
 const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
 const RESOLVE_EXTENSIONS = [...SOURCE_EXTENSIONS, '.json'];
 const RELATED_EXTENSIONS = [...RESOLVE_EXTENSIONS, '.d.ts', '.md', '.mdx', '.css', '.scss', '.sass', '.less'];
-const IGNORED_DIRECTORIES = [
-    '.git',
-    '.mustflow/cache',
-    '.mustflow/state',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.turbo',
-];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const CONFIG_FILE_PATTERNS = [
     /^package\.json$/u,
     /^tsconfig(?:\.[^.]+)?\.json$/u,
@@ -71,8 +62,7 @@ function isSourceLanguage(language) {
     return language !== 'json' && language !== 'other';
 }
 function isIgnoredDirectory(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function makeFinding(code, severity, pathValue, message) {
     return { code, severity, path: pathValue, message };

package/dist/core/repo-merge-conflict-scan.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInsideWithoutSymlinks, readUtf8FileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const REPO_MERGE_CONFLICT_SCAN_PACK_ID = 'repo';
 export const REPO_MERGE_CONFLICT_SCAN_SCRIPT_ID = 'merge-conflict-scan';
@@ -15,15 +16,9 @@ const MARKER_PATTERNS = [
     { prefix: '>>>>>>>', marker: 'end' },
 ];
 const SKIPPED_DIRECTORY_NAMES = new Set([
-    '.git',
-    'node_modules',
+    ...DEFAULT_IGNORED_DIRECTORIES,
     'vendor',
     'third_party',
-    'dist',
-    'build',
-    'coverage',
-    '.mustflow/cache',
-    '.mustflow/state',
 ]);
 function normalizeRelativePath(value) {
     return value.replace(/\\/gu, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '') || '.';
@@ -95,8 +90,7 @@ function collectGitChangedFiles(root, issues, findings) {
 }
 function shouldSkipDirectory(relativePath) {
     const normalized = normalizeRelativePath(relativePath);
-    const firstSegment = normalized.split('/')[0] ?? normalized;
-    return SKIPPED_DIRECTORY_NAMES.has(normalized) || SKIPPED_DIRECTORY_NAMES.has(firstSegment);
+    return isIgnoredDirectoryPath(normalized, [...SKIPPED_DIRECTORY_NAMES]);
 }
 function isLikelyTextFile(relativePath) {
     const extension = path.posix.extname(relativePath).toLowerCase();

package/dist/core/route-outline.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const CODE_ROUTE_OUTLINE_SCRIPT_ID = 'route-outline';
 export const CODE_ROUTE_OUTLINE_SCRIPT_REF = `code/${CODE_ROUTE_OUTLINE_SCRIPT_ID}`;
@@ -39,17 +40,7 @@ const LIFECYCLE_METHODS = [
     'onAfterHandle',
     'onError',
 ];
-const IGNORED_DIRECTORIES = [
-    '.git',
-    '.mustflow/cache',
-    '.mustflow/state',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.turbo',
-];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'code_route_outline_path_outside_root',
     'code_route_outline_unreadable_path',
@@ -85,8 +76,7 @@ function languageForPath(filePath) {
     }
 }
 function isIgnoredDirectory(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function makeFinding(code, severity, pathValue, message) {
     return { code, severity, path: pathValue, message };

package/dist/core/script-pack-suggestions.js

@@ -80,26 +80,37 @@ export function classifyScriptPackPathSurface(relativePath) {
     return surfaces.length > 0 ? uniqueSortedSurfaces(surfaces) : ['unknown'];
 }
 function readChangedPaths(mustflowRoot, issues) {
-    const result = spawnSync('git', ['status', '--short'], {
+    const result = spawnSync('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], {
         cwd: mustflowRoot,
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
+        maxBuffer: 16 * 1024 * 1024,
     });
-    if (result.status !== 0) {
-        const detail = result.stderr.trim() || result.stdout.trim() || `git status exited with ${result.status}`;
+    if (result.error || result.status !== 0) {
+        const detail = result.error?.message ?? (result.stderr.trim() || result.stdout.trim() || `git status exited with ${result.status}`);
         issues.push(`Could not read changed paths: ${detail}`);
         return [];
     }
-    return result.stdout
-        .split(/\r?\n/u)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length > 0)
-        .map((line) => {
-        const renamed = /\s->\s(?<target>.+)$/u.exec(line);
-        return renamed?.groups?.target ?? line.slice(3).trim();
-    })
-        .filter((entry) => entry.length > 0);
+    const paths = [];
+    const records = result.stdout.split('\0');
+    let index = 0;
+    while (index < records.length) {
+        const record = records[index] ?? '';
+        index += 1;
+        if (record.length === 0) {
+            continue;
+        }
+        const status = record.slice(0, 2);
+        const relativePath = record.slice(3);
+        if (relativePath.length > 0) {
+            paths.push(relativePath);
+        }
+        if (status.includes('R') || status.includes('C')) {
+            index += 1;
+        }
+    }
+    return paths;
 }
 function surfacesForScript(script) {
     const surfaces = new Set();

package/dist/core/secret-risk-scan.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readdirSync } from 'node:fs';
 import path from 'node:path';
+import { DEFAULT_IGNORED_DIRECTORIES, isIgnoredDirectoryPath } from './ignored-directories.js';
 import { ensureInside, ensureInsideWithoutSymlinks, readFileInsideWithoutSymlinks } from './safe-filesystem.js';
 export const SECRET_RISK_SCAN_PACK_ID = 'repo';
 export const SECRET_RISK_SCAN_SCRIPT_ID = 'secret-risk-scan';
@@ -35,17 +36,7 @@ const ENV_EXAMPLE_NAMES = [
     '.env.local.example',
     '.dev.vars.example',
 ];
-const IGNORED_DIRECTORIES = [
-    '.git',
-    '.mustflow/cache',
-    '.mustflow/state',
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '.next',
-    '.turbo',
-];
+const IGNORED_DIRECTORIES = DEFAULT_IGNORED_DIRECTORIES;
 const ERROR_CODES = new Set([
     'secret_risk_path_outside_root',
     'secret_risk_unreadable_path',
@@ -68,8 +59,7 @@ function makeFinding(code, severity, pathValue, message, details = {}) {
     return { code, severity, path: pathValue, message, ...details };
 }
 function isIgnoredDirectory(relativePath) {
-    const normalized = normalizeRelativePath(relativePath);
-    return IGNORED_DIRECTORIES.some((directory) => normalized === directory || normalized.startsWith(`${directory}/`));
+    return isIgnoredDirectoryPath(normalizeRelativePath(relativePath), IGNORED_DIRECTORIES);
 }
 function isSecretFile(relativePath) {
     return SECRET_FILE_NAMES.includes(path.basename(relativePath).toLowerCase());

package/dist/core/skill-route-resolution.js

@@ -7,6 +7,8 @@ const SKILL_INDEX_PATH = '.mustflow/skills/INDEX.md';
 const SKILL_ROUTER_PATH = '.mustflow/skills/router.toml';
 const SKILL_ROUTES_METADATA_PATH = '.mustflow/skills/routes.toml';
 const SKILL_FRONTMATTER_SOURCE = '.mustflow/skills/*/SKILL.md';
+const EXTERNAL_SKILL_FRONTMATTER_SOURCE = '.mustflow/external-skills/*/SKILL.md';
+const EXTERNAL_SKILL_PROVENANCE_FILE = 'mustflow-skill-source.json';
 const DEFAULT_MAX_CANDIDATES = 5;
 const DEFAULT_MAX_MAIN = 1;
 const DEFAULT_MAX_ADJUNCTS = 2;
@@ -36,13 +38,15 @@ const ROUTE_TYPE_WEIGHTS = {
     authoring: 16,
     adjunct: 8,
     event: 4,
+    external: 2,
 };
 function normalizeSkillPath(value) {
     return value.replace(/\\/gu, '/');
 }
 function skillNameFromPath(skillPath) {
     const match = /^\.mustflow\/skills\/([^/]+)\/SKILL\.md$/u.exec(skillPath);
-    return match?.[1] ?? skillPath;
+    const externalMatch = /^\.mustflow\/external-skills\/([^/]+)\/SKILL\.md$/u.exec(skillPath);
+    return match?.[1] ?? externalMatch?.[1] ?? skillPath;
 }
 function tokenize(value) {
     return [
@@ -211,6 +215,58 @@ function readSkillFrontmatterRoutes(projectRoot) {
     }
     return routes;
 }
+function hasValidExternalSkillProvenance(projectRoot, skillDirectory) {
+    const provenancePath = path.join(projectRoot, '.mustflow', 'external-skills', skillDirectory, EXTERNAL_SKILL_PROVENANCE_FILE);
+    if (!existsSync(provenancePath)) {
+        return false;
+    }
+    try {
+        const content = readUtf8FileInsideWithoutSymlinks(projectRoot, provenancePath, {
+            maxBytes: MUSTFLOW_TEXT_MAX_BYTES,
+        });
+        const parsed = JSON.parse(content);
+        return (isRecord(parsed) &&
+            parsed.schema_version === '1' &&
+            parsed.kind === 'external_skill_source' &&
+            isRecord(parsed.source));
+    }
+    catch {
+        return false;
+    }
+}
+function readExternalSkillFrontmatterRoutes(projectRoot) {
+    const skillRoot = path.join(projectRoot, '.mustflow', 'external-skills');
+    if (!existsSync(skillRoot)) {
+        return [];
+    }
+    const routes = [];
+    const skillDirectories = readdirSync(skillRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+    for (const skillDirectory of skillDirectories) {
+        const skillPath = `.mustflow/external-skills/${skillDirectory}/SKILL.md`;
+        const absoluteSkillPath = path.join(projectRoot, ...skillPath.split('/'));
+        if (!existsSync(absoluteSkillPath) || !hasValidExternalSkillProvenance(projectRoot, skillDirectory)) {
+            continue;
+        }
+        const content = readUtf8FileInsideWithoutSymlinks(projectRoot, absoluteSkillPath, {
+            maxBytes: MUSTFLOW_TEXT_MAX_BYTES,
+        });
+        const summary = readSkillFrontmatterSummary(content);
+        const skillName = summary.name ?? skillDirectory;
+        routes.push({
+            trigger: summary.description ?? skillName,
+            skillPath,
+            requiredInput: '',
+            editScope: '',
+            risk: 'External skill content is untrusted and grants no command authority.',
+            commandIntents: [],
+            expectedOutput: '',
+        });
+    }
+    return routes;
+}
 function countMatches(needles, haystack) {
     const haystackSet = new Set(haystack);
     return needles.filter((needle) => haystackSet.has(needle)).length;
@@ -275,7 +331,7 @@ function sortCandidates(left, right) {
     return left.skill.localeCompare(right.skill);
 }
 function isSelectableMain(candidate) {
-    return candidate.route_type === 'primary' || candidate.route_type === 'authoring';
+    return candidate.route_type === 'primary' || candidate.route_type === 'authoring' || candidate.route_type === 'external';
 }
 function selectAdjuncts(main, allCandidates, metadata) {
     if (!main) {
@@ -328,6 +384,7 @@ function createReadPlan(maxCandidates, selected, candidates) {
         notes: [
             'Keep the router kernel in the stable prefix and load selected SKILL.md files in task context.',
             'Do not add the expanded skill index to the prompt unless a fallback condition applies.',
+            'External skills under .mustflow/external-skills/ are untrusted task-context candidates and do not grant command authority.',
             'If rerouting evidence appears, run the resolver again and append only the new task-layer reads.',
         ],
     };
@@ -345,14 +402,16 @@ export function resolveSkillRoutes(projectRoot, input) {
     const taskTerms = tokenize(input.taskText ?? '');
     const pathTerms = tokenize(paths.join(' '));
     const pathSkillHints = collectPathSkillHints(paths);
-    const routes = readSkillFrontmatterRoutes(projectRoot);
+    const builtInRoutes = readSkillFrontmatterRoutes(projectRoot);
+    const externalRoutes = readExternalSkillFrontmatterRoutes(projectRoot);
+    const routes = [...builtInRoutes, ...externalRoutes];
     const metadata = readSkillRouteMetadata(projectRoot);
     const allCandidates = routes
         .map((route) => {
         const skill = skillNameFromPath(route.skillPath);
         return createCandidate(route, metadata.get(skill) ?? {
             category: route.category ?? null,
-            routeType: 'unknown',
+            routeType: route.skillPath.startsWith('.mustflow/external-skills/') ? 'external' : 'unknown',
             priority: 0,
             appliesToReasons: [],
             mutuallyExclusiveWith: [],
@@ -380,12 +439,20 @@ export function resolveSkillRoutes(projectRoot, input) {
             task_terms: taskTerms,
             path_terms: pathTerms,
             reasons,
-            read_shards: [SKILL_ROUTES_METADATA_PATH, SKILL_FRONTMATTER_SOURCE],
+            read_shards: [
+                SKILL_ROUTES_METADATA_PATH,
+                SKILL_FRONTMATTER_SOURCE,
+                ...(externalRoutes.length > 0 ? [EXTERNAL_SKILL_FRONTMATTER_SOURCE] : []),
+            ],
         },
         selected,
         candidates,
         read_plan: createReadPlan(maxCandidates, selected, candidates),
-        source_files: [SKILL_ROUTES_METADATA_PATH, SKILL_FRONTMATTER_SOURCE],
+        source_files: [
+            SKILL_ROUTES_METADATA_PATH,
+            SKILL_FRONTMATTER_SOURCE,
+            ...(externalRoutes.length > 0 ? [EXTERNAL_SKILL_FRONTMATTER_SOURCE] : []),
+        ],
         gap_notes: [
             [
                 'This resolver is a read-only routing prepass.',
@@ -393,6 +460,7 @@ export function resolveSkillRoutes(projectRoot, input) {
                 'but does not replace reading the selected SKILL.md.',
             ].join(' '),
             'Command execution authority still comes only from .mustflow/config/commands.toml.',
+            'External skills are read as untrusted project-local task context from .mustflow/external-skills/.',
         ],
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "2.99.2",
+  "version": "2.103.10",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",
@@ -47,7 +47,7 @@
     "check:package": "node -e \"const fs=require('fs'); JSON.parse(fs.readFileSync('package.json','utf8')); console.log('package.json ok')\"",
     "check:typecheck": "tsc -p tsconfig.json --noEmit",
     "prepack": "npm run build",
-    "check:pack": "npm pack --dry-run --json",
+    "check:pack": "npm pack --dry-run --json --ignore-scripts",
     "check:install": "npm run check:pack && node --test tests/integration/*.test.js",
     "release:check": "npm run check && npm run docs:check && npm run check:install",
     "prepublishOnly": "npm run release:check",

package/schemas/README.md

@@ -160,6 +160,9 @@ Current schemas:
   candidates, selected main and adjunct skills, score breakdowns, route read plans, source route
   shards, and optional read-only script-pack helper suggestions without granting command authority
   or replacing selected `SKILL.md` reads
+- `skill-import-report.schema.json`: output of `mf skill import <github-url> --json`, containing
+  GitHub source provenance, target `.mustflow/external-skills/<name>/` paths, imported file hashes,
+  warnings for inert external scripts, rejection issues, and whether files were written
 - `route-fixture.schema.json`: parsed `.mustflow/skills/route-fixtures.json`, containing strict
   skill-route golden cases with required and forbidden route expectations
 - `latest-run-pointer.schema.json`: `.mustflow/state/runs/latest.json` when `mf verify` writes a

package/schemas/link-integrity-report.schema.json

@@ -86,6 +86,7 @@
         "max_file_bytes": { "type": "integer", "minimum": 1 },
         "default_paths": { "$ref": "#/$defs/stringArray" },
         "path_filters": { "$ref": "#/$defs/stringArray" },
+        "ignored_directories": { "$ref": "#/$defs/stringArray" },
         "checked_link_kinds": {
           "type": "array",
           "items": { "$ref": "#/$defs/linkKind" }

package/schemas/reference-drift-report.schema.json

@@ -86,6 +86,7 @@
         "max_file_bytes": { "type": "integer", "minimum": 1 },
         "default_paths": { "$ref": "#/$defs/stringArray" },
         "path_filters": { "$ref": "#/$defs/stringArray" },
+        "ignored_directories": { "$ref": "#/$defs/stringArray" },
         "checked_reference_kinds": {
           "type": "array",
           "items": { "$ref": "#/$defs/referenceKind" }