mustflow 2.22.4 → 2.22.9

package/dist/cli/lib/local-index/workflow-documents.js

@@ -0,0 +1,204 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { listFilesRecursive, toPosixPath } from '../filesystem.js';
+import { readMustflowTextFile } from '../mustflow-read.js';
+import { MAX_SNIPPET_BYTES_PER_DOCUMENT } from './constants.js';
+import { sha256Text } from './hashing.js';
+export function getExistingIndexablePaths(projectRoot) {
+    const paths = new Set();
+    const addIfExists = (relativePath) => {
+        if (existsSync(path.join(projectRoot, ...relativePath.split('/')))) {
+            paths.add(relativePath);
+        }
+    };
+    addIfExists('AGENTS.md');
+    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'docs'))) {
+        if (relativePath.endsWith('.md')) {
+            paths.add(toPosixPath(path.join('.mustflow', 'docs', relativePath)));
+        }
+    }
+    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'context'))) {
+        if (relativePath.endsWith('.md')) {
+            paths.add(toPosixPath(path.join('.mustflow', 'context', relativePath)));
+        }
+    }
+    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'skills'))) {
+        if (relativePath === 'INDEX.md' || relativePath.endsWith('/SKILL.md')) {
+            paths.add(toPosixPath(path.join('.mustflow', 'skills', relativePath)));
+        }
+    }
+    for (const relativePath of listFilesRecursive(path.join(projectRoot, '.mustflow', 'config'))) {
+        if (relativePath.endsWith('.toml')) {
+            paths.add(toPosixPath(path.join('.mustflow', 'config', relativePath)));
+        }
+    }
+    return Array.from(paths).sort((left, right) => left.localeCompare(right));
+}
+export function readText(projectRoot, relativePath) {
+    return readMustflowTextFile(projectRoot, relativePath);
+}
+function getDocumentType(relativePath) {
+    if (relativePath === 'AGENTS.md') {
+        return 'agent_rules';
+    }
+    if (relativePath.startsWith('.mustflow/config/')) {
+        return 'config';
+    }
+    if (relativePath === '.mustflow/skills/INDEX.md') {
+        return 'skill_index';
+    }
+    if (relativePath === '.mustflow/context/INDEX.md') {
+        return 'context_index';
+    }
+    if (relativePath.startsWith('.mustflow/context/')) {
+        return 'context';
+    }
+    if (relativePath.endsWith('/SKILL.md')) {
+        return 'skill';
+    }
+    if (relativePath.startsWith('.mustflow/docs/')) {
+        return 'workflow_doc';
+    }
+    return 'document';
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith('---')) {
+        return {};
+    }
+    const end = content.indexOf('\n---', 3);
+    if (end === -1) {
+        return {};
+    }
+    const result = {};
+    const rawFrontmatter = content.slice(3, end);
+    for (const line of rawFrontmatter.split(/\r?\n/)) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        if (key.length > 0 && value.length > 0) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function getTitle(relativePath, content) {
+    const heading = content.match(/^#\s+(.+)$/mu)?.[1]?.trim();
+    return heading && heading.length > 0 ? heading : path.posix.basename(relativePath);
+}
+function getSections(content) {
+    return [...content.matchAll(/^##\s+(.+)$/gmu)].map((match) => match[1]?.trim()).filter((value) => Boolean(value));
+}
+function truncateUtf8(value, maxBytes) {
+    const buffer = Buffer.from(value, 'utf8');
+    if (buffer.byteLength <= maxBytes) {
+        return value;
+    }
+    return buffer.subarray(0, maxBytes).toString('utf8').replace(/\uFFFD$/u, '');
+}
+export function collectDocumentsFromPaths(projectRoot, relativePaths) {
+    return relativePaths.map((relativePath) => {
+        const content = readText(projectRoot, relativePath);
+        const frontmatter = parseFrontmatter(content);
+        const revision = Number.parseInt(frontmatter.revision ?? '', 10);
+        return {
+            path: relativePath,
+            type: getDocumentType(relativePath),
+            title: getTitle(relativePath, content),
+            locale: frontmatter.locale ?? null,
+            revision: Number.isInteger(revision) ? revision : null,
+            contentHash: sha256Text(content),
+            contentSnippet: truncateUtf8(content, MAX_SNIPPET_BYTES_PER_DOCUMENT),
+            sections: getSections(content),
+        };
+    });
+}
+export function collectDocuments(projectRoot) {
+    return collectDocumentsFromPaths(projectRoot, getExistingIndexablePaths(projectRoot));
+}
+export function collectSkills(documents) {
+    return documents
+        .filter((document) => document.type === 'skill')
+        .map((document) => ({
+        name: document.path.split('/').at(-2) ?? document.title,
+        path: document.path,
+        title: document.title,
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function normalizeMarkdownCell(value) {
+    return value
+        .replace(/<br\s*\/?>/giu, ' ')
+        .replace(/`([^`]+)`/gu, '$1')
+        .replace(/\s+/gu, ' ')
+        .trim();
+}
+function parseMarkdownTableRow(line) {
+    return line
+        .trim()
+        .replace(/^\|/u, '')
+        .replace(/\|$/u, '')
+        .split('|')
+        .map((cell) => normalizeMarkdownCell(cell));
+}
+function isMarkdownSeparatorRow(cells) {
+    return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/u.test(cell));
+}
+function skillNameFromPath(skillPath) {
+    return skillPath.split('/').at(-2) ?? path.posix.basename(skillPath, '.md');
+}
+export function splitVerificationIntents(value) {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .sort((left, right) => left.localeCompare(right));
+}
+export function skillRouteKey(route) {
+    return `${route.skillName}\u0000${route.trigger}`;
+}
+export function collectSkillRoutes(projectRoot) {
+    const indexPath = path.join(projectRoot, '.mustflow', 'skills', 'INDEX.md');
+    if (!existsSync(indexPath)) {
+        return [];
+    }
+    const content = readMustflowTextFile(projectRoot, '.mustflow/skills/INDEX.md');
+    const routes = [];
+    let inRouteTable = false;
+    for (const line of content.split(/\r?\n/u)) {
+        if (!line.trim().startsWith('|')) {
+            if (inRouteTable && line.trim() === '') {
+                inRouteTable = false;
+            }
+            continue;
+        }
+        const cells = parseMarkdownTableRow(line);
+        if (cells.includes('Skill Document') && cells.includes('Trigger')) {
+            inRouteTable = true;
+            continue;
+        }
+        if (!inRouteTable || isMarkdownSeparatorRow(cells) || cells.length < 7) {
+            continue;
+        }
+        const [trigger, skillPath, requiredInput, editScope, risk, verificationIntents, expectedOutput] = cells;
+        if (!skillPath?.startsWith('.mustflow/skills/') || !skillPath.endsWith('/SKILL.md')) {
+            continue;
+        }
+        routes.push({
+            skillName: skillNameFromPath(skillPath),
+            skillPath,
+            trigger: trigger ?? '',
+            requiredInput: requiredInput ?? '',
+            editScope: editScope ?? '',
+            risk: risk ?? '',
+            verificationIntents: splitVerificationIntents(verificationIntents ?? ''),
+            expectedOutput: expectedOutput ?? '',
+        });
+    }
+    return routes.sort((left, right) => {
+        const skillOrder = left.skillName.localeCompare(right.skillName);
+        return skillOrder === 0 ? left.trigger.localeCompare(right.trigger) : skillOrder;
+    });
+}

package/dist/cli/lib/mustflow-read.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { readUtf8FileInsideWithoutSymlinks } from './filesystem.js';
+export const MUSTFLOW_TEXT_MAX_BYTES = 1024 * 1024;
+export const MUSTFLOW_TOML_MAX_BYTES = 256 * 1024;
+export const MUSTFLOW_JSON_MAX_BYTES = 1024 * 1024;
+export function mustflowProjectPath(projectRoot, relativePath) {
+    return path.join(projectRoot, ...relativePath.split('/'));
+}
+function missingPath(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+export function readMustflowTextFile(projectRoot, relativePath, options = {}) {
+    return readUtf8FileInsideWithoutSymlinks(projectRoot, mustflowProjectPath(projectRoot, relativePath), { maxBytes: options.maxBytes ?? MUSTFLOW_TEXT_MAX_BYTES });
+}
+export function readMustflowTextFileResult(projectRoot, relativePath, options = {}) {
+    const filePath = mustflowProjectPath(projectRoot, relativePath);
+    if (!existsSync(filePath)) {
+        return { ok: false, exists: false, error: null };
+    }
+    try {
+        return {
+            ok: true,
+            content: readMustflowTextFile(projectRoot, relativePath, options),
+        };
+    }
+    catch (error) {
+        if (missingPath(error)) {
+            return { ok: false, exists: false, error: null };
+        }
+        return {
+            ok: false,
+            exists: true,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function readMustflowTextFileIfExists(projectRoot, relativePath, options = {}) {
+    const result = readMustflowTextFileResult(projectRoot, relativePath, options);
+    return result.ok ? result.content : null;
+}

package/dist/cli/lib/project-root.js

@@ -2,8 +2,7 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 function hasMustflowMarker(directoryPath) {
     return (existsSync(path.join(directoryPath, '.mustflow', 'config', 'mustflow.toml')) ||
-        existsSync(path.join(directoryPath, '.mustflow', 'config', 'commands.toml')) ||
-        existsSync(path.join(directoryPath, '.mustflow')));
+        existsSync(path.join(directoryPath, '.mustflow', 'config', 'commands.toml')));
 }
 export function findMustflowRoot(startPath = process.cwd()) {
     let current = path.resolve(startPath);

package/dist/cli/lib/repo-map.js

@@ -4,7 +4,7 @@ import { existsSync, lstatSync, readdirSync, realpathSync, statSync } from 'node
 import path from 'node:path';
 import { toPosixPath } from './filesystem.js';
 import { writeUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
-import { readTomlFile } from './toml.js';
+import { readMustflowTomlFile } from './toml.js';
 const DEFAULT_DEPTH = 3;
 const REPO_MAP_DOC_ID = 'repo-map';
 const REPO_MAP_LIFECYCLE = 'generated';
@@ -214,7 +214,7 @@ function readMustflowConfig(projectRoot) {
         return {};
     }
     try {
-        const parsed = readTomlFile(configPath);
+        const parsed = readMustflowTomlFile(projectRoot, '.mustflow/config/mustflow.toml');
         return isRecord(parsed) ? parsed : {};
     }
     catch {
@@ -243,7 +243,19 @@ function getRepoMapConfig(projectRoot) {
         },
     };
 }
-export function listGitFilesForRepoMap(projectRoot, options = {}) {
+function classifyGitLsFilesFailure(result) {
+    const errorRecord = result.error;
+    const errorCode = typeof errorRecord?.code === 'string' ? errorRecord.code : undefined;
+    const errorMessage = result.error?.message ?? '';
+    if (errorCode === 'ETIMEDOUT' || /timed?\s*out|ETIMEDOUT/iu.test(errorMessage)) {
+        return 'timeout';
+    }
+    if (errorCode === 'ENOBUFS' || /maxBuffer|ENOBUFS|buffer/iu.test(errorMessage)) {
+        return 'max_buffer';
+    }
+    return 'error';
+}
+export function discoverGitFilesForRepoMap(projectRoot, options = {}) {
     const spawnGit = options.spawnGit ??
         ((command, args, spawnOptions) => spawnSync(command, [...args], spawnOptions));
     const result = spawnGit('git', ['ls-files', '-z'], {
@@ -254,12 +266,21 @@ export function listGitFilesForRepoMap(projectRoot, options = {}) {
         windowsHide: true,
     });
     if (result.status !== 0 || result.error) {
-        return [];
+        return {
+            files: [],
+            status: classifyGitLsFilesFailure(result),
+        };
     }
-    return result.stdout
-        .split('\0')
-        .map((line) => toPosixPath(line))
-        .filter(Boolean);
+    return {
+        files: result.stdout
+            .split('\0')
+            .map((line) => toPosixPath(line))
+            .filter(Boolean),
+        status: 'ok',
+    };
+}
+export function listGitFilesForRepoMap(projectRoot, options = {}) {
+    return discoverGitFilesForRepoMap(projectRoot, options).files;
 }
 function isAnchorCandidatePath(relativePath, priorityPaths) {
     return priorityPaths.has(relativePath) || Boolean(getAnchorDescription(relativePath));
@@ -290,13 +311,17 @@ function listAnchorCandidateFilesRecursive(rootPath, depth, priorityPaths) {
 }
 function getRepositoryFiles(projectRoot, depth, priorityPaths) {
     const files = new Set();
-    for (const relativePath of listGitFilesForRepoMap(projectRoot)) {
+    const gitFiles = discoverGitFilesForRepoMap(projectRoot);
+    for (const relativePath of gitFiles.files) {
         files.add(relativePath);
     }
     for (const relativePath of listAnchorCandidateFilesRecursive(projectRoot, depth, priorityPaths)) {
         files.add(relativePath);
     }
-    return Array.from(files);
+    return {
+        files: Array.from(files),
+        gitLsFilesStatus: gitFiles.status,
+    };
 }
 function shouldIncludePath(relativePath) {
     if (GENERATED_FILES.has(relativePath)) {
@@ -341,7 +366,8 @@ function isUnderExcludedPrefix(relativePath, excludedPrefixes) {
     return excludedPrefixes.some((prefix) => relativePath === prefix.slice(0, -1) || relativePath.startsWith(prefix));
 }
 function discoverAnchors(projectRoot, depth, priorityPaths, nestedRepositories, excludedPrefixes) {
-    return getRepositoryFiles(projectRoot, depth, priorityPaths)
+    const repositoryFiles = getRepositoryFiles(projectRoot, depth, priorityPaths);
+    const anchors = repositoryFiles.files
         .filter(shouldIncludePath)
         .filter((relativePath) => !isUnderNestedRepository(relativePath, nestedRepositories))
         .filter((relativePath) => !isUnderExcludedPrefix(relativePath, excludedPrefixes))
@@ -352,6 +378,10 @@ function discoverAnchors(projectRoot, depth, priorityPaths, nestedRepositories,
         .filter((anchor) => Boolean(anchor))
         .filter((anchor) => priorityPaths.has(anchor.relativePath) || getDirectoryDepth(anchor.relativePath) <= depth)
         .sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    return {
+        anchors,
+        gitLsFilesStatus: repositoryFiles.gitLsFilesStatus,
+    };
 }
 function renderAnchorList(anchors) {
     return anchors.map((anchor) => `- \`${anchor.relativePath}\`: ${anchor.description}`);
@@ -594,10 +624,11 @@ function countNestedEntrypoints(repository) {
         ...repository.editingPolicies,
     ].filter(Boolean).length;
 }
-function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, anchors, nestedRepositories) {
+function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, gitLsFilesStatus, anchors, nestedRepositories) {
     const payload = {
         depth,
         includeNested,
+        gitLsFilesStatus,
         priorityPaths: [...configuredPriorityPaths].sort(),
         anchors: anchors.map((anchor) => anchor.relativePath).sort(),
         nestedRepositories: nestedRepositories
@@ -621,7 +652,8 @@ function getSourceFingerprint(depth, includeNested, configuredPriorityPaths, anc
     const digest = createHash('sha256').update(JSON.stringify(payload)).digest('hex');
     return `sha256:${digest}`;
 }
-function renderRepoMapFrontmatter(anchorCount, sourceFingerprint) {
+function renderRepoMapFrontmatter(anchorCount, sourceFingerprint, gitLsFilesStatus) {
+    const degraded = gitLsFilesStatus !== 'ok';
     return [
         '---',
         `mustflow_doc: ${REPO_MAP_DOC_ID}`,
@@ -631,11 +663,25 @@ function renderRepoMapFrontmatter(anchorCount, sourceFingerprint) {
         `source_policy: ${REPO_MAP_SOURCE_POLICY}`,
         `privacy_mode: ${REPO_MAP_PRIVACY_MODE}`,
         `anchor_count: ${anchorCount}`,
+        `degraded: ${degraded ? 'true' : 'false'}`,
+        `git_ls_files_status: ${gitLsFilesStatus}`,
         `source_fingerprint: "${sourceFingerprint}"`,
         '---',
         '',
     ];
 }
+function renderSourceQuality(gitLsFilesStatus) {
+    if (gitLsFilesStatus === 'ok') {
+        return [];
+    }
+    return [
+        '## Source Quality',
+        '',
+        `- \`git ls-files\` status: \`${gitLsFilesStatus}\``,
+        '- Anchor discovery used the bounded recursive fallback. Treat this map as incomplete until regenerated after Git file discovery succeeds.',
+        '',
+    ];
+}
 export function generateRepoMap(projectRoot, options = {}) {
     const depth = options.depth ?? DEFAULT_DEPTH;
     const config = getRepoMapConfig(projectRoot);
@@ -647,15 +693,17 @@ export function generateRepoMap(projectRoot, options = {}) {
     };
     const nestedRepositories = discoverNestedRepositories(projectRoot, mapConfig, config.workspace);
     const workspaceRootPrefixes = getWorkspaceRootPrefixes(projectRoot, config.workspace);
-    const anchors = discoverAnchors(projectRoot, depth, priorityPathSet, nestedRepositories, workspaceRootPrefixes);
+    const anchorDiscovery = discoverAnchors(projectRoot, depth, priorityPathSet, nestedRepositories, workspaceRootPrefixes);
+    const anchors = anchorDiscovery.anchors;
+    const gitLsFilesStatus = anchorDiscovery.gitLsFilesStatus;
     const priorityAnchors = configuredPriorityPaths
         .map((relativePath) => anchors.find((anchor) => anchor.relativePath === relativePath))
         .filter((anchor) => Boolean(anchor));
     const otherAnchors = anchors.filter((anchor) => !priorityPathSet.has(anchor.relativePath));
     const anchorCount = anchors.length + nestedRepositories.reduce((total, repository) => total + countNestedEntrypoints(repository), 0);
-    const sourceFingerprint = getSourceFingerprint(depth, mapConfig.includeNested, configuredPriorityPaths, anchors, nestedRepositories);
+    const sourceFingerprint = getSourceFingerprint(depth, mapConfig.includeNested, configuredPriorityPaths, gitLsFilesStatus, anchors, nestedRepositories);
     return [
-        ...renderRepoMapFrontmatter(anchorCount, sourceFingerprint),
+        ...renderRepoMapFrontmatter(anchorCount, sourceFingerprint, gitLsFilesStatus),
         '# REPO_MAP.md',
         '',
         'This file is an agent navigation map for the current mustflow root. It is not a full file listing.',
@@ -670,6 +718,7 @@ export function generateRepoMap(projectRoot, options = {}) {
             : []),
         '- Use `git ls-files` or your editor when you need the complete file list.',
         '',
+        ...renderSourceQuality(gitLsFilesStatus),
         '## Priority Anchors',
         '',
         ...(priorityAnchors.length > 0 ? renderAnchorList(priorityAnchors) : ['No mustflow priority anchors were found.']),

package/dist/cli/lib/run-root-trust.js

@@ -0,0 +1,27 @@
+import { MANIFEST_LOCK_RELATIVE_PATH, readManifestLock } from './manifest-lock.js';
+export const ALLOW_UNTRUSTED_ROOT_OPTION = '--allow-untrusted-root';
+export function assessRunRootTrust(projectRoot) {
+    const readResult = readManifestLock(projectRoot);
+    if (readResult.kind === 'present') {
+        return {
+            trusted: true,
+            reason: 'manifest_lock_present',
+            manifestLockPath: readResult.lockPath,
+            detail: null,
+        };
+    }
+    if (readResult.kind === 'invalid') {
+        return {
+            trusted: false,
+            reason: 'manifest_lock_invalid',
+            manifestLockPath: readResult.lockPath,
+            detail: readResult.message,
+        };
+    }
+    return {
+        trusted: false,
+        reason: 'manifest_lock_missing',
+        manifestLockPath: readResult.lockPath,
+        detail: MANIFEST_LOCK_RELATIVE_PATH,
+    };
+}

package/dist/cli/lib/templates.js

@@ -2,6 +2,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'smol-toml';
+const DEV_TEMPLATE_ROOT_ENV = 'MUSTFLOW_DEV_TEMPLATE_ROOT';
+const ALLOW_DEV_TEMPLATE_ROOT_ENV = 'MUSTFLOW_ALLOW_DEV_TEMPLATE_ROOT';
 function readStringGroup(raw, label) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         throw new Error(`Template manifest is missing table: ${label}`);
@@ -69,15 +71,124 @@ function shouldIncludeTemplatePath(relativePath, selectedSkills) {
     }
     return selectedSkills.includes(skillName);
 }
+const SKILL_INDEX_SKILL_PATH_PATTERN = /`\.mustflow\/skills\/([^/]+)\/SKILL\.md`/u;
+const SKILL_INDEX_HEADING_PATTERN = /^(#{2,3})\s+(.+?)\s*$/u;
+const SKILL_INDEX_ROUTE_CATEGORY_NAMES = [
+    'Bug and Failure',
+    'General Code Change',
+    'Tests and Regression',
+    'Documentation and Release',
+    'Security and Privacy',
+    'Data and External Systems',
+    'UI and Assets',
+    'Architecture Patterns',
+    'Workflow and Contract Maintenance',
+];
+function skillNameFromSkillIndexLine(line) {
+    return SKILL_INDEX_SKILL_PATH_PATTERN.exec(line)?.[1];
+}
+function parseMarkdownTableCells(line) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith('|') || !trimmedLine.endsWith('|')) {
+        return undefined;
+    }
+    return trimmedLine
+        .slice(1, -1)
+        .split('|')
+        .map((cell) => cell.trim());
+}
+function isMarkdownTableDivider(cells) {
+    return cells.every((cell) => /^:?-{3,}:?$/u.test(cell));
+}
+function isMarkdownTableHeading(cells) {
+    const firstCell = cells[0] ?? '';
+    return [
+        'Category',
+        'Classification evidence',
+        'Trigger',
+    ].includes(firstCell);
+}
+function referencedSkillIndexCategories(text) {
+    return SKILL_INDEX_ROUTE_CATEGORY_NAMES.filter((categoryName) => text.includes(categoryName));
+}
+function collectSelectedSkillIndexCategories(lines, selectedSkillSet) {
+    const selectedCategories = new Set();
+    let inSpecificRoutes = false;
+    let currentCategory;
+    for (const line of lines) {
+        const heading = SKILL_INDEX_HEADING_PATTERN.exec(line);
+        if (heading) {
+            const [, level, title] = heading;
+            if (level === '##') {
+                inSpecificRoutes = title === 'Specific Routes';
+                currentCategory = undefined;
+                continue;
+            }
+            if (inSpecificRoutes && level === '###') {
+                currentCategory = title;
+            }
+        }
+        const skillName = skillNameFromSkillIndexLine(line);
+        if (inSpecificRoutes && currentCategory && skillName && selectedSkillSet.has(skillName)) {
+            selectedCategories.add(currentCategory);
+        }
+    }
+    return selectedCategories;
+}
+function shouldKeepSkillIndexTableRow(line, currentSection, selectedCategories) {
+    const cells = parseMarkdownTableCells(line);
+    if (!cells || isMarkdownTableDivider(cells) || isMarkdownTableHeading(cells)) {
+        return true;
+    }
+    if (currentSection === 'Route Category Gate') {
+        const categoryName = cells[0] ?? '';
+        return !SKILL_INDEX_ROUTE_CATEGORY_NAMES.includes(categoryName) ||
+            selectedCategories.has(categoryName);
+    }
+    if (currentSection === 'Classification Prefilter') {
+        const categoryNames = referencedSkillIndexCategories(cells.join(' '));
+        return categoryNames.length === 0 || categoryNames.some((categoryName) => selectedCategories.has(categoryName));
+    }
+    return true;
+}
 function filterSkillIndexContent(content, selectedSkills) {
     const selectedSkillSet = new Set(selectedSkills);
-    return content
-        .split(/\r?\n/u)
-        .filter((line) => {
-        const match = /`\.mustflow\/skills\/([^/]+)\/SKILL\.md`/u.exec(line);
-        return !match || selectedSkillSet.has(match[1] ?? '');
-    })
-        .join('\n');
+    const lines = content.split(/\r?\n/u);
+    const selectedCategories = collectSelectedSkillIndexCategories(lines, selectedSkillSet);
+    const filteredLines = [];
+    let currentSection;
+    let skipCurrentSpecificCategory = false;
+    for (const line of lines) {
+        const heading = SKILL_INDEX_HEADING_PATTERN.exec(line);
+        if (heading) {
+            const [, level, title] = heading;
+            if (level === '##') {
+                currentSection = title;
+                skipCurrentSpecificCategory = false;
+                filteredLines.push(line);
+                continue;
+            }
+            if (currentSection === 'Specific Routes' && level === '###') {
+                skipCurrentSpecificCategory = !selectedCategories.has(title);
+                if (!skipCurrentSpecificCategory) {
+                    filteredLines.push(line);
+                }
+                continue;
+            }
+        }
+        if (skipCurrentSpecificCategory) {
+            continue;
+        }
+        const skillName = skillNameFromSkillIndexLine(line);
+        if (skillName && !selectedSkillSet.has(skillName)) {
+            continue;
+        }
+        if (!shouldKeepSkillIndexTableRow(line, currentSection, selectedCategories)) {
+            continue;
+        }
+        filteredLines.push(line);
+    }
+    return filteredLines.join('\n').replace(/\n{3,}/gu, '\n\n');
 }
 function filterSkillRouteMetadataContent(content, selectedSkills) {
     const selectedSkillSet = new Set(selectedSkills);
@@ -166,7 +277,12 @@ function readManifest(manifestPath) {
     };
 }
 export function getDefaultTemplate() {
-    const templateRoot = path.resolve(process.env.MUSTFLOW_DEV_TEMPLATE_ROOT ?? fileURLToPath(new URL('../../../templates/default', import.meta.url)));
+    const packagedTemplateRoot = fileURLToPath(new URL('../../../templates/default', import.meta.url));
+    const templateRootOverride = process.env[DEV_TEMPLATE_ROOT_ENV];
+    const selectedTemplateRoot = templateRootOverride && process.env[ALLOW_DEV_TEMPLATE_ROOT_ENV] === '1'
+        ? templateRootOverride
+        : packagedTemplateRoot;
+    const templateRoot = path.resolve(selectedTemplateRoot);
     const manifestPath = path.join(templateRoot, 'manifest.toml');
     const manifest = readManifest(manifestPath);
     return {

package/dist/cli/lib/toml.js

@@ -1 +1,6 @@
-export { parseTomlText, readTomlFile, stringifyToml } from '../../core/toml.js';
+import { parseTomlText, readTomlFile, stringifyToml } from '../../core/toml.js';
+import { MUSTFLOW_TOML_MAX_BYTES, readMustflowTextFile } from './mustflow-read.js';
+export { parseTomlText, readTomlFile, stringifyToml };
+export function readMustflowTomlFile(projectRoot, relativePath) {
+    return parseTomlText(readMustflowTextFile(projectRoot, relativePath, { maxBytes: MUSTFLOW_TOML_MAX_BYTES }));
+}

package/dist/cli/lib/validation/constants.js

@@ -198,6 +198,8 @@ export const REPO_MAP_RELATIVE_ROOT = '.';
 export const REPO_MAP_SOURCE_POLICY = 'anchors_only';
 export const REPO_MAP_PRIVACY_MODE = 'minimal';
 export const REPO_MAP_SOURCE_FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+export const ALLOWED_REPO_MAP_DEGRADED_VALUES = new Set(['true', 'false']);
+export const ALLOWED_REPO_MAP_GIT_LS_FILES_STATUSES = new Set(['ok', 'timeout', 'max_buffer', 'error']);
 export const SKILL_RESOURCE_MANIFEST = 'resources.toml';
 export const SKILL_RESOURCE_ROOTS = new Set(['references', 'assets', 'scripts']);
 export const ALLOWED_SKILL_RESOURCE_TYPES = new Set(['reference', 'asset', 'script']);