skill-check 0.1.1 → 1.1.0

package/dist/core/agent-scan.d.ts

@@ -7,13 +7,29 @@ export interface AgentScanOptions {
     paths?: string[];
     skills?: string[];
     runner?: AgentScanRunner;
+    verbose?: boolean;
 }
 export interface AgentScanInvocation {
     command: string;
     args: string[];
 }
+export interface AgentScanRunResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+    invocation: AgentScanInvocation;
+}
+export interface AgentScanOutputSummary {
+    scannedTarget?: string;
+    skillsFound?: number;
+    findingsTotal: number;
+    findingsByCode: Record<string, number>;
+    noSkillsOrServers: boolean;
+}
+export declare function deriveAgentScanSkillRoots(skillFilePaths: string[]): string[];
 export declare function isValidAgentScanRunner(value: string): value is AgentScanRunner;
 export declare function isCommandAvailable(commandName: string): boolean;
 export declare function resolveAgentScanInvocation(options: AgentScanOptions, hasCommand?: (commandName: string) => boolean): AgentScanInvocation;
-export declare function runAgentScan(options: AgentScanOptions): number;
+export declare function summarizeAgentScanOutput(rawOutput: string): AgentScanOutputSummary;
+export declare function runAgentScan(options: AgentScanOptions): AgentScanRunResult;
 export {};

package/dist/core/agent-scan.js

@@ -3,6 +3,26 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { CliError } from './errors.js';
 const VALID_RUNNERS = ['auto', 'local', 'uvx', 'pipx'];
+export function deriveAgentScanSkillRoots(skillFilePaths) {
+    const rootCounts = new Map();
+    for (const skillFilePath of skillFilePaths) {
+        const absoluteSkillFilePath = path.resolve(skillFilePath);
+        const skillDir = path.dirname(absoluteSkillFilePath);
+        const maybeSkillsRoot = path.dirname(skillDir);
+        const selectedRoot = path.basename(maybeSkillsRoot).toLowerCase() === 'skills'
+            ? maybeSkillsRoot
+            : skillDir;
+        rootCounts.set(selectedRoot, (rootCounts.get(selectedRoot) ?? 0) + 1);
+    }
+    return Array.from(rootCounts.entries())
+        .sort((a, b) => {
+        if (b[1] !== a[1]) {
+            return b[1] - a[1];
+        }
+        return a[0].localeCompare(b[0]);
+    })
+        .map(([root]) => root);
+}
 function normalizePaths(cwd, values, fallback) {
     const list = values && values.length > 0 ? values : fallback;
     return list.map((value) => path.resolve(cwd, value));
@@ -69,11 +89,35 @@ export function resolveAgentScanInvocation(options, hasCommand = isCommandAvaila
     }
     throw new CliError('No security scan runner found. Install mcp-scan, uv, or pipx.', 2);
 }
+export function summarizeAgentScanOutput(rawOutput) {
+    const output = rawOutput.replace(/\r/g, '');
+    const scanMatch = output.match(/●\s+Scanning\s+(.+?)\s+found\s+(\d+)\s+skills?/i);
+    const codeMatches = Array.from(output.matchAll(/\[([A-Z]\d{3})\]/g)).map((match) => match[1]);
+    const findingsByCode = {};
+    for (const code of codeMatches) {
+        if (!code)
+            continue;
+        findingsByCode[code] = (findingsByCode[code] ?? 0) + 1;
+    }
+    const findingsTotal = Object.values(findingsByCode).reduce((sum, count) => sum + count, 0);
+    return {
+        scannedTarget: scanMatch?.[1]?.trim(),
+        skillsFound: scanMatch?.[2] ? Number.parseInt(scanMatch[2], 10) : undefined,
+        findingsTotal,
+        findingsByCode,
+        noSkillsOrServers: /no servers or skills found/i.test(output),
+    };
+}
 export function runAgentScan(options) {
     const invocation = resolveAgentScanInvocation(options);
-    const result = spawnSync(invocation.command, invocation.args, {
-        stdio: 'inherit',
-    });
+    const result = options.verbose
+        ? spawnSync(invocation.command, invocation.args, {
+            stdio: 'inherit',
+        })
+        : spawnSync(invocation.command, invocation.args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            encoding: 'utf8',
+        });
     const error = result.error;
     if (error?.code === 'ENOENT') {
         throw new CliError(`Runner not found: ${invocation.command}`, 2);
@@ -84,5 +128,10 @@ export function runAgentScan(options) {
     if (typeof result.status !== 'number') {
         throw new CliError('Security scan process did not return an exit code.', 2);
     }
-    return result.status;
+    return {
+        status: result.status,
+        stdout: typeof result.stdout === 'string' ? result.stdout : '',
+        stderr: typeof result.stderr === 'string' ? result.stderr : '',
+        invocation,
+    };
 }

package/dist/core/body-split.d.ts

@@ -0,0 +1,31 @@
+import type { SkillArtifact } from '../types.js';
+export interface SourceLineRange {
+    startLine: number;
+    endLine: number;
+}
+export interface SplitReferencePlan {
+    relativePath: string;
+    title: string;
+    content: string;
+    sourceLineRange: SourceLineRange;
+}
+export interface SplitPlan {
+    skillFilePath: string;
+    skillRelativePath: string;
+    beforeLineCount: number;
+    afterLineCount: number;
+    referencesToCreate: SplitReferencePlan[];
+    newSkillBody: string;
+    newSkillContent: string;
+    status: 'noop' | 'planned' | 'blocked';
+    reason?: string;
+}
+interface PlanBodySplitDeps {
+    pathExists?: (targetPath: string) => boolean;
+}
+export declare function planBodySplit(skill: SkillArtifact, maxBodyLines: number, deps?: PlanBodySplitDeps): SplitPlan;
+export declare function applyBodySplitPlan(plan: SplitPlan): {
+    updatedSkill: boolean;
+    writtenReferenceFiles: string[];
+};
+export {};

package/dist/core/body-split.js

@@ -0,0 +1,178 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+const H2_RE = /^##\s+(.+?)\s*$/;
+function countLines(text) {
+    return text.split(/\r?\n/).length;
+}
+function trimEmptyEdges(lines) {
+    let start = 0;
+    while (start < lines.length && lines[start]?.trim() === '') {
+        start += 1;
+    }
+    let end = lines.length - 1;
+    while (end >= start && lines[end]?.trim() === '') {
+        end -= 1;
+    }
+    return lines.slice(start, end + 1);
+}
+function toSlug(input) {
+    const normalized = input
+        .toLowerCase()
+        .replace(/[`*_~]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || 'section';
+}
+function normalizeLineEnding(content) {
+    return content.includes('\r\n') ? '\r\n' : '\n';
+}
+function parseSections(body) {
+    const lines = body.split(/\r?\n/);
+    const indexes = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        if (H2_RE.test(lines[i] ?? '')) {
+            indexes.push(i);
+        }
+    }
+    const sections = [];
+    for (let i = 0; i < indexes.length; i += 1) {
+        const startIndex = indexes[i] ?? 0;
+        const endIndex = (indexes[i + 1] ?? lines.length) - 1;
+        const heading = lines[startIndex] ?? '';
+        const title = heading.replace(H2_RE, '$1').trim();
+        sections.push({ title: title || 'Section', startIndex, endIndex });
+    }
+    return sections;
+}
+function buildReferenceContent(title, sectionLines, lineEnding) {
+    const trimmed = trimEmptyEdges(sectionLines);
+    if (trimmed.length === 0) {
+        return `# ${title}${lineEnding}`;
+    }
+    return `# ${title}${lineEnding}${lineEnding}${trimmed.join(lineEnding)}${lineEnding}`;
+}
+function buildNewBody(introLines, references, lineEnding) {
+    const blocks = [];
+    const intro = trimEmptyEdges(introLines).join(lineEnding);
+    if (intro) {
+        blocks.push(intro);
+    }
+    const referenceLines = [
+        '## References',
+        '',
+        'This skill content is modularized into reference docs for readability.',
+        '',
+        ...references.map((entry) => `- [${entry.title}](${entry.relativePath}) - extracted from SKILL body`),
+    ];
+    blocks.push(referenceLines.join(lineEnding));
+    return `${blocks.join(`${lineEnding}${lineEnding}`)}${lineEnding}`;
+}
+function replaceBody(content, newBody) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match) {
+        return newBody;
+    }
+    return `${match[0]}${newBody}`;
+}
+function resolveBodyStartLine(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match)
+        return 1;
+    return match[0].split(/\r?\n/).length;
+}
+function allocateReferencePath(skillDir, baseSlug, usedPaths, pathExists) {
+    let index = 1;
+    while (true) {
+        const suffix = index === 1 ? '' : `-${index}`;
+        const relativePath = path.posix.join('references', `${baseSlug}${suffix}.md`);
+        if (!usedPaths.has(relativePath)) {
+            const absolutePath = path.join(skillDir, ...relativePath.split('/'));
+            if (!pathExists(absolutePath)) {
+                usedPaths.add(relativePath);
+                return relativePath;
+            }
+        }
+        index += 1;
+    }
+}
+export function planBodySplit(skill, maxBodyLines, deps = {}) {
+    const beforeLineCount = countLines(skill.body);
+    const lineEnding = normalizeLineEnding(skill.content);
+    const noopResult = {
+        skillFilePath: skill.filePath,
+        skillRelativePath: skill.relativePath,
+        beforeLineCount,
+        afterLineCount: beforeLineCount,
+        referencesToCreate: [],
+        newSkillBody: skill.body,
+        newSkillContent: skill.content,
+        status: 'noop',
+        reason: `Body is within limit (${beforeLineCount} <= ${maxBodyLines}).`,
+    };
+    if (beforeLineCount <= maxBodyLines) {
+        return noopResult;
+    }
+    const sections = parseSections(skill.body);
+    if (sections.length === 0) {
+        return {
+            ...noopResult,
+            status: 'blocked',
+            reason: 'Add at least one ## section heading before automatic split.',
+        };
+    }
+    const pathExists = deps.pathExists ?? ((targetPath) => fs.existsSync(targetPath));
+    const skillDir = path.dirname(skill.filePath);
+    const bodyLines = skill.body.split(/\r?\n/);
+    const bodyStartLine = resolveBodyStartLine(skill.content);
+    const introLines = bodyLines.slice(0, sections[0]?.startIndex ?? 0);
+    const usedReferencePaths = new Set();
+    const referencesToCreate = sections.map((section) => {
+        const baseSlug = toSlug(section.title);
+        const relativePath = allocateReferencePath(skillDir, baseSlug, usedReferencePaths, pathExists);
+        const sectionLines = bodyLines.slice(section.startIndex + 1, section.endIndex + 1);
+        return {
+            relativePath,
+            title: section.title,
+            content: buildReferenceContent(section.title, sectionLines, lineEnding),
+            sourceLineRange: {
+                startLine: bodyStartLine + section.startIndex,
+                endLine: bodyStartLine + section.endIndex,
+            },
+        };
+    });
+    const newSkillBody = buildNewBody(introLines, referencesToCreate, lineEnding);
+    const newSkillContent = replaceBody(skill.content, newSkillBody);
+    const afterLineCount = countLines(newSkillBody);
+    return {
+        skillFilePath: skill.filePath,
+        skillRelativePath: skill.relativePath,
+        beforeLineCount,
+        afterLineCount,
+        referencesToCreate,
+        newSkillBody,
+        newSkillContent,
+        status: 'planned',
+        reason: afterLineCount > maxBodyLines
+            ? `Split completed but body still exceeds limit (${afterLineCount} > ${maxBodyLines}).`
+            : undefined,
+    };
+}
+export function applyBodySplitPlan(plan) {
+    if (plan.status !== 'planned') {
+        return { updatedSkill: false, writtenReferenceFiles: [] };
+    }
+    fs.writeFileSync(plan.skillFilePath, plan.newSkillContent, 'utf8');
+    const skillDir = path.dirname(plan.skillFilePath);
+    const writtenReferenceFiles = [];
+    for (const reference of plan.referencesToCreate) {
+        const absolutePath = path.join(skillDir, ...reference.relativePath.split('/'));
+        fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+        fs.writeFileSync(absolutePath, reference.content, 'utf8');
+        writtenReferenceFiles.push(absolutePath);
+    }
+    return {
+        updatedSkill: true,
+        writtenReferenceFiles,
+    };
+}

package/dist/core/conclusion-card.d.ts

@@ -0,0 +1,21 @@
+export type ValidationStatus = 'PASS' | 'WARN' | 'FAIL' | 'SKIPPED';
+export type SecurityStatus = 'PASS' | 'FAIL' | 'SKIPPED';
+export type ConclusionCardMode = 'default' | 'share';
+export interface ConclusionCardInput {
+    skillCount: number;
+    errorCount: number;
+    warningCount: number;
+    affectedFileCount: number;
+    overallScore: number | null;
+    validationStatus: ValidationStatus;
+    securityStatus: SecurityStatus;
+    elapsedMs: number;
+    runCommand?: string;
+    title?: string;
+    mode?: ConclusionCardMode;
+}
+export interface ConclusionCardRenderResult {
+    card: string;
+    fullCommandPlain?: string;
+}
+export declare function renderConclusionCard(input: ConclusionCardInput): ConclusionCardRenderResult;

package/dist/core/conclusion-card.js

@@ -0,0 +1,154 @@
+import pc from 'picocolors';
+const pcForced = pc.createColors(true);
+const SCORE_BAR_WIDTH = 30;
+const RUN_COMMAND_PREVIEW_LIMIT = 56;
+const SHARE_CARD_MIN_WIDTH = 74;
+function createLine(plainText, renderedText = plainText) {
+    return { plainText, renderedText };
+}
+function padLine(line, width) {
+    const trailing = ' '.repeat(Math.max(0, width - line.plainText.length));
+    return `| ${line.renderedText}${trailing} |`;
+}
+function colorizeByScore(c, score, text) {
+    if (score === null)
+        return c.dim(text);
+    if (score >= 90)
+        return c.green(text);
+    if (score >= 75)
+        return c.cyan(text);
+    if (score >= 50)
+        return c.yellow(text);
+    return c.red(text);
+}
+function scoreLabel(score) {
+    if (score === null)
+        return 'No skills';
+    if (score >= 90)
+        return 'Excellent';
+    if (score >= 75)
+        return 'Solid';
+    if (score >= 50)
+        return 'Needs work';
+    return 'Critical';
+}
+function formatElapsed(elapsedMs) {
+    if (elapsedMs < 1000) {
+        return `${Math.max(0, Math.round(elapsedMs))}ms`;
+    }
+    return `${(elapsedMs / 1000).toFixed(1)}s`;
+}
+function renderScoreBar(c, score, mode = 'default') {
+    const emptyChar = mode === 'share' ? '·' : '░';
+    if (score === null) {
+        const empty = emptyChar.repeat(SCORE_BAR_WIDTH);
+        return createLine(empty, c.dim(empty));
+    }
+    const filledCount = Math.round((score / 100) * SCORE_BAR_WIDTH);
+    const emptyCount = SCORE_BAR_WIDTH - filledCount;
+    const filled = '█'.repeat(filledCount);
+    const empty = emptyChar.repeat(emptyCount);
+    return createLine(`${filled}${empty}`, `${colorizeByScore(c, score, filled)}${c.dim(empty)}`);
+}
+function renderValidationStatus(c, status) {
+    if (status === 'PASS')
+        return c.green(status);
+    if (status === 'WARN')
+        return c.yellow(status);
+    if (status === 'SKIPPED')
+        return c.dim(status);
+    return c.red(status);
+}
+function renderSecurityStatus(c, status) {
+    if (status === 'PASS')
+        return c.green(status);
+    if (status === 'FAIL')
+        return c.red(status);
+    return c.yellow(status);
+}
+function truncateRunCommand(value, maxLength) {
+    if (value.length <= maxLength) {
+        return { text: value, truncated: false };
+    }
+    if (maxLength <= 1) {
+        return { text: '…', truncated: true };
+    }
+    return {
+        text: `${value.slice(0, maxLength - 1)}…`,
+        truncated: true,
+    };
+}
+export function renderConclusionCard(input) {
+    const mode = input.mode ?? 'default';
+    const c = mode === 'share' ? pcForced : pc;
+    const scoreValue = input.overallScore === null
+        ? '--'
+        : String(Math.max(0, input.overallScore));
+    const label = scoreLabel(input.overallScore);
+    const scoreLinePlain = `${scoreValue} / 100  ${label}`;
+    const scoreLineRendered = `${colorizeByScore(c, input.overallScore, scoreValue)} / 100  ${colorizeByScore(c, input.overallScore, label)}`;
+    const scoreBar = renderScoreBar(c, input.overallScore, mode);
+    const validationLinePlain = `validation ${input.validationStatus} | security ${input.securityStatus}`;
+    const validationLineRendered = `${c.bold('validation')} ${renderValidationStatus(c, input.validationStatus)} ${c.dim('|')} ${c.bold('security')} ${renderSecurityStatus(c, input.securityStatus)}`;
+    const errorsText = `✖ ${input.errorCount} error${input.errorCount === 1 ? '' : 's'}`;
+    const warningsText = `⚠ ${input.warningCount} warning${input.warningCount === 1 ? '' : 's'}`;
+    const skillCountText = `${input.skillCount} skill${input.skillCount === 1 ? '' : 's'}`;
+    const filesText = `across ${input.affectedFileCount} file${input.affectedFileCount === 1 ? '' : 's'}`;
+    const elapsedText = `in ${formatElapsed(input.elapsedMs)}`;
+    const countsLinePlain = `${errorsText}  ${warningsText}  ${skillCountText}  ${filesText}  ${elapsedText}`;
+    const countsLineRendered = `${input.errorCount > 0 ? c.red(errorsText) : c.dim(errorsText)}  ` +
+        `${input.warningCount > 0 ? c.yellow(warningsText) : c.dim(warningsText)}  ` +
+        `${c.dim(skillCountText)}  ${c.dim(filesText)}  ${c.dim(elapsedText)}`;
+    const title = input.title ?? 'skill-check cli';
+    let fullCommandPlain;
+    let runCommandPreview;
+    let runCommandWasTruncated = false;
+    if (input.runCommand) {
+        const preview = truncateRunCommand(input.runCommand, RUN_COMMAND_PREVIEW_LIMIT);
+        runCommandPreview = preview.text;
+        runCommandWasTruncated = preview.truncated;
+        if (runCommandWasTruncated) {
+            fullCommandPlain = input.runCommand;
+        }
+    }
+    const lines = [];
+    if (mode === 'share') {
+        lines.push(createLine(title, `${c.bold(c.cyan('skill-check'))} ${c.bold('cli')}`), createLine(''));
+    }
+    else {
+        lines.push(createLine('  .--------.', c.cyan('  .--------.')), createLine('  | skill  |', c.cyan('  | skill  |')), createLine('  | check  |', c.cyan('  | check  |')), createLine("  '--------'", c.cyan("  '--------'")), createLine(''), createLine(title, `${c.bold('skill-check')} ${c.dim('cli')}`), createLine(''));
+    }
+    if (runCommandPreview) {
+        lines.push(createLine(`run: ${runCommandPreview}`, `${c.bold('run:')} ${c.cyan(runCommandPreview)}`));
+        if (runCommandWasTruncated) {
+            lines.push(createLine('full command below', c.dim('full command below')));
+        }
+    }
+    lines.push(createLine(''), createLine(scoreLinePlain, scoreLineRendered), createLine(''), scoreBar, createLine(''), createLine(validationLinePlain, validationLineRendered), createLine(countsLinePlain, countsLineRendered));
+    if (mode === 'share') {
+        lines.push(createLine(''), createLine('try it: npx skill-check <path-or-github-url>', `${c.bold('try it:')} ${c.cyan('npx skill-check <path-or-github-url>')}`), createLine('npm: https://www.npmjs.com/package/skill-check', `${c.bold('npm:')} ${c.dim('https://www.npmjs.com/package/skill-check')}`));
+    }
+    const width = Math.max(mode === 'share' ? SHARE_CARD_MIN_WIDTH : 0, ...lines.map((line) => line.plainText.length));
+    let card;
+    if (mode === 'share') {
+        card = lines
+            .map((line) => {
+            const trailing = ' '.repeat(Math.max(0, width - line.plainText.length));
+            return `${line.renderedText}${trailing}`;
+        })
+            .join('\n');
+    }
+    else {
+        const border = '-'.repeat(width + 2);
+        const output = [`+${border}+`];
+        for (const line of lines) {
+            output.push(padLine(line, width));
+        }
+        output.push(`+${border}+`);
+        card = output.join('\n');
+    }
+    return {
+        card,
+        fullCommandPlain,
+    };
+}

package/dist/core/defaults.js

@@ -1,4 +1,4 @@
-export const DEFAULT_INCLUDE = ['**/skills/*/SKILL.md'];
+export const DEFAULT_INCLUDE = ['**/SKILL.md'];
 export const DEFAULT_EXCLUDE = [
     '**/node_modules/**',
     '**/.git/**',

package/dist/core/discovery.js

@@ -1,11 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import fg from 'fast-glob';
-import { DEFAULT_INCLUDE } from './defaults.js';
 export async function discoverSkillFiles(config) {
     const found = new Set();
-    const usesDefaultInclude = config.include.length === DEFAULT_INCLUDE.length &&
-        config.include.every((pattern, index) => pattern === DEFAULT_INCLUDE[index]);
     for (const root of config.rootsAbs) {
         if (fs.existsSync(root) && fs.statSync(root).isFile()) {
             if (path.basename(root) === 'SKILL.md') {
@@ -23,21 +20,6 @@ export async function discoverSkillFiles(config) {
             onlyFiles: true,
             dot: true,
         });
-        if (matches.length === 0 &&
-            usesDefaultInclude &&
-            path.basename(path.resolve(root)) === 'skills') {
-            const fallbackMatches = await fg('**/SKILL.md', {
-                cwd: root,
-                ignore: config.exclude,
-                absolute: true,
-                onlyFiles: true,
-                dot: true,
-            });
-            for (const match of fallbackMatches) {
-                found.add(path.resolve(match));
-            }
-            continue;
-        }
         for (const match of matches) {
             found.add(path.resolve(match));
         }

package/dist/core/formatters.d.ts

@@ -1,4 +1,13 @@
 import type { AnalysisResult } from '../types.js';
+import { type SecurityStatus } from './conclusion-card.js';
 import type { SkillScore } from './quality-score.js';
-export declare function renderText(result: AnalysisResult, scores?: SkillScore[]): string;
+export interface RenderTextOptions {
+    includeConclusion?: boolean;
+    securityStatus?: SecurityStatus;
+    elapsedMs?: number;
+    affectedFileCount?: number;
+    runCommand?: string;
+    title?: string;
+}
+export declare function renderText(result: AnalysisResult, scores?: SkillScore[], options?: RenderTextOptions): string;
 export declare function toJson(result: AnalysisResult): Record<string, unknown>;

package/dist/core/formatters.js

@@ -1,6 +1,6 @@
-import boxen from 'boxen';
 import Table from 'cli-table3';
 import pc from 'picocolors';
+import { renderConclusionCard, } from './conclusion-card.js';
 function groupByFile(diagnostics) {
     const grouped = new Map();
     for (const diagnostic of diagnostics) {
@@ -77,39 +77,28 @@ function renderOverviewTable(result, fileCount) {
     ]);
     return table.toString();
 }
-function renderSummaryPanel(result) {
-    const status = result.summary.errorCount > 0
-        ? pc.red(pc.bold('FAIL'))
-        : result.summary.warningCount > 0
-            ? pc.yellow(pc.bold('WARN'))
-            : pc.green(pc.bold('PASS'));
-    return boxen([
-        `${pc.bold('Status')}    ${status}`,
-        `${pc.bold('Skills')}    ${pc.cyan(String(result.summary.skillCount))}`,
-        `${pc.bold('Errors')}    ${pc.red(String(result.summary.errorCount))}`,
-        `${pc.bold('Warnings')}  ${pc.yellow(String(result.summary.warningCount))}`,
-    ].join('\n'), {
-        borderColor: result.summary.errorCount > 0
-            ? 'red'
-            : result.summary.warningCount > 0
-                ? 'yellow'
-                : 'green',
-        borderStyle: 'classic',
-        padding: {
-            top: 0,
-            right: 1,
-            bottom: 0,
-            left: 1,
-        },
-    });
-}
 function renderScoreBar(score) {
     const color = score >= 80 ? pc.green : score >= 50 ? pc.yellow : pc.red;
     const filled = Math.round(score / 5);
     const empty = 20 - filled;
     return `${color('█'.repeat(filled))}${pc.dim('░'.repeat(empty))} ${color(String(score))}`;
 }
-export function renderText(result, scores) {
+function resolveValidationStatus(result) {
+    if (result.summary.skillCount === 0)
+        return 'SKIPPED';
+    if (result.summary.errorCount > 0)
+        return 'FAIL';
+    if (result.summary.warningCount > 0)
+        return 'WARN';
+    return 'PASS';
+}
+function computeOverallScore(scores) {
+    if (!scores || scores.length === 0)
+        return null;
+    const total = scores.reduce((sum, score) => sum + score.score, 0);
+    return Math.round(total / scores.length);
+}
+export function renderText(result, scores, options = {}) {
     const lines = [];
     const grouped = groupByFile(result.diagnostics);
     const status = renderStatusTag(result.summary);
@@ -156,16 +145,25 @@ export function renderText(result, scores) {
         }
         lines.push('');
     }
-    lines.push(pc.dim(renderDivider('-')));
-    lines.push(renderSummaryPanel(result));
-    lines.push('');
-    const statusWord = result.summary.errorCount > 0
-        ? pc.red('FAIL')
-        : result.summary.warningCount > 0
-            ? pc.yellow('WARN')
-            : pc.green('PASS');
-    lines.push(`Summary: skills=${pc.cyan(String(result.summary.skillCount))} errors=${pc.red(String(result.summary.errorCount))} warnings=${pc.yellow(String(result.summary.warningCount))} status=${statusWord}`);
-    lines.push(pc.dim(renderDivider('-')));
+    if (options.includeConclusion !== false) {
+        const conclusion = renderConclusionCard({
+            skillCount: result.summary.skillCount,
+            errorCount: result.summary.errorCount,
+            warningCount: result.summary.warningCount,
+            affectedFileCount: options.affectedFileCount ?? grouped.size,
+            overallScore: computeOverallScore(scores),
+            validationStatus: resolveValidationStatus(result),
+            securityStatus: options.securityStatus ?? 'SKIPPED',
+            elapsedMs: options.elapsedMs ?? 0,
+            runCommand: options.runCommand,
+            title: options.title,
+        });
+        lines.push(pc.dim(renderDivider('-')));
+        lines.push(conclusion.card);
+        if (conclusion.fullCommandPlain) {
+            lines.push(conclusion.fullCommandPlain);
+        }
+    }
     return `${lines.join('\n').trimEnd()}\n`;
 }
 export function toJson(result) {