@shrkcrft/inspector 0.1.0-alpha.1

package/dist/check-result-v1.js

@@ -0,0 +1,335 @@
+/**
+ * Universal check-result protocol (`sharkcraft.check-result/v1`).
+ *
+ * A single schema any tool can emit so SharkCraft can aggregate
+ * results from itself + ESLint + Biome + custom project checks into
+ * one rollup. Distinct from `sharkcraft.custom-check/v1` (which is
+ * descriptor-driven, one-check-at-a-time).
+ *
+ * Design rules (from feature_47.md):
+ *   - status: pass | warn | fail | unknown.
+ *   - findings carry severity / file / optional line/column / ruleId /
+ *     message / suggestedAction / safeToAutoFix.
+ *   - schema string + tool + command + generatedAt + sourceReportPath
+ *     stay alongside so reproducibility is not lost.
+ *   - Conversion is round-trippable but not lossy: ESLint's `endLine`
+ *     / `endColumn` etc. live under `metadata` so they survive the
+ *     trip without bloating the canonical shape.
+ *
+ * This module is pure and read-only. No spawning, no writes — the CLI
+ * surface (`shrk checks import/aggregate/report/convert`) handles I/O.
+ */
+import { readFileSync, existsSync } from 'node:fs';
+export const CHECK_RESULT_SCHEMA = 'sharkcraft.check-result/v1';
+export const CHECK_AGGREGATE_SCHEMA = 'sharkcraft.check-aggregate/v1';
+export var CheckResultStatus;
+(function (CheckResultStatus) {
+    CheckResultStatus["Pass"] = "pass";
+    CheckResultStatus["Warn"] = "warn";
+    CheckResultStatus["Fail"] = "fail";
+    CheckResultStatus["Unknown"] = "unknown";
+})(CheckResultStatus || (CheckResultStatus = {}));
+export var CheckFindingSeverity;
+(function (CheckFindingSeverity) {
+    CheckFindingSeverity["Error"] = "error";
+    CheckFindingSeverity["Warning"] = "warning";
+    CheckFindingSeverity["Info"] = "info";
+})(CheckFindingSeverity || (CheckFindingSeverity = {}));
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function severityFromUnknown(raw) {
+    if (raw === 2 || raw === 'error' || raw === 'fatal')
+        return CheckFindingSeverity.Error;
+    if (raw === 1 || raw === 'warning' || raw === 'warn')
+        return CheckFindingSeverity.Warning;
+    return CheckFindingSeverity.Info;
+}
+function summarize(findings) {
+    let errors = 0;
+    let warnings = 0;
+    let infos = 0;
+    for (const f of findings) {
+        if (f.severity === CheckFindingSeverity.Error)
+            errors += 1;
+        else if (f.severity === CheckFindingSeverity.Warning)
+            warnings += 1;
+        else
+            infos += 1;
+    }
+    return { errors, warnings, infos, total: findings.length };
+}
+function statusFor(summary) {
+    if (summary.errors > 0)
+        return CheckResultStatus.Fail;
+    if (summary.warnings > 0)
+        return CheckResultStatus.Warn;
+    return CheckResultStatus.Pass;
+}
+export function buildCheckResult(input) {
+    const summary = summarize(input.findings);
+    const status = input.status ?? statusFor(summary);
+    const result = {
+        schema: CHECK_RESULT_SCHEMA,
+        tool: input.tool,
+        generatedAt: new Date().toISOString(),
+        status,
+        findings: input.findings,
+        summary,
+    };
+    if (input.command !== undefined)
+        result.command = input.command;
+    if (input.sourceReportPath !== undefined)
+        result.sourceReportPath = input.sourceReportPath;
+    if (input.metadata !== undefined)
+        result.metadata = input.metadata;
+    return result;
+}
+export function parseCheckResult(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return { ok: false, reason: `invalid JSON: ${e.message}` };
+    }
+    if (!isPlainObject(parsed))
+        return { ok: false, reason: 'top-level value must be an object' };
+    if (parsed.schema !== CHECK_RESULT_SCHEMA) {
+        return {
+            ok: false,
+            reason: `expected schema ${CHECK_RESULT_SCHEMA}, got ${String(parsed.schema)}`,
+        };
+    }
+    if (typeof parsed.tool !== 'string' || parsed.tool === '') {
+        return { ok: false, reason: 'missing tool string' };
+    }
+    if (typeof parsed.generatedAt !== 'string') {
+        return { ok: false, reason: 'missing generatedAt' };
+    }
+    if (!Array.isArray(parsed.findings)) {
+        return { ok: false, reason: 'findings must be an array' };
+    }
+    const findings = [];
+    for (const rawF of parsed.findings) {
+        if (!isPlainObject(rawF)) {
+            return { ok: false, reason: 'finding must be an object' };
+        }
+        if (typeof rawF.message !== 'string' || rawF.message === '') {
+            return { ok: false, reason: 'finding.message must be a non-empty string' };
+        }
+        const f = {
+            severity: severityFromUnknown(rawF.severity),
+            message: rawF.message,
+        };
+        if (typeof rawF.file === 'string')
+            f.file = rawF.file;
+        if (typeof rawF.line === 'number')
+            f.line = rawF.line;
+        if (typeof rawF.column === 'number')
+            f.column = rawF.column;
+        if (typeof rawF.ruleId === 'string')
+            f.ruleId = rawF.ruleId;
+        if (typeof rawF.suggestedAction === 'string')
+            f.suggestedAction = rawF.suggestedAction;
+        if (typeof rawF.safeToAutoFix === 'boolean')
+            f.safeToAutoFix = rawF.safeToAutoFix;
+        if (isPlainObject(rawF.metadata))
+            f.metadata = rawF.metadata;
+        findings.push(f);
+    }
+    const summary = summarize(findings);
+    const statusRaw = parsed.status;
+    const status = statusRaw === CheckResultStatus.Pass ||
+        statusRaw === CheckResultStatus.Warn ||
+        statusRaw === CheckResultStatus.Fail ||
+        statusRaw === CheckResultStatus.Unknown
+        ? statusRaw
+        : statusFor(summary);
+    const result = {
+        schema: CHECK_RESULT_SCHEMA,
+        tool: parsed.tool,
+        generatedAt: parsed.generatedAt,
+        status,
+        findings,
+        summary,
+    };
+    if (typeof parsed.command === 'string')
+        result.command = parsed.command;
+    if (typeof parsed.sourceReportPath === 'string') {
+        result.sourceReportPath = parsed.sourceReportPath;
+    }
+    if (isPlainObject(parsed.metadata))
+        result.metadata = parsed.metadata;
+    return { ok: true, result };
+}
+export function parseCheckResultFromFile(path) {
+    if (!existsSync(path))
+        return { ok: false, reason: `file not found: ${path}` };
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (e) {
+        return { ok: false, reason: `read error: ${e.message}` };
+    }
+    return parseCheckResult(raw);
+}
+export function convertEslintToCheckResult(raw, sourceReportPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return { ok: false, reason: `invalid ESLint JSON: ${e.message}` };
+    }
+    if (!Array.isArray(parsed)) {
+        return { ok: false, reason: 'ESLint JSON must be a top-level array of file results' };
+    }
+    const findings = [];
+    for (const rawFile of parsed) {
+        if (!isPlainObject(rawFile))
+            continue;
+        const file = rawFile;
+        const filePath = typeof file.filePath === 'string' ? file.filePath : undefined;
+        const msgs = Array.isArray(file.messages) ? file.messages : [];
+        for (const msg of msgs) {
+            if (!isPlainObject(msg))
+                continue;
+            if (typeof msg.message !== 'string')
+                continue;
+            const f = {
+                severity: severityFromUnknown(msg.severity),
+                message: msg.message,
+            };
+            if (filePath)
+                f.file = filePath;
+            if (typeof msg.line === 'number')
+                f.line = msg.line;
+            if (typeof msg.column === 'number')
+                f.column = msg.column;
+            if (typeof msg.ruleId === 'string')
+                f.ruleId = msg.ruleId;
+            if (msg.fix !== undefined)
+                f.safeToAutoFix = Boolean(msg.fix);
+            const meta = {};
+            if (typeof msg.endLine === 'number')
+                meta.endLine = msg.endLine;
+            if (typeof msg.endColumn === 'number')
+                meta.endColumn = msg.endColumn;
+            if (Object.keys(meta).length > 0)
+                f.metadata = meta;
+            findings.push(f);
+        }
+    }
+    return {
+        ok: true,
+        result: buildCheckResult({
+            tool: 'eslint',
+            command: 'eslint --format json',
+            findings,
+            ...(sourceReportPath !== undefined ? { sourceReportPath } : {}),
+        }),
+    };
+}
+/**
+ * Biome's JSON output is not a stable contract. We accept either:
+ *   - the adjacent shape: { diagnostics: [{ category, severity, description, location: { path, line?, column? } }] }
+ *   - native Biome `--reporter github`-ish: { diagnostics: [{ severity, description, location }] }
+ * Anything else returns a clear reason.
+ */
+export function convertBiomeToCheckResult(raw, sourceReportPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return { ok: false, reason: `invalid Biome JSON: ${e.message}` };
+    }
+    if (!isPlainObject(parsed) || !Array.isArray(parsed.diagnostics)) {
+        return { ok: false, reason: 'expected { diagnostics: [...] } shape' };
+    }
+    const findings = [];
+    for (const rawDiag of parsed.diagnostics) {
+        if (!isPlainObject(rawDiag))
+            continue;
+        const d = rawDiag;
+        const message = typeof d.description === 'string'
+            ? d.description
+            : typeof d.message === 'string'
+                ? d.message
+                : isPlainObject(d.message) && typeof d.message.content === 'string'
+                    ? (d.message.content)
+                    : null;
+        if (!message)
+            continue;
+        const f = {
+            severity: severityFromUnknown(d.severity),
+            message,
+        };
+        if (typeof d.category === 'string')
+            f.ruleId = d.category;
+        const loc = d.location;
+        if (loc) {
+            if (typeof loc.path === 'string')
+                f.file = loc.path;
+            else if (isPlainObject(loc.path) && typeof loc.path.file === 'string') {
+                f.file = loc.path.file;
+            }
+            if (typeof loc.line === 'number')
+                f.line = loc.line;
+            if (typeof loc.column === 'number')
+                f.column = loc.column;
+        }
+        findings.push(f);
+    }
+    return {
+        ok: true,
+        result: buildCheckResult({
+            tool: 'biome',
+            command: 'biome check --reporter json',
+            findings,
+            ...(sourceReportPath !== undefined ? { sourceReportPath } : {}),
+        }),
+    };
+}
+function combineStatus(a, b) {
+    // Worst wins. Fail > Warn > Pass > Unknown (Unknown only "wins" if there
+    // are no other results — handled by initial accumulator).
+    if (a === CheckResultStatus.Fail || b === CheckResultStatus.Fail)
+        return CheckResultStatus.Fail;
+    if (a === CheckResultStatus.Warn || b === CheckResultStatus.Warn)
+        return CheckResultStatus.Warn;
+    if (a === CheckResultStatus.Pass || b === CheckResultStatus.Pass)
+        return CheckResultStatus.Pass;
+    return CheckResultStatus.Unknown;
+}
+export function buildCheckAggregate(results) {
+    const findings = [];
+    const entries = [];
+    let overall = CheckResultStatus.Unknown;
+    const total = { errors: 0, warnings: 0, infos: 0, total: 0 };
+    for (const item of results) {
+        overall = combineStatus(overall, item.result.status);
+        total.errors += item.result.summary.errors;
+        total.warnings += item.result.summary.warnings;
+        total.infos += item.result.summary.infos;
+        total.total += item.result.summary.total;
+        entries.push({
+            tool: item.result.tool,
+            status: item.result.status,
+            summary: item.result.summary,
+            sourceReportPath: item.sourceReportPath,
+        });
+        for (const f of item.result.findings)
+            findings.push(f);
+    }
+    return {
+        schema: CHECK_AGGREGATE_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        overall,
+        total,
+        entries,
+        findings,
+    };
+}

package/dist/ci-integrity-report.d.ts

@@ -0,0 +1,38 @@
+export declare const CI_INTEGRITY_SCHEMA = "sharkcraft.ci-integrity/v1";
+export declare enum GateStatus {
+    Pass = "pass",
+    Warn = "warn",
+    Fail = "fail",
+    Unknown = "unknown"
+}
+export interface ICiGate {
+    id: string;
+    title: string;
+    /** File name (relative) the gate was read from, when applicable. */
+    source?: string;
+    status: GateStatus;
+    errors: number;
+    warnings: number;
+    /** Short headline. */
+    summary: string;
+    /** Concrete next command to investigate. */
+    nextCommand?: string;
+}
+export interface ICiIntegrityReport {
+    schema: typeof CI_INTEGRITY_SCHEMA;
+    generatedAt: string;
+    reportsDir: string;
+    gates: readonly ICiGate[];
+    overall: GateStatus;
+    totalErrors: number;
+    totalWarnings: number;
+    topActionableFailures: readonly string[];
+    nextCommands: readonly string[];
+}
+export interface ICiIntegrityOptions {
+    reportsDir?: string;
+}
+export declare function buildCiIntegrityReport(projectRoot: string, options?: ICiIntegrityOptions): ICiIntegrityReport;
+export declare function renderCiIntegrityMarkdown(report: ICiIntegrityReport): string;
+export declare function renderCiIntegrityHtml(report: ICiIntegrityReport): string;
+//# sourceMappingURL=ci-integrity-report.d.ts.map

package/dist/ci-integrity-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-integrity-report.d.ts","sourceRoot":"","sources":["../src/ci-integrity-report.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE,oBAAY,UAAU;IACpB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,mBAAmB,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,SAAS,OAAO,EAAE,CAAC;IAC1B,OAAO,EAAE,UAAU,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAoLD,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CA0EpB;AAeD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA0B5E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAexE"}

package/dist/ci-integrity-report.js

@@ -0,0 +1,324 @@
+/**
+ * CI integrity report aggregator.
+ *
+ * Aggregates the JSON reports written by the SharkCraft CI scaffold steps
+ * (knowledge-stale.json, template-drift.json, boundaries.json, agent tests,
+ * safety audit, product check, release readiness, etc.) into a single
+ * "is the PR healthy?" verdict + PR-comment-ready markdown.
+ *
+ * Schema: sharkcraft.ci-integrity/v1
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export const CI_INTEGRITY_SCHEMA = 'sharkcraft.ci-integrity/v1';
+export var GateStatus;
+(function (GateStatus) {
+    GateStatus["Pass"] = "pass";
+    GateStatus["Warn"] = "warn";
+    GateStatus["Fail"] = "fail";
+    GateStatus["Unknown"] = "unknown";
+})(GateStatus || (GateStatus = {}));
+function asObj(raw) {
+    return raw && typeof raw === 'object' ? raw : {};
+}
+function num(o, key) {
+    const v = o[key];
+    return typeof v === 'number' ? v : 0;
+}
+const PROBES = [
+    {
+        filenameStartsWith: 'knowledge-stale',
+        id: 'knowledge-stale',
+        title: 'Knowledge stale-check',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const counts = asObj(o.summary ?? o);
+            const stale = num(counts, 'stale');
+            const missing = num(counts, 'missing');
+            const errors = num(counts, 'requiredStale') + num(counts, 'requiredMissing');
+            const warnings = stale + missing - errors;
+            const status = errors > 0 ? GateStatus.Fail : warnings > 0 ? GateStatus.Warn : GateStatus.Pass;
+            return {
+                status,
+                errors,
+                warnings: warnings < 0 ? 0 : warnings,
+                summary: `stale=${stale} missing=${missing}`,
+                nextCommand: 'shrk knowledge stale-check --strict',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'template-drift',
+        id: 'template-drift',
+        title: 'Template drift',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const fail = num(o, 'fail');
+            const warn = num(o, 'warn');
+            const pass = num(o, 'pass');
+            const status = fail > 0 ? GateStatus.Fail : warn > 0 ? GateStatus.Warn : GateStatus.Pass;
+            return {
+                status,
+                errors: fail,
+                warnings: warn,
+                summary: `pass=${pass} warn=${warn} fail=${fail}`,
+                nextCommand: 'shrk templates drift --min-severity warning',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'boundaries',
+        id: 'boundaries',
+        title: 'Boundary check',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const violations = Array.isArray(o.violations) ? o.violations.length : num(o, 'violations');
+            const status = violations > 0 ? GateStatus.Fail : GateStatus.Pass;
+            return {
+                status,
+                errors: violations,
+                warnings: 0,
+                summary: `violations=${violations}`,
+                nextCommand: 'shrk check boundaries --changed-only',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'safety-audit',
+        id: 'safety-audit',
+        title: 'Safety audit',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const passed = o.passed === true;
+            const errors = num(o, 'errors');
+            const warnings = num(o, 'warnings');
+            const status = !passed || errors > 0 ? GateStatus.Fail : warnings > 0 ? GateStatus.Warn : GateStatus.Pass;
+            return {
+                status,
+                errors,
+                warnings,
+                summary: passed ? 'safety audit passed' : 'safety audit failed',
+                nextCommand: 'shrk safety audit --deep',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'agent-tests',
+        id: 'agent-tests',
+        title: 'Agent contract tests',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const total = Array.isArray(o.results) ? o.results.length : num(o, 'total');
+            const passed = num(o, 'passed');
+            const failed = num(o, 'failed') || (total - passed);
+            const status = failed > 0 ? GateStatus.Fail : GateStatus.Pass;
+            return {
+                status,
+                errors: failed,
+                warnings: 0,
+                summary: `passed=${passed} failed=${failed} total=${total}`,
+                nextCommand: 'shrk test agent',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'product',
+        id: 'product-check',
+        title: 'Product coherence check',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const errors = num(o, 'errors');
+            const warnings = num(o, 'warnings');
+            const status = errors > 0 ? GateStatus.Fail : warnings > 0 ? GateStatus.Warn : GateStatus.Pass;
+            return {
+                status,
+                errors,
+                warnings,
+                summary: `errors=${errors} warnings=${warnings}`,
+                nextCommand: 'shrk product check',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'commands-doctor',
+        id: 'commands-doctor',
+        title: 'Commands doctor',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const passed = o.passed === true;
+            const errors = num(asObj(o.summary), 'errors') || num(o, 'errors');
+            const warnings = num(asObj(o.summary), 'warnings') || num(o, 'warnings');
+            const status = !passed || errors > 0 ? GateStatus.Fail : warnings > 0 ? GateStatus.Warn : GateStatus.Pass;
+            return {
+                status,
+                errors,
+                warnings,
+                summary: passed ? 'catalog OK' : 'catalog issues',
+                nextCommand: 'shrk commands doctor',
+            };
+        },
+    },
+    {
+        filenameStartsWith: 'release-readiness',
+        id: 'release-readiness',
+        title: 'Release readiness',
+        pickStatus: (raw) => {
+            const o = asObj(raw);
+            const passed = o.passed === true || o.ready === true;
+            const errors = num(o, 'errors');
+            const status = !passed ? GateStatus.Fail : errors > 0 ? GateStatus.Fail : GateStatus.Pass;
+            return {
+                status,
+                errors,
+                warnings: 0,
+                summary: passed ? 'release ready' : 'release not ready',
+                nextCommand: 'shrk release readiness --strict',
+            };
+        },
+    },
+];
+function loadJson(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function buildCiIntegrityReport(projectRoot, options = {}) {
+    const reportsDir = nodePath.isAbsolute(options.reportsDir ?? '.sharkcraft/reports')
+        ? (options.reportsDir ?? '.sharkcraft/reports')
+        : nodePath.join(projectRoot, options.reportsDir ?? '.sharkcraft/reports');
+    const gates = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    if (!existsSync(reportsDir)) {
+        return {
+            schema: CI_INTEGRITY_SCHEMA,
+            generatedAt: new Date().toISOString(),
+            reportsDir,
+            gates: [],
+            overall: GateStatus.Unknown,
+            totalErrors: 0,
+            totalWarnings: 0,
+            topActionableFailures: [],
+            nextCommands: [`Run \`shrk ci scaffold --with-integrity\` to populate ${reportsDir}`],
+        };
+    }
+    const files = readdirSync(reportsDir).filter((n) => n.endsWith('.json'));
+    for (const probe of PROBES) {
+        const file = files.find((f) => f.startsWith(probe.filenameStartsWith));
+        if (!file) {
+            gates.push({
+                id: probe.id,
+                title: probe.title,
+                status: GateStatus.Unknown,
+                errors: 0,
+                warnings: 0,
+                summary: 'no report file present',
+            });
+            continue;
+        }
+        const full = nodePath.join(reportsDir, file);
+        const raw = loadJson(full);
+        const evaluated = probe.pickStatus(raw);
+        totalErrors += evaluated.errors;
+        totalWarnings += evaluated.warnings;
+        gates.push({
+            id: probe.id,
+            title: probe.title,
+            source: nodePath.relative(projectRoot, full),
+            status: evaluated.status,
+            errors: evaluated.errors,
+            warnings: evaluated.warnings,
+            summary: evaluated.summary,
+            ...(evaluated.nextCommand ? { nextCommand: evaluated.nextCommand } : {}),
+        });
+    }
+    // Overall verdict.
+    let overall = GateStatus.Pass;
+    let sawFail = false;
+    for (const g of gates) {
+        if (g.status === GateStatus.Fail) {
+            sawFail = true;
+            break;
+        }
+        if (g.status === GateStatus.Warn)
+            overall = GateStatus.Warn;
+        if (g.status === GateStatus.Unknown && overall === GateStatus.Pass)
+            overall = GateStatus.Unknown;
+    }
+    if (sawFail)
+        overall = GateStatus.Fail;
+    const failing = gates.filter((g) => g.status === GateStatus.Fail);
+    return {
+        schema: CI_INTEGRITY_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        reportsDir,
+        gates,
+        overall,
+        totalErrors,
+        totalWarnings,
+        topActionableFailures: failing.slice(0, 5).map((g) => `${g.title}: ${g.summary}`),
+        nextCommands: failing.slice(0, 5).map((g) => g.nextCommand ?? '').filter(Boolean),
+    };
+}
+function badge(status) {
+    switch (status) {
+        case GateStatus.Pass:
+            return '✓ pass';
+        case GateStatus.Warn:
+            return '⚠ warn';
+        case GateStatus.Fail:
+            return '✗ fail';
+        case GateStatus.Unknown:
+            return '— unknown';
+    }
+}
+export function renderCiIntegrityMarkdown(report) {
+    const lines = [];
+    lines.push('# SharkCraft CI integrity');
+    lines.push(`Generated: ${report.generatedAt}`);
+    lines.push(`Reports dir: \`${report.reportsDir}\``);
+    lines.push('');
+    lines.push(`Overall: **${badge(report.overall)}**`);
+    lines.push(`Totals: errors=${report.totalErrors}, warnings=${report.totalWarnings}`);
+    lines.push('');
+    lines.push('| Gate | Status | Summary | Next command |');
+    lines.push('| --- | --- | --- | --- |');
+    for (const g of report.gates) {
+        const next = g.nextCommand ? `\`${g.nextCommand}\`` : '—';
+        lines.push(`| ${g.title} | ${badge(g.status)} | ${g.summary} | ${next} |`);
+    }
+    if (report.topActionableFailures.length > 0) {
+        lines.push('');
+        lines.push('## Top failing gates');
+        for (const f of report.topActionableFailures)
+            lines.push(`- ${f}`);
+    }
+    if (report.nextCommands.length > 0) {
+        lines.push('');
+        lines.push('## Next commands');
+        for (const c of report.nextCommands)
+            lines.push(`- \`${c}\``);
+    }
+    return lines.join('\n') + '\n';
+}
+export function renderCiIntegrityHtml(report) {
+    const esc = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const rows = report.gates
+        .map((g) => `<tr><td>${esc(g.title)}</td><td>${badge(g.status)}</td><td>${esc(g.summary)}</td><td>${g.nextCommand ? `<code>${esc(g.nextCommand)}</code>` : ''}</td></tr>`)
+        .join('');
+    return [
+        '<!doctype html><html><head><meta charset="utf-8">',
+        '<title>SharkCraft — CI integrity</title>',
+        '<style>body{font:14px/1.5 -apple-system,sans-serif;max-width:960px;margin:24px auto;padding:0 16px}table{border-collapse:collapse;width:100%}th,td{border:1px solid #d0d7de;padding:6px 10px}th{background:#f6f8fa}</style>',
+        '</head><body>',
+        `<h1>SharkCraft CI integrity</h1>`,
+        `<p>Overall: <strong>${badge(report.overall)}</strong></p>`,
+        `<table><thead><tr><th>Gate</th><th>Status</th><th>Summary</th><th>Next</th></tr></thead><tbody>${rows}</tbody></table>`,
+        '</body></html>',
+    ].join('\n');
+}