@supen-ai/cli 0.1.6

package/dist/knowledge.js

@@ -0,0 +1,1581 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import yaml from 'yaml';
+import { computerApiPath } from './transport/computer-api.js';
+const SUPEN_LLM_ENV_KEYS = [
+    'SUPEN_LLM_TOKEN',
+    'SUPEN_LLM_API_KEY',
+    'SUPEN_LLM_GATEWAY_URL',
+    'SUPEN_LLM_BASE_URL',
+];
+function daemonBaseUrl() {
+    const explicit = (process.env.SUPEN_DAEMON_URL || process.env.SUPEN_API_URL || '').trim().replace(/\/+$/, '');
+    if (explicit)
+        return explicit;
+    return `http://127.0.0.1:${process.env.SUPEN_DAEMON_PORT || process.env.PORT || '2756'}`;
+}
+function hasCompleteSupenLlmEnv(env) {
+    return Boolean((env.SUPEN_LLM_TOKEN || env.SUPEN_LLM_API_KEY) &&
+        (env.SUPEN_LLM_GATEWAY_URL || env.SUPEN_LLM_BASE_URL));
+}
+async function readSpaceLlmEnv() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10000);
+    try {
+        const response = await fetch(`${daemonBaseUrl()}${computerApiPath('/llm-env')}`, {
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return {};
+        const parsed = await response.json();
+        if (!parsed?.available || !parsed.env || typeof parsed.env !== 'object')
+            return {};
+        const env = {};
+        for (const key of SUPEN_LLM_ENV_KEYS) {
+            const value = parsed.env[key];
+            if (typeof value === 'string' && value.trim()) {
+                env[key] = value.trim();
+            }
+        }
+        return hasCompleteSupenLlmEnv(env) ? env : {};
+    }
+    catch {
+        return {};
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function normalizeKnowledgeLlmEnv(env) {
+    const token = env.SUPEN_LLM_TOKEN || env.SUPEN_LLM_API_KEY || env.TIWATER_LLM_API_KEY || '';
+    const baseUrl = env.SUPEN_LLM_GATEWAY_URL || env.SUPEN_LLM_BASE_URL || env.TIWATER_LLM_BASE_URL || '';
+    if (!token || !baseUrl)
+        return env;
+    return {
+        ...env,
+        SUPEN_LLM_TOKEN: env.SUPEN_LLM_TOKEN || token,
+        SUPEN_LLM_API_KEY: env.SUPEN_LLM_API_KEY || token,
+        SUPEN_LLM_GATEWAY_URL: env.SUPEN_LLM_GATEWAY_URL || baseUrl,
+        SUPEN_LLM_BASE_URL: env.SUPEN_LLM_BASE_URL || baseUrl,
+        TIWATER_LLM_API_KEY: env.TIWATER_LLM_API_KEY || token,
+        TIWATER_LLM_BASE_URL: env.TIWATER_LLM_BASE_URL || baseUrl,
+        SUPEN_KNOWLEDGE_LLM_ENV_AVAILABLE: '1',
+    };
+}
+async function resolveKnowledgeRuntimeEnv(runTests) {
+    if (!runTests)
+        return process.env;
+    if (hasCompleteSupenLlmEnv(process.env))
+        return normalizeKnowledgeLlmEnv(process.env);
+    const spaceLlmEnv = await readSpaceLlmEnv();
+    if (Object.keys(spaceLlmEnv).length === 0)
+        return process.env;
+    return normalizeKnowledgeLlmEnv({
+        ...process.env,
+        ...spaceLlmEnv,
+    });
+}
+function loadScenarios(packageRoot) {
+    const scenariosRoot = path.join(packageRoot, 'scenarios');
+    return walkMarkdownFiles(scenariosRoot)
+        .filter((filePath) => !filePath.endsWith(`${path.sep}questions.md`))
+        .filter((filePath) => !filePath.endsWith(`${path.sep}status-legend.md`))
+        .map((filePath) => parseScenario(packageRoot, filePath));
+}
+function normalizeScenarioSelector(value) {
+    if (typeof value !== 'string')
+        return [];
+    const normalized = value.trim().toUpperCase();
+    if (!normalized)
+        return [];
+    if (normalized.startsWith('SC-'))
+        return [normalized, normalized.slice(3)];
+    return [normalized, `SC-${normalized}`];
+}
+function resolvePackageRoot(input) {
+    const root = path.resolve(process.cwd(), input);
+    if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+        throw new Error(`Knowledge package path is not a directory: ${root}`);
+    }
+    return root;
+}
+function expandHomePath(inputPath) {
+    if (inputPath === '~')
+        return os.homedir();
+    if (inputPath.startsWith('~/'))
+        return path.join(os.homedir(), inputPath.slice(2));
+    return path.resolve(inputPath);
+}
+function readYamlObject(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return {};
+        const parsed = yaml.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function configuredRootValue(section) {
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    const root = section.root;
+    return typeof root === 'string' && root.trim() ? root.trim() : null;
+}
+function configuredStringValue(section, key) {
+    if (!section || typeof section !== 'object' || Array.isArray(section))
+        return null;
+    const value = section[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function resolveCliSpaceRoot() {
+    const explicit = process.env.SPACE_DIR || process.env.SPACES_DIR;
+    return explicit ? expandHomePath(explicit) : supenHomeDir();
+}
+function resolveConfiguredRoot(configured, baseRoot) {
+    if (configured === '~' || configured.startsWith('~/') || path.isAbsolute(configured)) {
+        return expandHomePath(configured);
+    }
+    return path.resolve(baseRoot, configured);
+}
+function readLocalSpaceConfig() {
+    const root = resolveCliSpaceRoot();
+    const candidates = [
+        { configPath: path.join(root, 'space.yaml'), baseRoot: root },
+        { configPath: path.join(root, 'space', 'config.yaml'), baseRoot: path.join(root, 'space') },
+    ];
+    for (const candidate of candidates) {
+        const config = readYamlObject(candidate.configPath);
+        if (Object.keys(config).length > 0)
+            return { config, baseRoot: candidate.baseRoot };
+    }
+    return { config: {}, baseRoot: root };
+}
+function resolveMountedKnowledgeRoots() {
+    const { config, baseRoot } = readLocalSpaceConfig();
+    const knowledge = config.knowledge;
+    const configuredRoots = knowledge && typeof knowledge === 'object' && !Array.isArray(knowledge)
+        ? knowledge.roots
+        : null;
+    if (Array.isArray(configuredRoots)) {
+        const roots = configuredRoots.flatMap((entry) => {
+            const id = configuredStringValue(entry, 'id');
+            const configured = configuredRootValue(entry);
+            if (!id || !configured)
+                return [];
+            return [{ id, root: resolveConfiguredRoot(configured, baseRoot) }];
+        });
+        if (roots.length > 0)
+            return roots;
+    }
+    return [{
+            id: 'default',
+            root: path.join(resolveCliSpaceRoot(), 'knowledge'),
+        }];
+}
+function readPluginName(pluginRoot) {
+    const manifestPath = path.join(pluginRoot, 'plugin.json');
+    try {
+        if (!fs.existsSync(manifestPath))
+            return null;
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        return typeof manifest.name === 'string' && manifest.name.trim() ? manifest.name.trim() : path.basename(pluginRoot);
+    }
+    catch {
+        return path.basename(pluginRoot);
+    }
+}
+function mountedPluginTargets() {
+    const targets = [];
+    for (const knowledgeRoot of resolveMountedKnowledgeRoots()) {
+        const pluginsRoot = path.join(knowledgeRoot.root, 'plugins');
+        if (!fs.existsSync(pluginsRoot) || !fs.statSync(pluginsRoot).isDirectory())
+            continue;
+        for (const entry of fs.readdirSync(pluginsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            const pluginRoot = path.join(pluginsRoot, entry.name);
+            const pluginName = readPluginName(pluginRoot);
+            if (!pluginName)
+                continue;
+            targets.push({
+                input: pluginName,
+                pluginName,
+                packageRoot: knowledgeRoot.root,
+                pluginRoot,
+                resolvedFrom: 'mounted-plugin',
+            });
+        }
+    }
+    return targets.sort((left, right) => (left.pluginName || '').localeCompare(right.pluginName || ''));
+}
+function resolvePluginTarget(input) {
+    const asPath = path.resolve(process.cwd(), input);
+    if (fs.existsSync(asPath) && fs.statSync(asPath).isDirectory()) {
+        const manifestName = readPluginName(asPath);
+        if (manifestName) {
+            const parent = path.dirname(asPath);
+            return {
+                input,
+                pluginName: manifestName,
+                packageRoot: path.basename(parent) === 'plugins' ? path.dirname(parent) : asPath,
+                pluginRoot: asPath,
+                resolvedFrom: 'path',
+            };
+        }
+        return { input, packageRoot: resolvePackageRoot(input), resolvedFrom: 'path' };
+    }
+    const matches = mountedPluginTargets().filter((target) => target.pluginName === input || path.basename(target.pluginRoot || '') === input);
+    if (matches.length === 1)
+        return { ...matches[0], input };
+    if (matches.length > 1) {
+        throw new Error(`Plugin name is ambiguous: ${input}. Matching roots: ${matches.map((target) => target.pluginRoot).join(', ')}`);
+    }
+    throw new Error(`Plugin is not mounted and path does not exist: ${input}`);
+}
+function resolveDefaultPluginTarget() {
+    const targets = mountedPluginTargets();
+    if (targets.length === 1)
+        return { ...targets[0], input: targets[0].pluginName || '' };
+    if (targets.length === 0) {
+        throw new Error('No mounted plugins found. Mount a knowledge root with plugins/<name>/plugin.json or pass a plugin/path explicitly.');
+    }
+    throw new Error(`Multiple plugins are mounted. Specify one: ${targets.map((target) => target.pluginName).filter(Boolean).map((name) => `supen verify ${name}`).join(', ')}`);
+}
+function resolveOptionalPluginTarget(input) {
+    return input && input.trim() ? resolvePluginTarget(input.trim()) : resolveDefaultPluginTarget();
+}
+function pluginNameFromRoot(pluginRoot) {
+    return pluginRoot ? path.basename(pluginRoot) : undefined;
+}
+function exists(filePath) {
+    return fs.existsSync(filePath);
+}
+function readText(filePath) {
+    return fs.readFileSync(filePath, 'utf8');
+}
+function relativeToPackage(packageRoot, filePath) {
+    return path.relative(packageRoot, filePath);
+}
+function walkFiles(dir) {
+    if (!exists(dir))
+        return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkFiles(entryPath));
+        }
+        else if (entry.isFile()) {
+            results.push(entryPath);
+        }
+    }
+    return results.sort((left, right) => left.localeCompare(right));
+}
+function walkMarkdownFiles(dir) {
+    return walkFiles(dir).filter((filePath) => filePath.endsWith('.md'));
+}
+function parseFrontmatter(raw) {
+    if (!raw.startsWith('---\n'))
+        return {};
+    const end = raw.indexOf('\n---', 4);
+    if (end < 0)
+        return {};
+    const data = {};
+    for (const line of raw.slice(4, end).split(/\r?\n/)) {
+        const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
+        if (match)
+            data[match[1]] = match[2];
+    }
+    return data;
+}
+function frontmatterBlock(raw) {
+    if (!raw.startsWith('---\n'))
+        return '';
+    const end = raw.indexOf('\n---', 4);
+    if (end < 0)
+        return '';
+    return raw.slice(4, end);
+}
+function parseFrontmatterList(raw, key) {
+    const block = frontmatterBlock(raw);
+    const lines = block.split(/\r?\n/);
+    const values = [];
+    let inList = false;
+    const keyPattern = new RegExp(`^\\s{2}${key}:\\s*$`);
+    const topLevelPattern = /^\s{0,2}[A-Za-z0-9_-]+:/;
+    for (const line of lines) {
+        if (keyPattern.test(line)) {
+            inList = true;
+            continue;
+        }
+        if (inList && topLevelPattern.test(line) && !line.trim().startsWith('-'))
+            break;
+        if (inList) {
+            const match = line.match(/^\s{4}-\s+(.+?)\s*$/);
+            if (match)
+                values.push(match[1].trim());
+        }
+    }
+    return values;
+}
+function parseSections(raw) {
+    const sections = new Map();
+    const lines = raw.split(/\r?\n/);
+    let current = null;
+    let bucket = [];
+    function flush() {
+        if (!current)
+            return;
+        sections.set(current, bucket.join('\n').trim());
+    }
+    for (const line of lines) {
+        const heading = line.match(/^##\s+(.+?)\s*$/);
+        if (heading) {
+            flush();
+            current = heading[1].trim();
+            bucket = [];
+            continue;
+        }
+        if (current)
+            bucket.push(line);
+    }
+    flush();
+    return sections;
+}
+function sectionHasContent(sections, name) {
+    const value = sections.get(name);
+    return typeof value === 'string' && value.replace(/[-\s]/g, '').length > 0;
+}
+function parseScenario(packageRoot, filePath) {
+    const raw = readText(filePath);
+    const frontmatter = parseFrontmatter(raw);
+    return {
+        filePath,
+        relativePath: relativeToPackage(packageRoot, filePath),
+        raw,
+        frontmatter,
+        sections: parseSections(raw),
+        id: frontmatter.id || '',
+        status: frontmatter.status || '',
+    };
+}
+function finding(severity, code, target, message, extra = {}) {
+    return { severity, code, target, message, ...extra };
+}
+const REQUIRED_SCENARIO_SECTIONS = [
+    '目标 (Goal)',
+    '输入文件 (Input Files)',
+    '处理流程 (Processing Flow)',
+    '输出结果 (Output Result)',
+    '验收标准 (Acceptance Criteria)',
+];
+const READY_SCENARIO_SECTIONS = [
+    '参考示例文件 (Reference Sample Files)',
+    '注意点 (Points of Attention)',
+];
+const READY_STATUSES = new Set(['1-Data-Ready', '2-Clarified', '3-Developing']);
+const INFRASTRUCTURE_SKILL_PATTERN = /(^|[-_])(runner|test|tests|validator)([-_]|$)/i;
+function parseUnresolvedQuestions(packageRoot) {
+    const questionsPath = path.join(packageRoot, 'scenarios', 'questions.md');
+    const unresolvedByScenario = new Map();
+    if (!exists(questionsPath))
+        return unresolvedByScenario;
+    const raw = readText(questionsPath);
+    let currentScenario = 'general';
+    let currentQuestion = null;
+    for (const line of raw.split(/\r?\n/)) {
+        const scenarioMatch = line.match(/^##\s+场景\s+\[\[.*?\|(.*?)\]\]/);
+        if (scenarioMatch) {
+            currentScenario = scenarioMatch[1].trim().toUpperCase();
+            currentQuestion = null;
+            continue;
+        }
+        if (/^##\s+通用问题/.test(line)) {
+            currentScenario = 'general';
+            currentQuestion = null;
+            continue;
+        }
+        const questionMatch = line.match(/^-\s+\*\*\[(Q\d+)\]\s+(.+?)\*\*/);
+        if (questionMatch) {
+            currentQuestion = {
+                id: questionMatch[1],
+                text: questionMatch[2],
+                scenario: currentScenario,
+                status: '',
+            };
+            continue;
+        }
+        const statusMatch = line.match(/状态\*\*:\s*(.+?)\s*$/);
+        if (statusMatch && currentQuestion) {
+            currentQuestion.status = statusMatch[1].trim();
+            if (!currentQuestion.status.includes('🟢')) {
+                const issue = finding('error', 'scenario.unresolved_questions', relativeToPackage(packageRoot, questionsPath), `Scenario ${currentQuestion.scenario} has unresolved clarification question ${currentQuestion.id}: ${currentQuestion.text}.`, { questions: [currentQuestion] });
+                const list = unresolvedByScenario.get(currentQuestion.scenario) || [];
+                list.push(issue);
+                unresolvedByScenario.set(currentQuestion.scenario, list);
+            }
+        }
+    }
+    return unresolvedByScenario;
+}
+function collectBuiltInScenarioFindings(packageRoot, scenarios) {
+    const findings = [];
+    const unresolvedByScenario = parseUnresolvedQuestions(packageRoot);
+    for (const scenario of scenarios) {
+        if (!scenario.id) {
+            findings.push(finding('error', 'scenario.missing_id', scenario.relativePath, 'Scenario frontmatter is missing `id`.'));
+        }
+        if (!scenario.status) {
+            findings.push(finding('error', 'scenario.missing_status', scenario.relativePath, 'Scenario frontmatter is missing `status`.'));
+        }
+        for (const section of REQUIRED_SCENARIO_SECTIONS) {
+            if (!sectionHasContent(scenario.sections, section)) {
+                findings.push(finding('error', 'scenario.missing_section', scenario.relativePath, `Scenario is missing required section content: ${section}.`));
+            }
+        }
+        if (READY_STATUSES.has(scenario.status)) {
+            for (const section of READY_SCENARIO_SECTIONS) {
+                if (!sectionHasContent(scenario.sections, section)) {
+                    findings.push(finding('error', 'scenario.ready_missing_section', scenario.relativePath, `Ready scenario is missing required section content: ${section}.`));
+                }
+            }
+            const samplesSection = scenario.sections.get('参考示例文件 (Reference Sample Files)') || '';
+            if (!samplesSection.includes('samples/')) {
+                findings.push(finding('warn', 'scenario.no_sample_links', scenario.relativePath, 'Ready scenario does not link any `samples/` fixtures.'));
+            }
+        }
+        const scenarioSlug = scenario.id.replace(/^SC-/, '').toUpperCase();
+        for (const unresolved of unresolvedByScenario.get(scenarioSlug) || []) {
+            findings.push({
+                ...unresolved,
+                severity: READY_STATUSES.has(scenario.status) ? 'error' : 'warn',
+                target: scenario.relativePath,
+            });
+        }
+    }
+    return findings;
+}
+function isPathInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function collectBuiltInPluginFindings(packageRoot, scenarios, targetPluginName) {
+    const findings = [];
+    const pluginsRoot = path.join(packageRoot, 'plugins');
+    if (!exists(pluginsRoot)) {
+        findings.push(finding('error', 'package.missing_plugins_dir', 'plugins', 'Knowledge package has no plugins directory.'));
+        return findings;
+    }
+    for (const filePath of walkFiles(pluginsRoot)) {
+        if (path.basename(filePath) === '.DS_Store') {
+            findings.push(finding('warn', 'package.os_metadata_file', relativeToPackage(packageRoot, filePath), 'Plugin package contains macOS metadata that should not be distributed.'));
+        }
+    }
+    const scenarioIds = new Set(scenarios.map((scenario) => scenario.id).filter(Boolean));
+    const contractScenarioIds = new Map();
+    const pluginDirs = fs.readdirSync(pluginsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .filter((entry) => !targetPluginName || entry.name === targetPluginName)
+        .map((entry) => path.join(pluginsRoot, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+    if (targetPluginName && pluginDirs.length === 0) {
+        findings.push(finding('error', 'plugin.not_found', path.join('plugins', targetPluginName), `Mounted plugin ${targetPluginName} was not found under plugins/.`));
+        return findings;
+    }
+    for (const pluginRoot of pluginDirs) {
+        const pluginName = path.basename(pluginRoot);
+        const manifestPath = path.join(pluginRoot, 'plugin.json');
+        if (!exists(manifestPath)) {
+            findings.push(finding('error', 'plugin.missing_manifest', relativeToPackage(packageRoot, manifestPath), 'Plugin manifest is missing.'));
+            continue;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(readText(manifestPath));
+        }
+        catch (error) {
+            findings.push(finding('error', 'plugin.invalid_manifest_json', relativeToPackage(packageRoot, manifestPath), `Plugin manifest is not valid JSON: ${error.message}.`));
+            continue;
+        }
+        const pluginCommands = new Map();
+        if (!Array.isArray(manifest.commands)) {
+            findings.push(finding('warn', 'plugin.missing_commands', relativeToPackage(packageRoot, manifestPath), 'Plugin has no plugin-level `commands` declaration.'));
+        }
+        else {
+            for (const [index, command] of manifest.commands.entries()) {
+                const target = `${relativeToPackage(packageRoot, manifestPath)}#commands[${index}]`;
+                if (!command?.command || typeof command.command !== 'string') {
+                    findings.push(finding('error', 'plugin.command_missing_name', target, 'Plugin command entry is missing `command`.'));
+                    continue;
+                }
+                if (pluginCommands.has(command.command)) {
+                    findings.push(finding('error', 'plugin.duplicate_command', target, `Plugin command ${command.command} is declared more than once.`));
+                }
+                pluginCommands.set(command.command, target);
+                if (!command.description) {
+                    findings.push(finding('warn', 'plugin.command_missing_description', target, `Plugin command ${command.command} is missing a description.`));
+                }
+                if (!command.handler || typeof command.handler !== 'string') {
+                    findings.push(finding('error', 'plugin.command_missing_handler', target, `Plugin command ${command.command} is missing a handler path.`));
+                    continue;
+                }
+                const handlerPath = path.resolve(pluginRoot, command.handler);
+                if (!isPathInside(pluginRoot, handlerPath)) {
+                    findings.push(finding('error', 'plugin.command_handler_outside_plugin', target, `Plugin command ${command.command} handler points outside the plugin package.`));
+                }
+                else if (!exists(handlerPath)) {
+                    findings.push(finding('error', 'plugin.command_handler_missing', relativeToPackage(packageRoot, handlerPath), `Plugin command ${command.command} handler file is missing.`));
+                }
+                else if (readText(handlerPath).trim().length === 0) {
+                    findings.push(finding('error', 'plugin.command_handler_empty', relativeToPackage(packageRoot, handlerPath), `Plugin command ${command.command} handler file is empty.`));
+                }
+            }
+        }
+        const skillsRoot = path.join(pluginRoot, 'skills');
+        const skillNames = exists(skillsRoot)
+            ? fs.readdirSync(skillsRoot, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+                .sort()
+            : [];
+        const infraSkillNames = new Set(skillNames.filter((skillName) => INFRASTRUCTURE_SKILL_PATTERN.test(skillName)));
+        if (manifest.skills === './skills/' && infraSkillNames.size > 0) {
+            findings.push(finding('error', 'plugin.skills_glob_includes_infrastructure', relativeToPackage(packageRoot, manifestPath), '`skills: ./skills/` installs plugin infrastructure directories as end-user skills.'));
+        }
+        for (const skillName of infraSkillNames) {
+            const skillPath = path.join(skillsRoot, skillName, 'SKILL.md');
+            findings.push(finding('error', 'plugin.command_as_skill', relativeToPackage(packageRoot, skillPath), `${skillName} is plugin infrastructure and should not be installed as a scenario skill.`));
+        }
+        for (const commandFile of walkMarkdownFiles(skillsRoot).filter((filePath) => filePath.includes(`${path.sep}commands${path.sep}`))) {
+            const frontmatter = parseFrontmatter(readText(commandFile));
+            const commandName = frontmatter.command;
+            if (!commandName) {
+                findings.push(finding('warn', 'skill_command.missing_command_name', relativeToPackage(packageRoot, commandFile), 'Skill-level command file is missing command frontmatter.'));
+                continue;
+            }
+            if (pluginCommands.has(commandName)) {
+                findings.push(finding('error', 'plugin.command_shadowed_by_skill_command', relativeToPackage(packageRoot, commandFile), `Skill-level command ${commandName} duplicates a plugin-level command. Move the command to plugin.json and remove the skill command.`));
+            }
+        }
+        const mcpConfigPath = path.join(pluginRoot, '.mcp.json');
+        const mcpServerIds = new Set();
+        if (exists(mcpConfigPath)) {
+            try {
+                const mcpConfig = JSON.parse(readText(mcpConfigPath));
+                for (const serverId of Object.keys(mcpConfig.mcpServers || {}))
+                    mcpServerIds.add(serverId);
+            }
+            catch (error) {
+                findings.push(finding('error', 'plugin.invalid_mcp_json', relativeToPackage(packageRoot, mcpConfigPath), `MCP config is not valid JSON: ${error.message}.`));
+            }
+        }
+        for (const skillName of skillNames) {
+            if (infraSkillNames.has(skillName))
+                continue;
+            const skillPath = path.join(skillsRoot, skillName, 'SKILL.md');
+            if (!exists(skillPath)) {
+                findings.push(finding('error', 'skill.missing_skill_md', path.join('plugins', pluginName, 'skills', skillName), `Scenario skill ${skillName} is missing SKILL.md.`));
+                continue;
+            }
+            const skillRaw = readText(skillPath);
+            const skillFrontmatter = parseFrontmatter(skillRaw);
+            if (skillFrontmatter.name && skillFrontmatter.name !== skillName) {
+                findings.push(finding('warn', 'skill.name_mismatch', relativeToPackage(packageRoot, skillPath), `Skill frontmatter name ${skillFrontmatter.name} does not match directory name ${skillName}.`));
+            }
+            if (!skillRaw.includes('## How to test')) {
+                findings.push(finding('warn', 'skill.missing_how_to_test', relativeToPackage(packageRoot, skillPath), 'Scenario skill is missing a `How to test` section.'));
+            }
+            for (const serverId of parseFrontmatterList(skillRaw, 'mcp_servers')) {
+                if (mcpServerIds.size > 0 && !mcpServerIds.has(serverId)) {
+                    findings.push(finding('error', 'plugin.missing_mcp_server_for_skill', relativeToPackage(packageRoot, skillPath), `Skill references MCP server ${serverId}, but ${relativeToPackage(packageRoot, mcpConfigPath)} does not declare it.`));
+                }
+            }
+            const contractPath = path.join(skillsRoot, skillName, 'scenario.contract.json');
+            if (!exists(contractPath)) {
+                findings.push(finding('warn', 'skill.missing_contract', path.join('plugins', pluginName, 'skills', skillName), `Scenario skill ${skillName} is missing scenario.contract.json.`));
+                continue;
+            }
+            let contract;
+            try {
+                contract = JSON.parse(readText(contractPath));
+            }
+            catch (error) {
+                findings.push(finding('error', 'skill.invalid_contract_json', relativeToPackage(packageRoot, contractPath), `Scenario contract is not valid JSON: ${error.message}.`));
+                continue;
+            }
+            if (!contract.contract_version) {
+                findings.push(finding('error', 'skill.contract_missing_version', relativeToPackage(packageRoot, contractPath), 'Scenario contract is missing `contract_version`.'));
+            }
+            if (contract.scenario_id) {
+                const existing = contractScenarioIds.get(contract.scenario_id) || [];
+                existing.push(`${pluginName}/${skillName}`);
+                contractScenarioIds.set(contract.scenario_id, existing);
+            }
+            if (!scenarioIds.has(contract.scenario_id)) {
+                findings.push(finding('error', 'skill.contract_without_scenario', relativeToPackage(packageRoot, contractPath), `Contract references ${contract.scenario_id}, but no matching scenario markdown was found.`));
+            }
+            const metadataScenarioId = skillRaw.match(/^\s{2}scenario_id:\s*(SC-[A-Z0-9]+)\s*$/m)?.[1];
+            if (metadataScenarioId && contract.scenario_id && metadataScenarioId !== contract.scenario_id) {
+                findings.push(finding('error', 'skill.contract_metadata_mismatch', relativeToPackage(packageRoot, contractPath), `Contract scenario ${contract.scenario_id} does not match SKILL metadata ${metadataScenarioId}.`));
+            }
+            if (contract.scenario_doc && !exists(path.resolve(path.dirname(contractPath), contract.scenario_doc))) {
+                findings.push(finding('error', 'skill.contract_scenario_doc_missing', relativeToPackage(packageRoot, contractPath), `Scenario contract points to missing scenario_doc: ${contract.scenario_doc}.`));
+            }
+            if (!Array.isArray(contract.sample_inputs) || contract.sample_inputs.length === 0) {
+                findings.push(finding('warn', 'skill.contract_missing_sample_inputs', relativeToPackage(packageRoot, contractPath), 'Scenario contract does not declare sample_inputs.'));
+            }
+            else {
+                for (const [index, sample] of contract.sample_inputs.entries()) {
+                    if (!sample.path) {
+                        findings.push(finding('error', 'skill.contract_sample_missing_path', `${relativeToPackage(packageRoot, contractPath)}#sample_inputs[${index}]`, 'Sample input is missing `path`.'));
+                        continue;
+                    }
+                    if (sample.required !== false && !exists(path.resolve(path.dirname(contractPath), sample.path))) {
+                        findings.push(finding('error', 'skill.contract_required_sample_missing', relativeToPackage(packageRoot, path.resolve(path.dirname(contractPath), sample.path)), `Required sample input is missing for ${skillName}.`));
+                    }
+                }
+            }
+            if (!Array.isArray(contract.expected_outputs) || contract.expected_outputs.length === 0) {
+                findings.push(finding('error', 'skill.contract_missing_expected_outputs', relativeToPackage(packageRoot, contractPath), 'Scenario contract does not declare expected_outputs.'));
+            }
+            else {
+                for (const [index, output] of contract.expected_outputs.entries()) {
+                    if (!output.path) {
+                        findings.push(finding('error', 'skill.contract_output_missing_path', `${relativeToPackage(packageRoot, contractPath)}#expected_outputs[${index}]`, 'Expected output is missing `path`.'));
+                    }
+                    if (!output.kind) {
+                        findings.push(finding('warn', 'skill.contract_output_missing_kind', `${relativeToPackage(packageRoot, contractPath)}#expected_outputs[${index}]`, 'Expected output is missing `kind`.'));
+                    }
+                }
+            }
+            if (contract.validation?.prompt_file && !exists(path.resolve(path.dirname(contractPath), contract.validation.prompt_file))) {
+                findings.push(finding('error', 'skill.contract_validation_prompt_missing', relativeToPackage(packageRoot, path.resolve(path.dirname(contractPath), contract.validation.prompt_file)), `Validation prompt is missing for ${skillName}.`));
+            }
+        }
+    }
+    for (const [scenarioId, skills] of contractScenarioIds.entries()) {
+        if (skills.length > 1) {
+            findings.push(finding('warn', 'scenario.multiple_skill_contracts', 'plugins', `Scenario ${scenarioId} is implemented by multiple skills: ${skills.join(', ')}.`));
+        }
+    }
+    for (const scenario of scenarios) {
+        if (READY_STATUSES.has(scenario.status) && !contractScenarioIds.has(scenario.id)) {
+            findings.push(finding('error', 'scenario.ready_missing_skill_contract', scenario.relativePath, `Ready scenario ${scenario.id} has no scenario skill contract.`));
+        }
+    }
+    return findings;
+}
+function runBuiltInAssessment(packageRoot, context) {
+    const findings = [];
+    if (!exists(path.join(packageRoot, 'AGENTS.md'))) {
+        findings.push(finding('error', 'package.missing_agents_md', 'AGENTS.md', 'Knowledge package is missing AGENTS.md guidance for agents and consumers.'));
+    }
+    const scenarios = loadScenarios(packageRoot);
+    if (scenarios.length === 0) {
+        findings.push(finding('warn', 'package.no_scenarios', 'scenarios', 'Knowledge package has no scenario markdown files.'));
+    }
+    findings.push(...collectBuiltInScenarioFindings(packageRoot, scenarios));
+    findings.push(...collectBuiltInPluginFindings(packageRoot, scenarios, pluginNameFromRoot(context.target?.pluginRoot)));
+    const summary = {
+        packageRoot,
+        scenarioCount: scenarios.length,
+        findings: findingCounts(findings),
+    };
+    const parsed = { summary, findings };
+    return {
+        name: 'supen:builtin-knowledge-package-assessment',
+        command: [...context.command, relativeToPackage(process.cwd(), packageRoot)],
+        cwd: process.cwd(),
+        exitCode: findings.some((item) => item.severity === 'error') ? 1 : 0,
+        stdout: `${JSON.stringify(parsed, null, 2)}\n`,
+        stderr: '',
+        parsed,
+    };
+}
+function validatorCoverageCategory(code) {
+    if (code.startsWith('scenario.'))
+        return 'scenario-readiness';
+    if (code.startsWith('plugin.command') || code === 'plugin.skills_glob_includes_infrastructure')
+        return 'plugin-command-surface';
+    if (code.startsWith('skill.contract') || code === 'skill.missing_contract' || code === 'scenario.ready_missing_skill_contract')
+        return 'skill-contracts';
+    if (code.startsWith('package.'))
+        return 'package-hygiene';
+    if (code.startsWith('plugin.missing_mcp') || code.startsWith('plugin.invalid_mcp'))
+        return 'plugin-runtime-declarations';
+    return null;
+}
+function collectValidatorCoverageFindings(packageRoot, builtInRun, packageRuns) {
+    const findings = [];
+    const builtInFindings = builtInRun.parsed?.findings || [];
+    if (packageRuns.length === 0) {
+        return [
+            finding('warn', 'validator.missing_package_validator', 'plugins/*/tests/validate-package.mjs', 'No package-owned validators were found. Supen can assess the package, but the knowledge package cannot repeat the checks on its own.'),
+        ];
+    }
+    const packageFindingCodes = new Set(packageRuns.flatMap((run) => run.parsed?.findings || []).map((item) => item.code));
+    const categoryFindings = new Map();
+    for (const item of builtInFindings) {
+        const category = validatorCoverageCategory(item.code);
+        if (!category)
+            continue;
+        const list = categoryFindings.get(category) || [];
+        list.push(item);
+        categoryFindings.set(category, list);
+    }
+    for (const [category, categoryItems] of categoryFindings.entries()) {
+        const missedCodes = [...new Set(categoryItems.map((item) => item.code).filter((code) => !packageFindingCodes.has(code)))].sort();
+        if (missedCodes.length > 0) {
+            const missedItems = categoryItems.filter((item) => missedCodes.includes(item.code));
+            findings.push(finding('warn', 'validator.coverage_gap', 'plugins/*/tests/validate-package.mjs', `Package validators missed Supen-detected ${category} finding code(s): ${missedCodes.join(', ')}.`, {
+                category,
+                missedCodes,
+                missedTargets: missedItems.slice(0, 10).map((item) => item.target),
+            }));
+        }
+    }
+    const parsedFailures = packageRuns.filter((run) => run.stdout.trim() && !run.parsed);
+    for (const run of parsedFailures) {
+        findings.push(finding('warn', 'validator.non_json_output', run.name, 'Package validator produced stdout, but Supen could not parse it as structured JSON findings.'));
+    }
+    return findings;
+}
+function discoverValidators(packageRoot, targetPluginName) {
+    const pluginsRoot = path.join(packageRoot, 'plugins');
+    if (!fs.existsSync(pluginsRoot) || !fs.statSync(pluginsRoot).isDirectory()) {
+        return [];
+    }
+    return fs.readdirSync(pluginsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .filter((entry) => !targetPluginName || entry.name === targetPluginName)
+        .map((entry) => path.join(pluginsRoot, entry.name, 'tests', 'validate-package.mjs'))
+        .filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile())
+        .sort((left, right) => left.localeCompare(right));
+}
+function parseValidatorJson(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function runValidator(packageRoot, validatorPath, env) {
+    const relative = path.relative(packageRoot, validatorPath);
+    const result = spawnSync(process.execPath, [validatorPath], {
+        cwd: packageRoot,
+        encoding: 'utf8',
+        env,
+        maxBuffer: 20 * 1024 * 1024,
+    });
+    return {
+        name: relative,
+        command: [process.execPath, relative],
+        cwd: packageRoot,
+        exitCode: result.status ?? 1,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        parsed: parseValidatorJson(result.stdout || ''),
+    };
+}
+function discoverTestSuites(packageRoot, targetPluginName) {
+    const pluginsRoot = path.join(packageRoot, 'plugins');
+    if (!exists(pluginsRoot))
+        return [];
+    const searchRoot = targetPluginName ? path.join(pluginsRoot, targetPluginName) : pluginsRoot;
+    if (!exists(searchRoot))
+        return [];
+    return walkFiles(searchRoot)
+        .filter((filePath) => path.basename(filePath) === 'run-suite.mjs')
+        .filter((filePath) => {
+        const parts = filePath.split(path.sep);
+        const parent = parts.at(-2) || '';
+        const grandparent = parts.at(-3) || '';
+        return parent === 'tests' || (parent === 'scripts' && /test/i.test(grandparent));
+    })
+        .sort((left, right) => left.localeCompare(right));
+}
+function targetFromSkillName(packageRoot, skillsRoot, skillName) {
+    if (typeof skillName !== 'string')
+        return 'tests';
+    if (typeof skillsRoot === 'string') {
+        const skillPath = path.join(skillsRoot, skillName, 'SKILL.md');
+        if (isPathInside(packageRoot, skillPath)) {
+            return relativeToPackage(packageRoot, skillPath);
+        }
+    }
+    return `plugins/*/skills/${skillName}/SKILL.md`;
+}
+function collectReportedOutputs(record) {
+    const outputs = new Set();
+    const visit = (value) => {
+        if (!value)
+            return;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (typeof value === 'object') {
+            if (Array.isArray(value.outputs)) {
+                for (const output of value.outputs) {
+                    if (typeof output === 'string')
+                        outputs.add(output);
+                }
+            }
+            for (const nested of Object.values(value))
+                visit(nested);
+            return;
+        }
+    };
+    visit(record);
+    return [...outputs].sort((left, right) => left.localeCompare(right));
+}
+function resolveReportedOutput(packageRoot, outputPath) {
+    if (outputPath.includes('$'))
+        return null;
+    return path.isAbsolute(outputPath) ? outputPath : path.resolve(packageRoot, outputPath);
+}
+function validateReportedOutput(outputPath) {
+    if (!exists(outputPath))
+        return [`missing: ${outputPath}`];
+    const stats = fs.statSync(outputPath);
+    if (!stats.isFile())
+        return [`not a file: ${outputPath}`];
+    if (stats.size === 0)
+        return [`empty file: ${outputPath}`];
+    const extension = path.extname(outputPath).toLowerCase();
+    if (extension === '.json') {
+        try {
+            const raw = readText(outputPath);
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed) && parsed.length === 0)
+                return [`empty JSON array: ${outputPath}`];
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && Object.keys(parsed).length === 0) {
+                return [`empty JSON object: ${outputPath}`];
+            }
+        }
+        catch (error) {
+            return [`invalid JSON: ${outputPath}: ${error.message}`];
+        }
+    }
+    if (extension === '.docx' || extension === '.xlsx') {
+        const header = fs.readFileSync(outputPath, { flag: 'r' }).subarray(0, 2);
+        if (header[0] !== 0x50 || header[1] !== 0x4b) {
+            return [`invalid ${extension.slice(1).toUpperCase()} ZIP header: ${outputPath}`];
+        }
+    }
+    if (extension === '.pdf') {
+        const header = fs.readFileSync(outputPath, { flag: 'r' }).subarray(0, 4).toString('utf8');
+        if (header !== '%PDF')
+            return [`invalid PDF header: ${outputPath}`];
+    }
+    if (extension === '.md' && readText(outputPath).trim().length === 0) {
+        return [`empty Markdown file: ${outputPath}`];
+    }
+    return [];
+}
+function findingsFromTestSuite(packageRoot, runnerName, parsed) {
+    if (!parsed) {
+        return [finding('error', 'test.non_json_output', runnerName, 'Test suite did not emit structured JSON output.')];
+    }
+    const findings = [];
+    const results = Array.isArray(parsed.results) ? parsed.results : [];
+    const resultsByScenario = new Map();
+    if (results.length === 0) {
+        findings.push(finding('warn', 'test.no_results', runnerName, 'Test suite emitted no test results.'));
+    }
+    for (const result of results) {
+        if (!result || typeof result !== 'object')
+            continue;
+        const record = result;
+        for (const scenarioId of Array.isArray(record.scenarioIds) ? record.scenarioIds : []) {
+            for (const selector of normalizeScenarioSelector(scenarioId)) {
+                const list = resultsByScenario.get(selector) || [];
+                list.push(record);
+                resultsByScenario.set(selector, list);
+            }
+        }
+        const target = targetFromSkillName(packageRoot, parsed.skillsRoot, record.skillName);
+        if (record.finalStatus === 'failed') {
+            const failedParts = ['test', 'smoke', 'fixtureE2E', 'qaReview']
+                .map((key) => record[key])
+                .filter((entry) => entry && entry.status && !['passed', 'manual-review', 'not-automated'].includes(entry.status));
+            findings.push(finding('error', 'test.failed', target, `Test failed for ${record.skillName}: ${failedParts.map((entry) => entry.reason).filter(Boolean).join('; ') || 'no reason reported'}.`, { runner: runnerName, result: record }));
+        }
+        else if (record.finalStatus === 'blocked') {
+            const blockedParts = ['test', 'smoke', 'fixtureE2E', 'qaReview']
+                .map((key) => record[key])
+                .filter((entry) => entry && entry.status === 'blocked');
+            findings.push(finding('error', 'test.blocked_prerequisite', target, `Test for ${record.skillName} is blocked by a missing prerequisite: ${blockedParts.map((entry) => entry.reason).filter(Boolean).join('; ') || 'no blocker reported'}.`, { runner: runnerName, result: record }));
+        }
+        else if (record.finalStatus === 'incomplete') {
+            findings.push(finding('error', 'test.incomplete', target, `Test suite did not fully evaluate ${record.skillName}; declared expectations remain not automated or manual-only.`, { runner: runnerName, result: record }));
+        }
+        else if (record.finalStatus === 'passed') {
+            const outputPaths = collectReportedOutputs(record)
+                .map((outputPath) => resolveReportedOutput(packageRoot, outputPath))
+                .filter((outputPath) => typeof outputPath === 'string');
+            if (outputPaths.length === 0) {
+                findings.push(finding('error', 'test.no_verifiable_outputs', target, `Test passed for ${record.skillName}, but reported no concrete output artifacts for Supen to verify.`, { runner: runnerName, result: record }));
+            }
+            const outputIssues = outputPaths.flatMap(validateReportedOutput);
+            if (outputIssues.length > 0) {
+                findings.push(finding('error', 'test.output_invalid', target, `Test passed for ${record.skillName}, but Supen could not verify reported output artifacts: ${outputIssues.join('; ')}.`, { runner: runnerName, outputIssues, result: record }));
+            }
+        }
+        else {
+            findings.push(finding('error', 'test.unknown_status', target, `Test result for ${record.skillName} did not report a recognized finalStatus.`, { runner: runnerName, result: record }));
+        }
+    }
+    for (const scenario of loadScenarios(packageRoot)) {
+        if (!READY_STATUSES.has(scenario.status))
+            continue;
+        const scenarioResults = resultsByScenario.get(scenario.id) || [];
+        if (scenarioResults.length === 0) {
+            findings.push(finding('error', 'test.missing_scenario_result', scenario.relativePath, `Ready scenario ${scenario.id} is a test todo item, but no test result was reported for it.`, { runner: runnerName, scenarioId: scenario.id }));
+            continue;
+        }
+        if (!scenarioResults.some((record) => record.finalStatus === 'passed')) {
+            findings.push(finding('error', 'test.scenario_not_passed', scenario.relativePath, `Ready scenario ${scenario.id} is a test todo item, but no reported test passed for it.`, { runner: runnerName, scenarioId: scenario.id, results: scenarioResults }));
+        }
+    }
+    return findings;
+}
+function missingTestSuiteRun(packageRoot, context) {
+    const parsed = {
+        summary: {},
+        findings: [
+            finding('error', 'test.missing_runner', 'plugins', 'No package test suite runner was discovered. Supen cannot prove skill behavior without executable tests.'),
+        ],
+    };
+    return {
+        name: 'supen:test-suite-discovery',
+        command: [...context.command, relativeToPackage(process.cwd(), packageRoot), '--run-tests'],
+        cwd: process.cwd(),
+        exitCode: 1,
+        stdout: `${JSON.stringify(parsed, null, 2)}\n`,
+        stderr: '',
+        parsed,
+    };
+}
+function knowledgeTestTimeoutMs(explicit) {
+    if (explicit && Number.isFinite(explicit) && explicit > 0)
+        return explicit;
+    const fromEnv = Number.parseInt(process.env.SUPEN_KNOWLEDGE_TEST_TIMEOUT_MS || '', 10);
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    return 10 * 60 * 1000;
+}
+function runTestSuite(packageRoot, testSuitePath, env, timeoutMs) {
+    const relative = path.relative(packageRoot, testSuitePath);
+    const timeout = knowledgeTestTimeoutMs(timeoutMs);
+    const result = spawnSync(process.execPath, [testSuitePath, 'all'], {
+        cwd: packageRoot,
+        encoding: 'utf8',
+        env,
+        timeout,
+        maxBuffer: 50 * 1024 * 1024,
+    });
+    const parsedRaw = parseValidatorJson(result.stdout || '');
+    if (result.error && result.error.code === 'ETIMEDOUT' && !parsedRaw) {
+        const parsed = {
+            summary: {},
+            findings: [
+                finding('error', 'test.runner_timeout', relative, `Test suite exceeded the configured timeout of ${timeout}ms before producing complete structured results.`, {
+                    timeoutMs: timeout,
+                    stdout: result.stdout || '',
+                    stderr: result.stderr || '',
+                }),
+            ],
+        };
+        return {
+            name: relative,
+            command: [process.execPath, relative, 'all'],
+            cwd: packageRoot,
+            exitCode: 1,
+            stdout: `${JSON.stringify(parsed, null, 2)}\n`,
+            stderr: result.stderr || '',
+            parsed,
+        };
+    }
+    const parsed = {
+        summary: parsedRaw?.summary,
+        findings: findingsFromTestSuite(packageRoot, relative, parsedRaw),
+        ...(parsedRaw || {}),
+    };
+    return {
+        name: relative,
+        command: [process.execPath, relative, 'all'],
+        cwd: packageRoot,
+        exitCode: result.status ?? 0,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+        parsed,
+    };
+}
+function findingCounts(findings) {
+    return findings.reduce((counts, finding) => {
+        counts[finding.severity] = (counts[finding.severity] || 0) + 1;
+        return counts;
+    }, {});
+}
+function firstLine(value) {
+    return String(value || '')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) || '';
+}
+function conciseFindingMessage(finding, maxLength = 240) {
+    const result = asRecord(finding.result);
+    const test = asRecord(result?.test);
+    const rawReason = String(test?.reason || finding.message || '');
+    const reason = rawReason.includes('You must install .NET to run this application.')
+        ? 'You must install .NET to run this application.'
+        : rawReason.includes('Failed to resolve libhostfxr.so')
+            ? 'Failed to resolve libhostfxr.so; the .NET runtime is not available.'
+            : firstLine(rawReason);
+    if (!reason)
+        return finding.message;
+    return reason.length > maxLength ? `${reason.slice(0, maxLength - 1)}…` : reason;
+}
+function collectRunSuiteResults(runs) {
+    return runs.flatMap((run) => {
+        const results = Array.isArray(run.parsed?.results) ? run.parsed.results : [];
+        return results.filter((result) => !!result && typeof result === 'object' && !Array.isArray(result));
+    });
+}
+function buildRoundSummary(runs, findings, taskArtifacts) {
+    const testResults = collectRunSuiteResults(runs);
+    const testsByStatus = testResults.reduce((counts, result) => {
+        const status = typeof result.finalStatus === 'string' && result.finalStatus.trim()
+            ? result.finalStatus.trim()
+            : 'unknown';
+        counts[status] = (counts[status] || 0) + 1;
+        return counts;
+    }, {});
+    const blockedPrerequisites = Array.from(new Set(findings
+        .filter((finding) => finding.code === 'test.blocked_prerequisite')
+        .map((finding) => conciseFindingMessage(finding, 160))
+        .filter(Boolean)));
+    return {
+        validators: runs.length,
+        findings: {
+            total: findings.length,
+            bySeverity: findingCounts(findings),
+        },
+        tests: {
+            total: testResults.length,
+            byStatus: testsByStatus,
+            passed: testResults
+                .filter((result) => result.finalStatus === 'passed')
+                .map((result) => result.skillName)
+                .filter(Boolean),
+            blocked: testResults
+                .filter((result) => result.finalStatus === 'blocked')
+                .map((result) => result.skillName)
+                .filter(Boolean),
+        },
+        primaryBlockers: blockedPrerequisites.slice(0, 5),
+        artifacts: taskArtifacts
+            ? {
+                root: taskArtifacts.root,
+                files: taskArtifacts.files.length,
+            }
+            : undefined,
+    };
+}
+function uniqueFindings(findings) {
+    const seen = new Set();
+    const unique = [];
+    for (const finding of findings) {
+        const key = finding.code === 'scenario.ready_missing_section' || finding.code === 'validator.coverage_gap'
+            ? `${finding.severity}\0${finding.code}\0${finding.target}\0${finding.message}`
+            : `${finding.severity}\0${finding.code}\0${finding.target}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(finding);
+    }
+    return unique;
+}
+function recommendedAction(finding) {
+    switch (finding.code) {
+        case 'package.missing_agents_md':
+            return 'Add AGENTS.md describing the package purpose, structure, consumer expectations, and evolution rules.';
+        case 'package.os_metadata_file':
+            return 'Remove the metadata file from the package and prevent it from being committed again.';
+        case 'scenario.ready_missing_section':
+            return 'Update the scenario markdown with the missing ready-state section, or downgrade its lifecycle status until the requirement is actually ready.';
+        case 'scenario.unresolved_questions':
+            return 'Resolve or explicitly defer the linked clarification question before implementation continues.';
+        case 'scenario.no_sample_links':
+            return 'Link the concrete fixture under samples/, or mark the scenario as blocked on fixture collection.';
+        case 'plugin.command_as_skill':
+            return 'Move plugin infrastructure out of normal scenario skills and expose it through plugin-level commands or package tests.';
+        case 'plugin.command_shadowed_by_skill_command':
+            return 'Delete or migrate the stale skill-level command so the plugin-level command is the single command surface.';
+        case 'plugin.skills_glob_includes_infrastructure':
+            return 'Change plugin skill discovery so infrastructure directories are excluded from installable scenario skills.';
+        case 'plugin.missing_commands':
+            return 'Declare package operations in plugin.json commands and back them with plugin command handlers.';
+        case 'plugin.command_handler_missing':
+        case 'plugin.command_handler_empty':
+            return 'Add a real handler file for the plugin-level command and rerun command catalog validation.';
+        case 'skill.missing_contract':
+            return 'Add a scenario.contract.json for the skill or remove it from scenario-skill discovery.';
+        case 'skill.contract_required_sample_missing':
+            return 'Add the missing required fixture or mark the sample optional only if the scenario can still be validated without it.';
+        case 'skill.contract_validation_prompt_missing':
+            return 'Add the validation prompt file referenced by the contract.';
+        case 'scenario.ready_missing_skill_contract':
+            return 'Create a scenario skill contract for the ready scenario, or downgrade the scenario status until implementation is planned.';
+        case 'validator.missing_package_validator':
+            return 'Add a package-owned validator so the knowledge package can repeat Supen-discovered checks without bespoke manual review.';
+        case 'validator.coverage_gap':
+            return 'Extend the package validator to cover the missed category, then rerun Supen to prove the gap is closed.';
+        case 'validator.non_json_output':
+            return 'Emit structured JSON with summary and findings so Supen can compare validation evidence across rounds.';
+        case 'test.non_json_output':
+            return 'Update the test runner to emit structured JSON so Supen can record test evidence.';
+        case 'test.no_results':
+            return 'Update the test runner to discover and report scenario test results.';
+        case 'test.missing_scenario_result':
+            return 'Use the scenarios folder as the test todo list: add a test result for this ready scenario.';
+        case 'test.scenario_not_passed':
+            return 'Fix or complete the scenario test until this ready scenario has a passing test result.';
+        case 'test.failed':
+            return 'Fix the failing test or remove the target from test discovery until it has a valid executable test.';
+        case 'test.blocked_prerequisite':
+            return 'Install or configure the missing prerequisite, or explicitly mark the scenario blocked until the prerequisite is available.';
+        case 'test.incomplete':
+            return 'Translate the declared scenario expectations into executable checks so the test can produce a pass/fail decision.';
+        case 'test.no_verifiable_outputs':
+            return 'Report concrete output artifact paths from the test runner so Supen can independently verify them.';
+        case 'test.output_invalid':
+            return 'Fix the test or implementation so every reported output artifact exists, is non-empty, and has the expected file structure.';
+        case 'test.unknown_status':
+            return 'Update the test runner to report finalStatus as passed, failed, blocked, or incomplete for every target.';
+        case 'test.missing_runner':
+            return 'Add a package test runner that executes scenario skill tests and emits structured JSON results.';
+        case 'test.runner_timeout':
+            return 'Add per-target timeouts/progress reporting to the package test runner, or increase the timeout only after proving the long-running step is bounded.';
+        default:
+            return 'Repair the cited package surface, rerun validation, and attach before/after evidence.';
+    }
+}
+function renderKnowledgeIssueMarkdown(round) {
+    const counts = findingCounts(round.findings);
+    const lines = [
+        '# Knowledge Evolution Round',
+        '',
+        `- Package: ${round.packageRoot}`,
+        `- Created: ${round.createdAt}`,
+        `- Status: ${round.status}`,
+        `- Findings: ${round.findings.length} (${Object.entries(counts).map(([severity, count]) => `${severity}: ${count}`).join(', ') || 'none'})`,
+        '',
+        '## Validators',
+        '',
+        ...round.validators.flatMap((validator) => [
+            `- ${validator.name}`,
+            `  - Exit code: ${validator.exitCode}`,
+            `  - Command: ${validator.command.map((part) => JSON.stringify(part)).join(' ')}`,
+        ]),
+        '',
+        '## Knowledge Issues',
+        '',
+    ];
+    if (round.findings.length === 0) {
+        lines.push('No issues detected.');
+    }
+    else {
+        for (const [index, finding] of round.findings.entries()) {
+            lines.push(`### KI-${String(index + 1).padStart(3, '0')} ${finding.code}`, '', `- Severity: ${finding.severity}`, `- Target: ${finding.target}`, `- Message: ${finding.message}`, `- Recommended repair: ${recommendedAction(finding)}`, '');
+        }
+    }
+    lines.push('## Promotion Decision', '', round.status === 'pass'
+        ? 'Promote: all validators passed.'
+        : 'Reject promotion: validation produced blocking findings. Apply a repair capsule, then rerun this command.', '');
+    return `${lines.join('\n')}\n`;
+}
+function renderRepairCapsuleMarkdown(round) {
+    const grouped = new Map();
+    for (const finding of round.findings) {
+        const list = grouped.get(finding.code) || [];
+        list.push(finding);
+        grouped.set(finding.code, list);
+    }
+    const lines = [
+        '# Repair Capsule',
+        '',
+        `- Package: ${round.packageRoot}`,
+        `- Created: ${round.createdAt}`,
+        `- Validation status: ${round.status}`,
+        `- Promotion decision: ${round.status === 'pass' ? 'promote' : 'reject until repaired'}`,
+        '',
+        '## Proposed Repairs',
+        '',
+    ];
+    if (round.findings.length === 0) {
+        lines.push('No repairs proposed. Validation passed.', '');
+    }
+    else {
+        for (const [code, findings] of grouped.entries()) {
+            lines.push(`### ${code}`, '', `Affected targets: ${findings.length}`, '');
+            const sampleTargets = findings.slice(0, 8).map((finding) => `- ${finding.target}`);
+            lines.push(...sampleTargets);
+            if (findings.length > sampleTargets.length) {
+                lines.push(`- ... ${findings.length - sampleTargets.length} more`);
+            }
+            lines.push('', `Repair action: ${recommendedAction(findings[0])}`, '');
+        }
+    }
+    lines.push('## Validation Required Before Promotion', '', ...round.validators.map((validator) => `- Rerun ${validator.command.map((part) => JSON.stringify(part)).join(' ')} from ${validator.cwd}.`), '', '## Rollback Path', '', 'Do not promote partial repairs. Revert the repair diff and keep this capsule as rejected evidence if validation still reports blocking findings.', '');
+    return `${lines.join('\n')}\n`;
+}
+function defaultEvolutionRoot(packageRoot) {
+    return path.join(packageRoot, '.supen', 'evolution');
+}
+function createOutputDir(packageRoot, createdAt, outputRoot) {
+    const safeTimestamp = createdAt.replace(/[:.]/g, '-');
+    const baseDir = outputRoot
+        ? path.resolve(process.cwd(), outputRoot)
+        : defaultEvolutionRoot(packageRoot);
+    const outputDir = path.join(baseDir, safeTimestamp);
+    fs.mkdirSync(outputDir, { recursive: true });
+    return outputDir;
+}
+function writeRoundEvidence(round, outputRoot) {
+    const outputDir = createOutputDir(round.packageRoot, round.createdAt, outputRoot);
+    const withOutput = { ...round, outputDir };
+    fs.writeFileSync(path.join(outputDir, 'evidence.json'), `${JSON.stringify(withOutput, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'knowledge-issues.md'), renderKnowledgeIssueMarkdown(withOutput), 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'repair-capsule.md'), renderRepairCapsuleMarkdown(withOutput), 'utf8');
+    for (const validator of round.validators) {
+        const baseName = validator.name.replace(/[^A-Za-z0-9_.-]+/g, '_');
+        fs.writeFileSync(path.join(outputDir, `${baseName}.stdout.txt`), validator.stdout, 'utf8');
+        fs.writeFileSync(path.join(outputDir, `${baseName}.stderr.txt`), validator.stderr, 'utf8');
+    }
+    return withOutput;
+}
+function supenHomeDir() {
+    return process.env.SUPEN_HOME || path.join(os.homedir(), '.supen');
+}
+function safeTaskSegment(value, fallback) {
+    const normalized = (value || '').trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    return normalized || fallback;
+}
+function taskArtifactRoot() {
+    return path.join(supenHomeDir(), 'tasks');
+}
+function taskArtifactFolderName(createdAt, packageRoot) {
+    const packageName = path.basename(packageRoot) || 'knowledge';
+    const timestamp = createdAt.replace(/[:.]/g, '-');
+    return `task-knowledge-evolve-${safeTaskSegment(packageName, 'package')}-${timestamp}`;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function collectTestOutputArtifacts(round) {
+    const artifacts = [];
+    for (const validator of round.validators) {
+        const parsed = asRecord(validator.parsed);
+        const results = Array.isArray(parsed?.results) ? parsed.results : [];
+        for (const rawResult of results) {
+            const result = asRecord(rawResult);
+            if (!result)
+                continue;
+            const skillName = typeof result.skillName === 'string'
+                ? result.skillName
+                : safeTaskSegment(String(result.skillName || ''), 'unknown-skill');
+            const test = asRecord(result.test);
+            const outputs = Array.isArray(test?.outputs) ? test.outputs : [];
+            for (const output of outputs) {
+                if (typeof output !== 'string' || !output.trim())
+                    continue;
+                const source = path.resolve(output);
+                if (!fs.existsSync(source) || !fs.statSync(source).isFile())
+                    continue;
+                artifacts.push({ skillName, source });
+            }
+        }
+    }
+    return artifacts;
+}
+function publishTaskArtifacts(round) {
+    const outputs = collectTestOutputArtifacts(round);
+    const taskFolder = taskArtifactFolderName(round.createdAt, round.packageRoot);
+    const root = path.join(taskArtifactRoot(), taskFolder);
+    fs.mkdirSync(root, { recursive: true });
+    const files = [];
+    for (const output of outputs) {
+        const skillSegment = safeTaskSegment(output.skillName, 'unknown-skill');
+        const targetDir = path.join(root, skillSegment);
+        fs.mkdirSync(targetDir, { recursive: true });
+        const target = path.join(targetDir, path.basename(output.source));
+        fs.copyFileSync(output.source, target);
+        const relative = path.relative(root, target);
+        files.push({
+            skillName: output.skillName,
+            source: output.source,
+            path: relative,
+            size: fs.statSync(target).size,
+        });
+    }
+    const published = { root, taskFolder, files };
+    const withArtifacts = { ...round, taskArtifacts: published };
+    fs.writeFileSync(path.join(root, 'artifact-index.json'), `${JSON.stringify(published, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(root, 'evidence.json'), `${JSON.stringify(withArtifacts, null, 2)}\n`, 'utf8');
+    fs.writeFileSync(path.join(root, 'knowledge-issues.md'), renderKnowledgeIssueMarkdown(withArtifacts), 'utf8');
+    fs.writeFileSync(path.join(root, 'repair-capsule.md'), renderRepairCapsuleMarkdown(withArtifacts), 'utf8');
+    const logsRoot = path.join(root, 'logs');
+    fs.mkdirSync(logsRoot, { recursive: true });
+    for (const validator of round.validators) {
+        const baseName = validator.name.replace(/[^A-Za-z0-9_.-]+/g, '_');
+        fs.writeFileSync(path.join(logsRoot, `${baseName}.stdout.txt`), validator.stdout, 'utf8');
+        fs.writeFileSync(path.join(logsRoot, `${baseName}.stderr.txt`), validator.stderr, 'utf8');
+    }
+    return withArtifacts;
+}
+async function runEvolution(packagePath, options) {
+    const target = options.target;
+    const packageRoot = target?.packageRoot || resolvePackageRoot(packagePath);
+    const context = {
+        command: options.command || ['supen', 'knowledge', 'evolve'],
+        title: options.title || 'Knowledge evolution round',
+        subjectLabel: options.subjectLabel || 'Package',
+        target,
+    };
+    const runtimeEnv = await resolveKnowledgeRuntimeEnv(options.runTests);
+    const testTimeoutMs = options.testTimeoutMs ? Number.parseInt(options.testTimeoutMs, 10) : undefined;
+    const targetPluginName = pluginNameFromRoot(target?.pluginRoot);
+    const packageValidators = discoverValidators(packageRoot, targetPluginName);
+    const builtInRun = runBuiltInAssessment(packageRoot, context);
+    const packageRuns = packageValidators.map((validatorPath) => runValidator(packageRoot, validatorPath, runtimeEnv));
+    const testSuitePaths = options.runTests ? discoverTestSuites(packageRoot, targetPluginName) : [];
+    const validatorCoverageRun = {
+        name: 'supen:validator-coverage-assessment',
+        command: [...context.command, relativeToPackage(process.cwd(), packageRoot)],
+        cwd: process.cwd(),
+        exitCode: 0,
+        stdout: '',
+        stderr: '',
+        parsed: {
+            summary: {},
+            findings: collectValidatorCoverageFindings(packageRoot, builtInRun, packageRuns),
+        },
+    };
+    validatorCoverageRun.exitCode = (validatorCoverageRun.parsed?.findings || []).some((item) => item.severity === 'error') ? 1 : 0;
+    validatorCoverageRun.stdout = `${JSON.stringify(validatorCoverageRun.parsed, null, 2)}\n`;
+    const runs = [
+        builtInRun,
+        ...packageRuns,
+        validatorCoverageRun,
+        ...(options.runTests
+            ? (testSuitePaths.length > 0
+                ? testSuitePaths.map((testSuitePath) => runTestSuite(packageRoot, testSuitePath, runtimeEnv, testTimeoutMs))
+                : [missingTestSuiteRun(packageRoot, context)])
+            : []),
+    ];
+    const findings = uniqueFindings(runs.flatMap((run) => run.parsed?.findings || []));
+    const status = runs.every((run) => run.exitCode === 0) && findings.every((finding) => finding.severity !== 'error')
+        ? 'pass'
+        : 'fail';
+    let round = {
+        packageRoot,
+        createdAt: new Date().toISOString(),
+        status,
+        validators: runs,
+        findings,
+    };
+    if (options.runTests && options.publishTaskArtifacts !== false) {
+        round = publishTaskArtifacts(round);
+    }
+    round = {
+        ...round,
+        summary: buildRoundSummary(runs, findings, round.taskArtifacts),
+    };
+    if (round.taskArtifacts) {
+        fs.writeFileSync(path.join(round.taskArtifacts.root, 'evidence.json'), `${JSON.stringify(round, null, 2)}\n`, 'utf8');
+        fs.writeFileSync(path.join(round.taskArtifacts.root, 'knowledge-issues.md'), renderKnowledgeIssueMarkdown(round), 'utf8');
+        fs.writeFileSync(path.join(round.taskArtifacts.root, 'repair-capsule.md'), renderRepairCapsuleMarkdown(round), 'utf8');
+    }
+    if (options.write !== false) {
+        round = writeRoundEvidence(round, options.output);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(round, null, 2));
+        if (status === 'fail')
+            process.exitCode = 1;
+        return;
+    }
+    const counts = findingCounts(findings);
+    const testSummary = asRecord(round.summary?.tests);
+    const testsByStatus = asRecord(testSummary?.byStatus);
+    console.log(`\n${context.title}\n`);
+    console.log(`  ${context.subjectLabel}: ${target?.pluginName || packageRoot}`);
+    if (target?.pluginRoot) {
+        console.log(`  Plugin dir: ${target.pluginRoot}`);
+        console.log(`  Root:       ${packageRoot}`);
+    }
+    console.log(`  Status:     ${status}`);
+    console.log(`  Validators: ${runs.length}`);
+    console.log(`  Findings:   ${findings.length} (${Object.entries(counts).map(([severity, count]) => `${severity}: ${count}`).join(', ') || 'none'})`);
+    if (testSummary && Object.keys(testsByStatus || {}).length > 0) {
+        console.log(`  Tests:      ${Object.entries(testsByStatus || {}).map(([testStatus, count]) => `${count} ${testStatus}`).join(', ')}`);
+    }
+    if (round.outputDir) {
+        console.log(`  Evidence:   ${round.outputDir}`);
+    }
+    if (round.taskArtifacts) {
+        console.log(`  Task files: ${round.taskArtifacts.root}`);
+    }
+    const primaryBlockers = Array.isArray(round.summary?.primaryBlockers) ? round.summary.primaryBlockers.filter(Boolean) : [];
+    if (primaryBlockers.length > 0) {
+        console.log('\nPrimary blockers\n');
+        for (const blocker of primaryBlockers) {
+            console.log(`  - ${blocker}`);
+        }
+    }
+    const blocking = findings.filter((finding) => finding.severity === 'error').slice(0, 8);
+    if (blocking.length > 0) {
+        console.log('\nBlocking issues\n');
+        for (const finding of blocking) {
+            console.log(`  - [${finding.code}] ${finding.target}`);
+            console.log(`    ${conciseFindingMessage(finding)}`);
+            console.log(`    ${recommendedAction(finding)}`);
+        }
+    }
+    if (round.taskArtifacts) {
+        console.log('\nEvidence files\n');
+        console.log(`  - ${path.join(round.taskArtifacts.root, 'evidence.json')}`);
+        console.log(`  - ${path.join(round.taskArtifacts.root, 'knowledge-issues.md')}`);
+        console.log(`  - ${path.join(round.taskArtifacts.root, 'repair-capsule.md')}`);
+    }
+    console.log('');
+    if (status === 'fail')
+        process.exitCode = 1;
+}
+function handleCliError(err, json) {
+    if (json) {
+        console.log(JSON.stringify({ error: err?.message || String(err) }));
+    }
+    else {
+        console.error(`\n  Error: ${err?.message || String(err)}\n`);
+    }
+    process.exit(1);
+}
+async function runPluginVerify(targetInput, options, command = ['supen', 'plugin', 'verify']) {
+    const target = resolveOptionalPluginTarget(targetInput);
+    await runEvolution(target.packageRoot, {
+        json: options.json,
+        write: false,
+        runTests: true,
+        testTimeoutMs: options.testTimeoutMs,
+        publishTaskArtifacts: true,
+        target,
+        command,
+        title: 'Plugin verification round',
+        subjectLabel: 'Plugin',
+    });
+}
+async function runKnowledgeEvolve(focusInput, options, command = ['supen', 'evolve']) {
+    const focusTarget = focusInput && focusInput.trim() ? resolvePluginTarget(focusInput.trim()) : resolveDefaultPluginTarget();
+    await runEvolution(focusTarget.packageRoot, {
+        ...options,
+        target: focusInput && focusInput.trim() ? focusTarget : undefined,
+        command,
+        title: 'Knowledge evolution round',
+        subjectLabel: 'Knowledge root',
+    });
+}
+export function registerVerifyEvolveCommands(program) {
+    program
+        .command('verify [plugin]')
+        .description('Verify the current mounted plugin, or a specified plugin/path')
+        .option('--json', 'Output the full verification evidence as JSON')
+        .option('--test-timeout-ms <ms>', 'Timeout for each discovered plugin test suite (default: 600000 or SUPEN_KNOWLEDGE_TEST_TIMEOUT_MS)')
+        .action(async (plugin, options) => {
+        try {
+            await runPluginVerify(plugin, options, ['supen', 'verify']);
+        }
+        catch (err) {
+            handleCliError(err, options.json);
+        }
+    });
+    program
+        .command('evolve [focus]')
+        .description('Evolve the current mounted knowledge context, optionally focused on a plugin/path')
+        .option('--json', 'Output the full evolution evidence as JSON')
+        .option('--no-write', 'Do not write evidence files into the knowledge root')
+        .option('--output <dir>', 'Directory for evolution evidence (default: .supen/evolution under the knowledge root)')
+        .option('--run-tests', 'Run discovered plugin test suites and include results as evolution evidence')
+        .option('--test-timeout-ms <ms>', 'Timeout for each discovered plugin test suite (default: 600000 or SUPEN_KNOWLEDGE_TEST_TIMEOUT_MS)')
+        .option('--no-publish-task-artifacts', 'Do not copy generated test outputs into Files / Tasks')
+        .action(async (plugin, options) => {
+        try {
+            await runKnowledgeEvolve(plugin, options, ['supen', 'evolve']);
+        }
+        catch (err) {
+            handleCliError(err, options.json);
+        }
+    });
+}
+export function registerPluginCommand(program) {
+    const command = program
+        .command('plugin')
+        .description('Inspect and verify mounted Supen plugins');
+    command
+        .command('list')
+        .description('List mounted plugins Supen can verify')
+        .option('--json', 'Output mounted plugins as JSON')
+        .action((options) => {
+        const plugins = mountedPluginTargets().map((target) => ({
+            name: target.pluginName,
+            root: target.pluginRoot,
+            knowledgeRoot: target.packageRoot,
+            sourceMode: target.resolvedFrom,
+        }));
+        if (options.json) {
+            console.log(JSON.stringify({ plugins }, null, 2));
+            return;
+        }
+        if (plugins.length === 0) {
+            console.log('\n  No mounted plugins found.\n');
+            return;
+        }
+        console.log('\nMounted plugins\n');
+        for (const plugin of plugins) {
+            console.log(`  - ${plugin.name}`);
+            console.log(`    Root: ${plugin.root}`);
+        }
+        console.log('');
+    });
+    command
+        .command('verify <plugin>')
+        .description('Verify a mounted plugin by running validators, scenario tests, and artifact checks')
+        .option('--json', 'Output the full verification evidence as JSON')
+        .option('--test-timeout-ms <ms>', 'Timeout for each discovered plugin test suite (default: 600000 or SUPEN_KNOWLEDGE_TEST_TIMEOUT_MS)')
+        .action(async (plugin, options) => {
+        try {
+            await runPluginVerify(plugin, options);
+        }
+        catch (err) {
+            handleCliError(err, options.json);
+        }
+    });
+}
+//# sourceMappingURL=knowledge.js.map