@perrylink/dsh-skill-pack-security-provider 1.3.0 → 2.0.1

package/lib/vet/manifest.js

@@ -0,0 +1,345 @@
+/**
+ * Manifest and lockfile parsing for the SBOM check — pure text/JSON parsing,
+ * zero dependencies. Supports package.json plus pnpm-lock.yaml,
+ * package-lock.json (v1–v3) and yarn.lock (v1); unknown formats are reported
+ * as `unsupported`, never guessed.
+ *
+ * @module dsh-skill-pack-security/vet/manifest
+ */
+const LOCKFILE_NAMES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'npm-shrinkwrap.json', 'bun.lockb'];
+/** Find and parse the first supported lockfile in the scan set. */
+export function parseLockfile(files) {
+    for (const name of LOCKFILE_NAMES) {
+        const hit = files.find(file => file.path === name || file.path.endsWith(`/${name}`));
+        if (hit === undefined || hit.text === null)
+            continue;
+        if (name === 'pnpm-lock.yaml')
+            return parsePnpmLock(hit.text);
+        if (name === 'package-lock.json' || name === 'npm-shrinkwrap.json')
+            return parseNpmLock(hit.text, name);
+        if (name === 'yarn.lock')
+            return parseYarnLock(hit.text);
+        if (name === 'bun.lockb') {
+            return { kind: 'unsupported', lockfile: name, lockfileVersion: '', entries: new Map(), hasIntegrity: false };
+        }
+    }
+    return { kind: null, lockfile: null, lockfileVersion: '', entries: new Map(), hasIntegrity: false };
+}
+/** Parse package.json when present. */
+export function parseManifest(files) {
+    const hit = files.find(file => file.path === 'package.json' || file.path.endsWith('/package.json'));
+    const empty = {
+        name: '', version: '', license: '', scripts: {},
+        dependencies: {}, devDependencies: {}, optionalDependencies: {}, peerDependencies: {},
+        repository: '', present: false,
+    };
+    if (hit === undefined || hit.text === null)
+        return empty;
+    let json;
+    try {
+        json = JSON.parse(hit.text);
+    }
+    catch {
+        return empty;
+    }
+    if (typeof json !== 'object' || json === null || Array.isArray(json))
+        return empty;
+    const pkg = json;
+    const record = (value) => {
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return {};
+        const out = {};
+        for (const [key, spec] of Object.entries(value)) {
+            if (typeof spec === 'string')
+                out[key] = spec;
+        }
+        return out;
+    };
+    const licenseField = pkg['license'];
+    let license = '';
+    if (typeof licenseField === 'string')
+        license = licenseField;
+    else if (typeof licenseField === 'object' && licenseField !== null && !Array.isArray(licenseField)) {
+        const type = licenseField['type'];
+        if (typeof type === 'string')
+            license = type;
+    }
+    const repository = pkg['repository'];
+    let repositoryString = '';
+    if (typeof repository === 'string')
+        repositoryString = repository;
+    else if (typeof repository === 'object' && repository !== null && !Array.isArray(repository)) {
+        const url = repository['url'];
+        if (typeof url === 'string')
+            repositoryString = url;
+    }
+    return {
+        name: typeof pkg['name'] === 'string' ? pkg['name'] : '',
+        version: typeof pkg['version'] === 'string' ? pkg['version'] : '',
+        license,
+        scripts: record(pkg['scripts']),
+        dependencies: record(pkg['dependencies']),
+        devDependencies: record(pkg['devDependencies']),
+        optionalDependencies: record(pkg['optionalDependencies']),
+        peerDependencies: record(pkg['peerDependencies']),
+        repository: repositoryString,
+        present: true,
+    };
+}
+// --- pnpm-lock.yaml ----------------------------------------------------------
+/** Normalize a pnpm packages-section key to `name@version` (strip `/` and `(suffix)`). */
+function normalizePnpmKey(key) {
+    const trimmed = key.replace(/^['"]|['"]$/g, '');
+    const noSuffix = trimmed.replace(/\(.*\)$/, '');
+    return noSuffix.startsWith('/') ? noSuffix.slice(1) : noSuffix;
+}
+function parsePnpmLock(text) {
+    const entries = new Map();
+    const hasIntegrity = text.includes('integrity');
+    const versionMatch = /lockfileVersion:\s*['"]?([0-9.]+)/.exec(text);
+    const version = versionMatch?.[1] ?? '';
+    // Only the `packages:` section is needed: `<key>` entries whose children list dependencies.
+    const packagesAt = text.indexOf('\npackages:');
+    const body = packagesAt === -1 ? text : text.slice(packagesAt + 1);
+    const lines = body.split('\n');
+    let current = null;
+    let inDependencies = false;
+    for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.trim() === '')
+            continue;
+        const indent = line.length - line.trimStart().length;
+        const trimmedLine = line.trim();
+        if (indent === 0) {
+            current = null;
+            inDependencies = false;
+            continue;
+        }
+        if (indent === 2 && trimmedLine.endsWith(':')) {
+            // New package entry: `name@version:`, `'name@version':` or `/name@version:`.
+            const keyMatch = /^(?:'([^']+)'|"([^"]+)"|(\S+)):$/.exec(trimmedLine);
+            if (keyMatch !== null) {
+                const key = keyMatch[1] ?? keyMatch[2] ?? keyMatch[3];
+                current = {};
+                entries.set(normalizePnpmKey(key), current);
+            }
+            else {
+                current = null;
+            }
+            inDependencies = false;
+            continue;
+        }
+        if (indent === 4) {
+            inDependencies = trimmedLine === 'dependencies:' || trimmedLine === 'optionalDependencies:';
+            continue;
+        }
+        if (indent === 6 && current !== null && inDependencies) {
+            const depMatch = /^(?:'([^']+)'|"([^"]+)"|(@?[^:\s][^:]*)):\s*(.+)$/.exec(trimmedLine);
+            if (depMatch !== null) {
+                const name = depMatch[1] ?? depMatch[2] ?? depMatch[3];
+                current[name] = depMatch[4].trim();
+            }
+        }
+    }
+    return { kind: 'pnpm', lockfile: 'pnpm-lock.yaml', lockfileVersion: version, entries, hasIntegrity };
+}
+// --- package-lock.json -------------------------------------------------------
+function parseNpmLock(text, lockfile) {
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        return { kind: 'unsupported', lockfile, lockfileVersion: '', entries: new Map(), hasIntegrity: false };
+    }
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        return { kind: 'unsupported', lockfile, lockfileVersion: '', entries: new Map(), hasIntegrity: false };
+    }
+    const root = json;
+    const entries = new Map();
+    let hasIntegrity = false;
+    const version = typeof root['lockfileVersion'] === 'number' ? String(root['lockfileVersion']) : '';
+    const packages = root['packages'];
+    if (typeof packages === 'object' && packages !== null && !Array.isArray(packages)) {
+        for (const [location, raw] of Object.entries(packages)) {
+            if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+                continue;
+            const entry = raw;
+            const name = typeof entry['name'] === 'string' ? entry['name'] : location.split('node_modules/').pop() ?? '';
+            const ver = typeof entry['version'] === 'string' ? entry['version'] : '';
+            if (location !== '' && name !== '') {
+                const deps = {};
+                if (typeof entry['dependencies'] === 'object' && entry['dependencies'] !== null) {
+                    for (const [dep, spec] of Object.entries(entry['dependencies'])) {
+                        if (typeof spec === 'string')
+                            deps[dep] = spec;
+                    }
+                }
+                entries.set(`${name}@${ver}`, deps);
+                if (typeof entry['integrity'] === 'string' && entry['integrity'] !== '')
+                    hasIntegrity = true;
+            }
+        }
+    }
+    else {
+        // v1 shape: nested `dependencies` objects.
+        const walk = (node) => {
+            if (typeof node !== 'object' || node === null || Array.isArray(node))
+                return;
+            for (const [name, raw] of Object.entries(node)) {
+                if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+                    continue;
+                const entry = raw;
+                const ver = typeof entry['version'] === 'string' ? entry['version'] : '';
+                const deps = {};
+                if (typeof entry['requires'] === 'object' && entry['requires'] !== null) {
+                    for (const [dep, spec] of Object.entries(entry['requires'])) {
+                        if (typeof spec === 'string')
+                            deps[dep] = spec;
+                    }
+                }
+                if (name !== '' && ver !== '')
+                    entries.set(`${name}@${ver}`, deps);
+                if (typeof entry['integrity'] === 'string' && entry['integrity'] !== '')
+                    hasIntegrity = true;
+                walk(entry['dependencies']);
+            }
+        };
+        walk(root['dependencies']);
+    }
+    return { kind: 'npm', lockfile, lockfileVersion: version, entries, hasIntegrity };
+}
+// --- yarn.lock (v1) ----------------------------------------------------------
+/** Extract the package name from a yarn key line (`name@^range` / `@scope/name@^range`). */
+function yarnKeyName(key) {
+    const unquoted = key.replace(/^["']|["']$/g, '').trim();
+    const at = unquoted.lastIndexOf('@');
+    return at <= 0 ? unquoted : unquoted.slice(0, at);
+}
+function parseYarnLock(text) {
+    const entries = new Map();
+    let hasIntegrity = text.includes('integrity') || text.includes('resolved "');
+    const lines = text.split('\n');
+    let current = null;
+    let key = '';
+    for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.trim() === '' || line.trimStart().startsWith('#'))
+            continue;
+        if (!/^\s/.test(line)) {
+            key = line.replace(/:$/, '').trim();
+            if (current !== null && current.version !== '') {
+                entries.set(`${current.key}@${current.version}`, current.deps);
+            }
+            current = null;
+            continue;
+        }
+        const match = /^\s+(.+?)\s+(.+)$/.exec(line);
+        if (match === null)
+            continue;
+        const fieldName = match[1];
+        const value = match[2].trim();
+        if (fieldName === 'version') {
+            if (current !== null && current.version !== '') {
+                entries.set(`${current.key}@${current.version}`, current.deps);
+            }
+            current = { key: yarnKeyName(key), deps: {}, version: value.replace(/^"|"$/g, '') };
+            continue;
+        }
+        if (fieldName === 'integrity') {
+            hasIntegrity = true;
+            continue;
+        }
+        if (fieldName === 'dependencies' || fieldName === 'optionalDependencies')
+            continue;
+        if (current !== null && !['resolved', 'uid'].includes(fieldName)) {
+            current.deps[fieldName.replace(/^["']|["']$/g, '')] = value;
+        }
+    }
+    if (current !== null && current.version !== '') {
+        entries.set(`${current.key}@${current.version}`, current.deps);
+    }
+    return { kind: 'yarn', lockfile: 'yarn.lock', lockfileVersion: '1', entries, hasIntegrity };
+}
+// --- tree building ------------------------------------------------------------
+/** Normalize a dependency spec into a bare version when possible. */
+export function specVersion(spec) {
+    const trimmed = spec.trim();
+    const match = /^(?:[\^~<>=*| ]+|npm:|workspace:|file:|link:)*(.+)$/.exec(trimmed);
+    return match?.[1] ?? trimmed;
+}
+/** Resolve a name+spec against lockfile entries (exact match, then prefix scan). */
+function resolveLockedVersion(name, spec, entries) {
+    const bare = specVersion(spec);
+    if (entries.has(`${name}@${bare}`))
+        return bare;
+    for (const key of entries.keys()) {
+        if (key.startsWith(`${name}@`))
+            return key.slice(name.length + 1);
+    }
+    return undefined;
+}
+/**
+ * Build the dependency tree: BFS from the manifest's direct dependencies
+ * through lockfile edges, deduped by name@version, depth- and node-capped.
+ */
+export function buildDependencyTree(manifest, lock, maxNodes) {
+    const packages = [];
+    const seen = new Set();
+    const queue = [];
+    const direct = [
+        ...Object.entries(manifest.dependencies).map(([name, spec]) => ({ name, spec, depth: 0, dev: false })),
+        ...Object.entries(manifest.devDependencies).map(([name, spec]) => ({ name, spec, depth: 0, dev: true })),
+    ];
+    let total = 0;
+    let truncated = false;
+    for (const root of direct) {
+        total += 1;
+        const version = lock.entries.size > 0 ? resolveLockedVersion(root.name, root.spec, lock.entries) ?? specVersion(root.spec) : specVersion(root.spec);
+        const key = `${root.name}@${version}`;
+        if (!seen.has(key) && packages.length < maxNodes) {
+            seen.add(key);
+            packages.push({ name: root.name, version, depth: 0, dev: root.dev });
+        }
+        else if (!seen.has(key)) {
+            truncated = true;
+        }
+        queue.push(root);
+    }
+    while (queue.length > 0) {
+        const item = queue.shift();
+        if (item.depth >= 20)
+            continue;
+        const version = lock.entries.size > 0 ? resolveLockedVersion(item.name, item.spec, lock.entries) : undefined;
+        const locked = version === undefined ? `${item.name}@${specVersion(item.spec)}` : `${item.name}@${version}`;
+        const edges = lock.entries.get(locked);
+        if (edges === undefined)
+            continue;
+        for (const [depName, depSpec] of Object.entries(edges)) {
+            if (depName === '' || depSpec === '')
+                continue;
+            const depVersion = resolveLockedVersion(depName, depSpec, lock.entries) ?? specVersion(depSpec);
+            const depKey = `${depName}@${depVersion}`;
+            total += 1;
+            if (!seen.has(depKey)) {
+                if (packages.length >= maxNodes) {
+                    truncated = true;
+                    continue;
+                }
+                seen.add(depKey);
+                packages.push({ name: depName, version: depVersion, depth: item.depth + 1, dev: item.dev });
+                queue.push({ name: depName, spec: depSpec, depth: item.depth + 1, dev: item.dev });
+            }
+        }
+    }
+    return { packages, truncated, total };
+}
+/** Direct specs that are not exact-version pinned (a supply-chain signal). */
+export function unpinnedSpecs(manifest) {
+    const out = [];
+    for (const [name, spec] of Object.entries(manifest.dependencies)) {
+        if (!/^\d/.test(spec.trim()))
+            out.push(`${name}@${spec}`);
+    }
+    return out;
+}

package/lib/vet/redact.js

@@ -0,0 +1,46 @@
+/**
+ * Report redaction: no secret-shaped text may ever leave the scan engine.
+ *
+ * Applied to every evidence snippet and finding message before a value enters
+ * the canonical report, mirroring the pack's `secret-scan` redaction rule
+ * (type marker only, never the value). Patterns cover the token families the
+ * `secret-scan` skill documents plus webhook/bot URLs.
+ *
+ * @module dsh-skill-pack-security/vet/redact
+ */
+const REDACTIONS = [
+    // Private key blocks (PEM / OpenSSH), multiline.
+    { pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g, replace: '[REDACTED private key]' },
+    // GitHub tokens.
+    { pattern: /ghp_[A-Za-z0-9]{30,}/g, replace: 'ghp_***' },
+    { pattern: /github_pat_[A-Za-z0-9_]{20,}/g, replace: 'github_pat_***' },
+    // AWS access keys.
+    { pattern: /AKIA[0-9A-Z]{16}/g, replace: 'AKIA***' },
+    // Generic sk- / xox tokens (OpenAI, Slack…).
+    { pattern: /sk-[A-Za-z0-9]{16,}/g, replace: 'sk-***' },
+    { pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/g, replace: 'xox*-***' },
+    // Azure storage keys.
+    { pattern: /AZURE_STORAGE_[A-Za-z0-9]+=[A-Za-z0-9+/=]+/g, replace: 'AZURE_STORAGE_***=***' },
+    // npm registry auth.
+    { pattern: /_authToken\s*=\s*[^\s"']+/g, replace: '_authToken=***' },
+    { pattern: /\/\/registry\.npmjs\.org\/:_authToken=[^\s"']+/g, replace: '//registry.npmjs.org/:_authToken=***' },
+    // Discord webhooks and Telegram bot tokens.
+    { pattern: /https:\/\/discord(?:app)?\.com\/api\/webhooks\/[0-9]+\/[A-Za-z0-9_-]+/g, replace: 'https://discord.com/api/webhooks/[REDACTED]' },
+    { pattern: /https:\/\/api\.telegram\.org\/bot[0-9]+:[A-Za-z0-9_-]+/g, replace: 'https://api.telegram.org/bot[REDACTED]' },
+    // Assignment-style credentials of any name.
+    { pattern: /(password|passwd|secret|api[_-]?key|token|credential[a-z]*)\s*[:=]\s*["'][^"']{6,}["']/gi, replace: '$1=[REDACTED]' },
+];
+/** Replace every secret-shaped substring with a type marker. */
+export function redact(text) {
+    let out = text;
+    for (const { pattern, replace } of REDACTIONS) {
+        out = out.replace(pattern, replace);
+    }
+    return out;
+}
+/** Cap a raw snippet and redact it for use as finding evidence. */
+export function redactSnippet(text, maxChars = 160) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    const cut = trimmed.length > maxChars ? `${trimmed.slice(0, maxChars - 1)}…` : trimmed;
+    return redact(cut);
+}

package/lib/vet/report.js

@@ -0,0 +1,95 @@
+/**
+ * Model-facing renderers for the plugin_vet report: the canonical JSON value
+ * becomes a compact markdown report (render), a pending-call card
+ * (presentCall), and a completed gate card (presentResult). Everything is
+ * pure and capped — no secrets (the engine redacts before this layer), no
+ * unbounded trees.
+ *
+ * @module dsh-skill-pack-security/vet/report
+ */
+import { DIMENSION_LABEL, T } from './skills.js';
+const TREE_CAP = 40;
+const FINDING_CAP = 6;
+function verdictMark(verdict) {
+    switch (verdict) {
+        case 'fail': return '🔴';
+        case 'warn': return '🟡';
+        case 'pass': return '🟢';
+        default: return '⚪';
+    }
+}
+/** Five-dimension score line. */
+export function scoresLine(scores, lang) {
+    const dims = ['license', 'source', 'dependencies', 'build-scripts', 'maintenance'];
+    return dims.map(dim => `${DIMENSION_LABEL[lang][dim]} ${scores[dim]}/100`).join(' · ') + ` · ${lang === 'zh' ? '总分' : 'overall'} ${scores.overall}/100`;
+}
+/** One check section. */
+function renderCheck(check, lang) {
+    const t = T[lang];
+    const head = `- ${verdictMark(check.verdict)} [${check.verdict.toUpperCase()}] ${check.name} — ${lang === 'zh' ? '深审技能' : 'deep-dive skill'}: \`${check.skill}\``;
+    const lines = [head];
+    if (check.verdict === 'skip' && check.skipReason !== undefined) {
+        lines.push(`  - ⚪ ${t.skip}: ${check.skipReason}`);
+        return lines.join('\n');
+    }
+    for (const finding of check.findings.slice(0, FINDING_CAP)) {
+        const loc = finding.location !== undefined ? ` \`${finding.location}\`` : '';
+        const evidence = finding.evidence !== undefined ? ` — ${t.evidence}: \`${finding.evidence}\`` : '';
+        lines.push(`  - ${verdictMark(finding.level)} ${finding.message}${loc}${evidence}`);
+    }
+    if (check.truncatedFindings)
+        lines.push(`  - … (${lang === 'zh' ? '其余发现被截断' : 'further findings truncated'})`);
+    return lines.join('\n');
+}
+/** Render the canonical report as model-facing markdown. */
+export function renderReport(report, lang) {
+    const t = T[lang];
+    const targetLabel = report.target.kind === 'npm-package' ? report.target.resolved : report.target.kind === 'local-path' ? report.target.resolved : `${report.target.resolved}@${report.target.ref}`;
+    const parts = [];
+    parts.push(`## plugin_vet ${report.target.raw}`);
+    parts.push('');
+    parts.push(`${verdictMark(report.verdict)} **${lang === 'zh' ? '结论' : 'Verdict'}: ${report.verdict.toUpperCase()}** — ${scoresLine(report.scores, lang)}`);
+    if (report.budget.truncated)
+        parts.push(`⚠️ ${t.budgetTruncated}: ${report.budget.truncatedReason ?? ''}`);
+    parts.push('');
+    if (report.gate.applied) {
+        if (report.gate.blocked) {
+            parts.push(`🛑 **${t.gateDenyTitle}**`);
+            parts.push(t.gateDenyBody);
+        }
+        else {
+            parts.push(`⚠️ **${t.gateWarnTitle}**`);
+            parts.push(t.gateWarnBody);
+        }
+        parts.push('');
+    }
+    parts.push(`${lang === 'zh' ? '扫描对象' : 'Target'}: ${targetLabel} · ${report.fetchedAt}`);
+    parts.push('');
+    for (const check of report.checks) {
+        parts.push(renderCheck(check, lang));
+    }
+    parts.push('');
+    parts.push(`**SBOM** (${report.sbom.lockfile ?? (lang === 'zh' ? '无锁文件' : 'no lockfile')}) — ${lang === 'zh' ? '直接依赖' : 'direct'} ${report.sbom.directDependencies} + dev ${report.sbom.directDevDependencies}, ${lang === 'zh' ? '唯一包' : 'unique packages'} ${report.sbom.packages.length}${report.sbom.totalPackages > report.sbom.packages.length ? ` (${lang === 'zh' ? '总计' : 'total'} ${report.sbom.totalPackages})` : ''}`);
+    if (report.sbom.packages.length > 0) {
+        const tree = report.sbom.packages.slice(0, TREE_CAP).map(pkg => `${'  '.repeat(Math.min(pkg.depth, 8))}${pkg.name}@${pkg.version}`).join('\n');
+        parts.push('```text');
+        parts.push(tree);
+        parts.push('```');
+        if (report.sbom.packages.length > TREE_CAP)
+            parts.push(`… (${lang === 'zh' ? '树被截断至' : 'tree capped at'} ${TREE_CAP} ${lang === 'zh' ? '行' : 'lines'})`);
+    }
+    parts.push('');
+    parts.push(`${lang === 'zh' ? '扫描预算' : 'Scan budget'}: ${report.budget.filesScanned} ${lang === 'zh' ? '个文件' : 'files'} · ${report.budget.bytesScanned} bytes · ${report.budget.filesSkipped} ${lang === 'zh' ? '跳过' : 'skipped'}${report.budget.truncated ? ` · ⚠️ ${t.budgetTruncated}` : ''}`);
+    parts.push('');
+    parts.push(`**${t.followup}**: ${report.followupSkills.map(name => `\`${name}\``).join(', ')}`);
+    return parts.join('\n');
+}
+/** Short gate summary for the completed card (≤ a few lines). */
+export function gateSummary(report, lang) {
+    const t = T[lang];
+    if (report.gate.blocked)
+        return `🛑 ${t.gateDenyTitle}\n${t.gateDenyBody}`;
+    if (report.gate.applied)
+        return `⚠️ ${t.gateWarnTitle}\n${t.gateWarnBody}`;
+    return '';
+}

package/lib/vet/skills.js

@@ -0,0 +1,99 @@
+/**
+ * Skill cross-references and report-language strings for plugin_vet.
+ *
+ * Every check cites the pack skill (and section) that continues its subject
+ * as a manual audit — "skill 教流程，插件自动执行". Skill names are identical
+ * in the zh/en editions, so the reference is language-neutral.
+ *
+ * @module dsh-skill-pack-security/vet/skills
+ */
+/** check id → pack skill + section (the manual deep-dive continuation). */
+export const SKILL_REF = {
+    license: 'dependency-audit §3',
+    sbom: 'dependency-audit §7',
+    'commit-lock': 'supply-chain-review §3',
+    'install-scripts': 'supply-chain-review §1',
+    'network-exfil': 'dependency-audit §4.4',
+    obfuscation: 'supply-chain-review §1',
+    source: 'dependency-audit §4.3',
+    maintenance: 'security-audit §3',
+};
+/** check id → human-readable check name per language. */
+export const CHECK_NAME = {
+    zh: {
+        license: '许可证扫描',
+        sbom: 'SBOM 依赖树',
+        'commit-lock': 'commit 锁定校验',
+        'install-scripts': 'install 脚本检查',
+        'network-exfil': '网络回传检测',
+        obfuscation: '混淆代码检测',
+        source: '来源可信信号',
+        maintenance: '维护状态',
+    },
+    en: {
+        license: 'License scan',
+        sbom: 'SBOM dependency tree',
+        'commit-lock': 'Commit lock verification',
+        'install-scripts': 'Install script checks',
+        'network-exfil': 'Network exfiltration scan',
+        obfuscation: 'Obfuscation scan',
+        source: 'Source trust signals',
+        maintenance: 'Maintenance status',
+    },
+};
+/** dimension → label per language. */
+export const DIMENSION_LABEL = {
+    zh: {
+        license: '许可证',
+        source: '来源',
+        dependencies: '依赖',
+        'build-scripts': '构建脚本',
+        maintenance: '维护状态',
+    },
+    en: {
+        license: 'License',
+        source: 'Source',
+        dependencies: 'Dependencies',
+        'build-scripts': 'Build scripts',
+        maintenance: 'Maintenance',
+    },
+};
+/** Messages shared by checks and the report renderer. */
+export const T = {
+    zh: {
+        pass: '通过',
+        warn: '警告',
+        fail: '失败',
+        skip: '跳过',
+        verdictPass: 'PASS',
+        verdictWarn: 'WARN',
+        verdictFail: 'FAIL',
+        gateDenyTitle: '门禁 DENY：此插件未通过供应链检查，安装已被策略拒绝',
+        gateDenyBody: '请加载 supply-chain-review / dependency-audit 技能人工深审；或由可信维护者修改门禁策略后重试。',
+        gateWarnTitle: '门禁警告：plugin_vet 结果为 FAIL，强烈建议停止安装',
+        gateWarnBody: '默认策略 warn 不阻断。继续安装前请按下方 skill 引用人工深审，确认风险可接受。',
+        followup: '人工深审建议（加载对应技能继续）',
+        budget: '扫描预算',
+        budgetTruncated: '扫描被预算截断：结果不完整',
+        offline: '离线/受限',
+        evidence: '证据',
+    },
+    en: {
+        pass: 'pass',
+        warn: 'warn',
+        fail: 'fail',
+        skip: 'skip',
+        verdictPass: 'PASS',
+        verdictWarn: 'WARN',
+        verdictFail: 'FAIL',
+        gateDenyTitle: 'Gate DENY: this plugin failed the supply-chain checks; installation is blocked by policy',
+        gateDenyBody: 'Load the supply-chain-review / dependency-audit skills for a manual deep-dive, or have a trusted maintainer change the gate policy and retry.',
+        gateWarnTitle: 'Gate warning: plugin_vet returned FAIL — installation is strongly discouraged',
+        gateWarnBody: 'The default policy is warn (non-blocking). Before continuing the install, follow the skill references below for a manual review and confirm the risk is acceptable.',
+        followup: 'Manual deep-dive (load these skills to continue)',
+        budget: 'Scan budget',
+        budgetTruncated: 'Scan truncated by budget: results are incomplete',
+        offline: 'Offline/limited',
+        evidence: 'Evidence',
+    },
+};