@shrkcrft/quality-gates 0.1.0-alpha.10

package/dist/gates/api-diff-gate.d.ts

@@ -0,0 +1,21 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IApiDiffGateOptions {
+    /** Path to a saved `IApiSurface` baseline. Required. */
+    baselinePath: string;
+    /** When true, breaking changes fail the gate. Default true. */
+    failOnBreaking?: boolean;
+    /** Restrict diff to these packages. */
+    packageFilter?: readonly string[];
+}
+/**
+ * API-surface diff gate. Compares the current code-graph's public
+ * surface to a saved baseline (typically committed at the last
+ * release) and fails when any breaking changes appear.
+ *
+ * Skipped when:
+ *   - the baseline file doesn't exist (use `shrk api-diff capture` to
+ *     create one)
+ *   - the code-graph isn't indexed
+ */
+export declare function apiDiffGate(projectRoot: string, options: IApiDiffGateOptions): IGateResult;
+//# sourceMappingURL=api-diff-gate.d.ts.map

package/dist/gates/api-diff-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-diff-gate.d.ts","sourceRoot":"","sources":["../../src/gates/api-diff-gate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,mBAAmB;IAClC,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uCAAuC;IACvC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,WAAW,CA2E1F"}

package/dist/gates/api-diff-gate.js

@@ -0,0 +1,91 @@
+import { readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { diffApiSurfaces, extractApiSurface, } from '@shrkcrft/api-surface-diff';
+import { GraphStore } from '@shrkcrft/graph';
+/**
+ * API-surface diff gate. Compares the current code-graph's public
+ * surface to a saved baseline (typically committed at the last
+ * release) and fails when any breaking changes appear.
+ *
+ * Skipped when:
+ *   - the baseline file doesn't exist (use `shrk api-diff capture` to
+ *     create one)
+ *   - the code-graph isn't indexed
+ */
+export function apiDiffGate(projectRoot, options) {
+    const start = Date.now();
+    const failOnBreaking = options.failOnBreaking ?? true;
+    const abs = nodePath.isAbsolute(options.baselinePath)
+        ? options.baselinePath
+        : nodePath.resolve(projectRoot, options.baselinePath);
+    let baseline;
+    try {
+        baseline = JSON.parse(readFileSync(abs, 'utf8'));
+    }
+    catch (e) {
+        return {
+            id: 'api-diff',
+            label: 'API surface',
+            status: 'skipped',
+            message: `Baseline read failed: ${e.message}`,
+            nextCommands: ['shrk api-diff capture --output ' + options.baselinePath],
+            durationMs: Date.now() - start,
+        };
+    }
+    const store = new GraphStore(projectRoot);
+    if (!store.exists()) {
+        return {
+            id: 'api-diff',
+            label: 'API surface',
+            status: 'skipped',
+            message: 'Skipped — graph index missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const snap = store.loadSnapshot();
+    const current = extractApiSurface(snap, {
+        ...(options.packageFilter && options.packageFilter.length > 0
+            ? { packageFilter: options.packageFilter }
+            : {}),
+    });
+    const diff = diffApiSurfaces(baseline, current);
+    if (failOnBreaking && diff.breakingCount > 0) {
+        return {
+            id: 'api-diff',
+            label: 'API surface',
+            status: 'fail',
+            message: `${diff.breakingCount} breaking API change(s).`,
+            details: {
+                added: diff.added,
+                removed: diff.removed,
+                changed: diff.changed,
+                breaking: diff.breakingCount,
+            },
+            nextCommands: [`shrk api-diff ${options.baselinePath}`],
+            durationMs: Date.now() - start,
+        };
+    }
+    if (diff.added > 0 || diff.removed > 0 || diff.changed > 0) {
+        return {
+            id: 'api-diff',
+            label: 'API surface',
+            status: diff.breakingCount > 0 ? 'warn' : 'pass',
+            message: `${diff.added} added, ${diff.removed} removed, ${diff.changed} changed (no breaking).`,
+            details: {
+                added: diff.added,
+                removed: diff.removed,
+                changed: diff.changed,
+                breaking: diff.breakingCount,
+            },
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'api-diff',
+        label: 'API surface',
+        status: 'pass',
+        message: 'No API surface changes.',
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/arch-gate.d.ts

@@ -0,0 +1,8 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+/**
+ * Architecture-guard gate. Pass when zero error-severity violations.
+ * Warnings (fat barrels, 2-node cycles, adapter leaks) are reported
+ * as `warn` — the gate doesn't fail, but the human sees them.
+ */
+export declare function archGate(projectRoot: string): IGateResult;
+//# sourceMappingURL=arch-gate.d.ts.map

package/dist/gates/arch-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arch-gate.d.ts","sourceRoot":"","sources":["../../src/gates/arch-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAgDzD"}

package/dist/gates/arch-gate.js

@@ -0,0 +1,55 @@
+import { runArchCheck } from '@shrkcrft/architecture-guard';
+/**
+ * Architecture-guard gate. Pass when zero error-severity violations.
+ * Warnings (fat barrels, 2-node cycles, adapter leaks) are reported
+ * as `warn` — the gate doesn't fail, but the human sees them.
+ */
+export function archGate(projectRoot) {
+    const start = Date.now();
+    const report = runArchCheck({ projectRoot });
+    if (report.diagnostics.some((d) => d.includes('code-graph store missing'))) {
+        return {
+            id: 'arch',
+            label: 'Architecture',
+            status: 'skipped',
+            message: 'Skipped — graph index missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const errors = report.countsBySeverity.error;
+    const warnings = report.countsBySeverity.warning;
+    if (errors > 0) {
+        return {
+            id: 'arch',
+            label: 'Architecture',
+            status: 'fail',
+            message: `${errors} architecture error(s).`,
+            details: {
+                errors,
+                warnings,
+                kinds: report.countsByKind,
+            },
+            nextCommands: ['shrk arch check'],
+            durationMs: Date.now() - start,
+        };
+    }
+    if (warnings > 0) {
+        return {
+            id: 'arch',
+            label: 'Architecture',
+            status: 'warn',
+            message: `${warnings} architecture warning(s).`,
+            details: { warnings, kinds: report.countsByKind },
+            nextCommands: ['shrk arch check'],
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'arch',
+        label: 'Architecture',
+        status: 'pass',
+        message: 'No architecture violations.',
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/graph-cycles-gate.d.ts

@@ -0,0 +1,17 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IGraphCyclesGateOptions {
+    /** A cycle counts as "large" at or above this size. Default 3. */
+    largeCycleSize?: number;
+    /** Total cycles at or above this count triggers warn. Default 5. */
+    manyCycleThreshold?: number;
+    /** When true, large/many cycles fail the gate instead of warning. */
+    failOnLarge?: boolean;
+}
+/**
+ * Surface import cycles in the file-import graph. Uses the persisted
+ * `cycleCount` / `largestCycleSize` from `IGraphManifest` so the gate
+ * is O(1) — no recomputation. Mirrors the doctor's heuristic: large
+ * cycles or many cycles → advisory by default, fail when caller opts in.
+ */
+export declare function graphCyclesGate(projectRoot: string, options?: IGraphCyclesGateOptions): IGateResult;
+//# sourceMappingURL=graph-cycles-gate.d.ts.map

package/dist/gates/graph-cycles-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-cycles-gate.d.ts","sourceRoot":"","sources":["../../src/gates/graph-cycles-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,uBAAuB;IACtC,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,uBAA4B,GACpC,WAAW,CA0Cb"}

package/dist/gates/graph-cycles-gate.js

@@ -0,0 +1,49 @@
+import { GraphStore } from '@shrkcrft/graph';
+/**
+ * Surface import cycles in the file-import graph. Uses the persisted
+ * `cycleCount` / `largestCycleSize` from `IGraphManifest` so the gate
+ * is O(1) — no recomputation. Mirrors the doctor's heuristic: large
+ * cycles or many cycles → advisory by default, fail when caller opts in.
+ */
+export function graphCyclesGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const large = options.largeCycleSize ?? 3;
+    const many = options.manyCycleThreshold ?? 5;
+    const failOnLarge = options.failOnLarge ?? false;
+    const store = new GraphStore(projectRoot);
+    if (!store.exists()) {
+        return {
+            id: 'graph-cycles',
+            label: 'Graph cycles',
+            status: 'skipped',
+            message: 'Skipped — graph index missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const snap = store.loadSnapshot();
+    const cycleCount = snap.manifest.cycleCount ?? 0;
+    const largestCycleSize = snap.manifest.largestCycleSize ?? 0;
+    const filesInCycles = snap.manifest.filesInCycles ?? 0;
+    const triggered = largestCycleSize >= large || cycleCount >= many;
+    if (!triggered) {
+        return {
+            id: 'graph-cycles',
+            label: 'Graph cycles',
+            status: 'pass',
+            message: `${cycleCount} cycle(s); largest ${largestCycleSize}.`,
+            details: { cycleCount, largestCycleSize, filesInCycles },
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'graph-cycles',
+        label: 'Graph cycles',
+        status: failOnLarge ? 'fail' : 'warn',
+        message: `${cycleCount} import cycle(s); largest spans ${largestCycleSize} files; ` +
+            `${filesInCycles} file(s) participate.`,
+        details: { cycleCount, largestCycleSize, filesInCycles, threshold: { large, many } },
+        nextCommands: ['shrk graph cycles', 'shrk arch check'],
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/graph-fresh-gate.d.ts

@@ -0,0 +1,8 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+/**
+ * Check whether the code-graph store exists AND the manifest digest
+ * matches the on-disk JSONL fingerprints. Catches: missing index;
+ * tampered / partial store; schema mismatch.
+ */
+export declare function graphFreshGate(projectRoot: string): IGateResult;
+//# sourceMappingURL=graph-fresh-gate.d.ts.map

package/dist/gates/graph-fresh-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-fresh-gate.d.ts","sourceRoot":"","sources":["../../src/gates/graph-fresh-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAgC/D"}

package/dist/gates/graph-fresh-gate.js

@@ -0,0 +1,39 @@
+import { GraphStore } from '@shrkcrft/graph';
+/**
+ * Check whether the code-graph store exists AND the manifest digest
+ * matches the on-disk JSONL fingerprints. Catches: missing index;
+ * tampered / partial store; schema mismatch.
+ */
+export function graphFreshGate(projectRoot) {
+    const start = Date.now();
+    const store = new GraphStore(projectRoot);
+    if (!store.exists()) {
+        return {
+            id: 'graph-fresh',
+            label: 'Code graph indexed',
+            status: 'fail',
+            message: 'Code-graph store missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const verify = store.verifyDigest();
+    if (!verify.ok) {
+        return {
+            id: 'graph-fresh',
+            label: 'Code graph indexed',
+            status: 'fail',
+            message: 'Code-graph digest mismatch — store may be tampered or partial.',
+            details: { expected: verify.expected, actual: verify.actual },
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'graph-fresh',
+        label: 'Code graph indexed',
+        status: 'pass',
+        message: 'Code-graph index is fresh.',
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/graph-unresolved-gate.d.ts

@@ -0,0 +1,16 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IGraphUnresolvedGateOptions {
+    /**
+     * When true, any unresolved import fails the gate. Default `false`
+     * (warn) — dynamic / runtime-only imports are sometimes intentional.
+     */
+    failOnAny?: boolean;
+}
+/**
+ * Read the persisted unresolved-import counts from the graph manifest
+ * and surface them. Warn by default (since some unresolved specifiers
+ * are intentional — dynamic imports, optional peer deps); fail when
+ * `failOnAny` is true.
+ */
+export declare function graphUnresolvedGate(projectRoot: string, options?: IGraphUnresolvedGateOptions): IGateResult;
+//# sourceMappingURL=graph-unresolved-gate.d.ts.map

package/dist/gates/graph-unresolved-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-unresolved-gate.d.ts","sourceRoot":"","sources":["../../src/gates/graph-unresolved-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,2BAA2B;IAC1C;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,2BAAgC,GACxC,WAAW,CAoCb"}

package/dist/gates/graph-unresolved-gate.js

@@ -0,0 +1,44 @@
+import { GraphStore } from '@shrkcrft/graph';
+/**
+ * Read the persisted unresolved-import counts from the graph manifest
+ * and surface them. Warn by default (since some unresolved specifiers
+ * are intentional — dynamic imports, optional peer deps); fail when
+ * `failOnAny` is true.
+ */
+export function graphUnresolvedGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const failOnAny = options.failOnAny ?? false;
+    const store = new GraphStore(projectRoot);
+    if (!store.exists()) {
+        return {
+            id: 'graph-unresolved',
+            label: 'Graph unresolved imports',
+            status: 'skipped',
+            message: 'Skipped — graph index missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const snap = store.loadSnapshot();
+    const count = snap.manifest.unresolvedImportCount ?? 0;
+    const files = snap.manifest.filesWithUnresolvedImports ?? 0;
+    const samples = snap.manifest.unresolvedImportSamples ?? [];
+    if (count === 0) {
+        return {
+            id: 'graph-unresolved',
+            label: 'Graph unresolved imports',
+            status: 'pass',
+            message: 'No unresolved imports.',
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'graph-unresolved',
+        label: 'Graph unresolved imports',
+        status: failOnAny ? 'fail' : 'warn',
+        message: `${count} unresolved import(s) across ${files} file(s).`,
+        details: { count, files, samples },
+        nextCommands: ['shrk graph unresolved'],
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/impact-baseline-gate.d.ts

@@ -0,0 +1,16 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IImpactBaselineGateOptions {
+    /**
+     * When true, a worsened baseline fails the gate. Default `false`
+     * (warn) — growing impact can be intentional in early development.
+     */
+    failOnWorsened?: boolean;
+}
+/**
+ * Compare the last impact run against the frozen baseline. Skipped
+ * when either side is missing. Warn / fail when the run is worse
+ * than baseline along any axis (more dependents, more packages, or a
+ * higher risk classification).
+ */
+export declare function impactBaselineGate(projectRoot: string, options?: IImpactBaselineGateOptions): IGateResult;
+//# sourceMappingURL=impact-baseline-gate.d.ts.map

package/dist/gates/impact-baseline-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-baseline-gate.d.ts","sourceRoot":"","sources":["../../src/gates/impact-baseline-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,0BAA+B,GACvC,WAAW,CAuDb"}

package/dist/gates/impact-baseline-gate.js

@@ -0,0 +1,61 @@
+import { ImpactReportStore, diffImpactReports } from '@shrkcrft/impact-engine';
+/**
+ * Compare the last impact run against the frozen baseline. Skipped
+ * when either side is missing. Warn / fail when the run is worse
+ * than baseline along any axis (more dependents, more packages, or a
+ * higher risk classification).
+ */
+export function impactBaselineGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const failOnWorsened = options.failOnWorsened ?? false;
+    const store = new ImpactReportStore(projectRoot);
+    const baseline = store.readBaseline();
+    const last = store.read();
+    if (!baseline) {
+        return {
+            id: 'impact-baseline',
+            label: 'Impact baseline',
+            status: 'skipped',
+            message: 'No baseline frozen. Run `shrk impact baseline write` to opt in.',
+            durationMs: Date.now() - start,
+        };
+    }
+    if (!last) {
+        return {
+            id: 'impact-baseline',
+            label: 'Impact baseline',
+            status: 'skipped',
+            message: 'Baseline present but no recent impact run to compare against.',
+            nextCommands: ['shrk impact --via-graph'],
+            durationMs: Date.now() - start,
+        };
+    }
+    const delta = diffImpactReports(baseline, last);
+    if (!delta.worsened) {
+        return {
+            id: 'impact-baseline',
+            label: 'Impact baseline',
+            status: 'pass',
+            message: `Within baseline — dependents ${delta.dependentDelta >= 0 ? '+' : ''}${delta.dependentDelta}, ` +
+                `packages ${delta.packageDelta >= 0 ? '+' : ''}${delta.packageDelta}.`,
+            details: { delta },
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'impact-baseline',
+        label: 'Impact baseline',
+        status: failOnWorsened ? 'fail' : 'warn',
+        message: `Worsened — dependents ${delta.dependentDelta >= 0 ? '+' : ''}${delta.dependentDelta}, ` +
+            `packages ${delta.packageDelta >= 0 ? '+' : ''}${delta.packageDelta}` +
+            (delta.riskDrift ? `, risk ${delta.riskDrift}` : '') +
+            '.',
+        details: { delta },
+        nextCommands: [
+            'shrk impact baseline show',
+            'shrk impact --via-graph <target>',
+            'shrk impact baseline write',
+        ],
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/impact-gate.d.ts

@@ -0,0 +1,15 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IImpactGateOptions {
+    /** Git ref to diff against (e.g. 'main', 'origin/main', 'HEAD~5'). */
+    sinceRef?: string;
+    /** Risk levels that fail the gate. Default ['critical']. */
+    failOn?: readonly ('high' | 'critical')[];
+}
+/**
+ * Impact-engine gate. Reads `git diff --name-only` against `sinceRef`
+ * (default 'main') and runs `analyzeGraphImpact`. Fails when the
+ * computed risk is in `failOn`. Skipped when no files changed or the
+ * graph isn't indexed.
+ */
+export declare function impactGate(projectRoot: string, options?: IImpactGateOptions): IGateResult;
+//# sourceMappingURL=impact-gate.d.ts.map

package/dist/gates/impact-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-gate.d.ts","sourceRoot":"","sources":["../../src/gates/impact-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,CAAC;CAC3C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,WAAW,CA+C7F"}

package/dist/gates/impact-gate.js

@@ -0,0 +1,54 @@
+import { analyzeGraphImpact } from '@shrkcrft/impact-engine';
+/**
+ * Impact-engine gate. Reads `git diff --name-only` against `sinceRef`
+ * (default 'main') and runs `analyzeGraphImpact`. Fails when the
+ * computed risk is in `failOn`. Skipped when no files changed or the
+ * graph isn't indexed.
+ */
+export function impactGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const sinceRef = options.sinceRef ?? 'main';
+    const failOn = new Set(options.failOn ?? ['critical']);
+    const analysis = analyzeGraphImpact({ kind: 'gitref', ref: sinceRef }, { projectRoot });
+    if (analysis.diagnostics.some((d) => d.includes('code-graph store missing'))) {
+        return {
+            id: 'impact',
+            label: 'Impact (since ' + sinceRef + ')',
+            status: 'skipped',
+            message: 'Skipped — graph index missing.',
+            nextCommands: ['shrk graph index'],
+            durationMs: Date.now() - start,
+        };
+    }
+    if (analysis.normalizedTargets.length === 0) {
+        return {
+            id: 'impact',
+            label: 'Impact (since ' + sinceRef + ')',
+            status: 'skipped',
+            message: `No files changed since ${sinceRef}.`,
+            durationMs: Date.now() - start,
+        };
+    }
+    const status = failOn.has(analysis.risk) ? 'fail' : analysis.risk === 'high' ? 'warn' : 'pass';
+    const message = status === 'fail'
+        ? `Risk: ${analysis.risk}. ${analysis.directDependents.length} direct dependents.`
+        : status === 'warn'
+            ? `Risk: ${analysis.risk}. Review the validation scope.`
+            : `Risk: ${analysis.risk}. Looks safe.`;
+    return {
+        id: 'impact',
+        label: 'Impact (since ' + sinceRef + ')',
+        status,
+        message,
+        details: {
+            risk: analysis.risk,
+            reasons: analysis.riskReasons,
+            direct: analysis.directDependents.length,
+            transitive: analysis.transitiveDependents.length,
+            publicApiTouched: analysis.publicApiTouched,
+            validationScope: analysis.validationScope,
+        },
+        nextCommands: analysis.validationScope.length > 0 ? [...analysis.validationScope] : undefined,
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/intent-classifier-gate.d.ts

@@ -0,0 +1,15 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IIntentClassifierGateOptions {
+    /** Accuracy below this threshold fails the gate. Default 0.6. */
+    failBelow?: number;
+    /** Accuracy below this threshold warns. Default 0.95. */
+    warnBelow?: number;
+}
+/**
+ * Run the intent-classifier benchmark in-process and gate on the
+ * accuracy. Skipped when no fixture is present at
+ * `sharkcraft/intent-benchmark.json` (the feature is opt-in). The gate
+ * does NOT persist a fresh run report — that's the CLI's job.
+ */
+export declare function intentClassifierGate(projectRoot: string, options?: IIntentClassifierGateOptions): IGateResult;
+//# sourceMappingURL=intent-classifier-gate.d.ts.map

package/dist/gates/intent-classifier-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-classifier-gate.d.ts","sourceRoot":"","sources":["../../src/gates/intent-classifier-gate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,4BAA4B;IAC3C,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,4BAAiC,GACzC,WAAW,CAyDb"}

package/dist/gates/intent-classifier-gate.js

@@ -0,0 +1,64 @@
+import { loadIntentBenchmark, runIntentBenchmark, } from '@shrkcrft/context-planner';
+/**
+ * Run the intent-classifier benchmark in-process and gate on the
+ * accuracy. Skipped when no fixture is present at
+ * `sharkcraft/intent-benchmark.json` (the feature is opt-in). The gate
+ * does NOT persist a fresh run report — that's the CLI's job.
+ */
+export function intentClassifierGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const failBelow = options.failBelow ?? 0.6;
+    const warnBelow = options.warnBelow ?? 0.95;
+    const benchmark = loadIntentBenchmark(projectRoot);
+    if (!benchmark) {
+        return {
+            id: 'intent-classifier',
+            label: 'Intent classifier accuracy',
+            status: 'skipped',
+            message: 'No fixture at sharkcraft/intent-benchmark.json.',
+            durationMs: Date.now() - start,
+        };
+    }
+    if (benchmark.cases.length === 0) {
+        return {
+            id: 'intent-classifier',
+            label: 'Intent classifier accuracy',
+            status: 'skipped',
+            message: 'Benchmark has zero cases.',
+            durationMs: Date.now() - start,
+        };
+    }
+    const run = runIntentBenchmark(benchmark);
+    const pct = Math.round(run.accuracy * 1000) / 10;
+    if (run.accuracy >= warnBelow) {
+        return {
+            id: 'intent-classifier',
+            label: 'Intent classifier accuracy',
+            status: 'pass',
+            message: `Accuracy ${pct}% (${run.passed}/${run.total}).`,
+            details: { accuracy: run.accuracy, passed: run.passed, failed: run.failed, total: run.total },
+            durationMs: Date.now() - start,
+        };
+    }
+    const status = run.accuracy < failBelow ? 'fail' : 'warn';
+    const sample = run.cases
+        .filter((c) => !c.passed)
+        .slice(0, 3)
+        .map((c) => `expected=${c.expected}, actual=${c.actual}`)
+        .join('; ');
+    return {
+        id: 'intent-classifier',
+        label: 'Intent classifier accuracy',
+        status,
+        message: `Accuracy ${pct}% (${run.passed}/${run.total}). ${run.failed} miss(es): ${sample}.`,
+        details: {
+            accuracy: run.accuracy,
+            passed: run.passed,
+            failed: run.failed,
+            total: run.total,
+            threshold: { failBelow, warnBelow },
+        },
+        nextCommands: ['shrk context benchmark'],
+        durationMs: Date.now() - start,
+    };
+}

package/dist/gates/structural-patterns-gate.d.ts

@@ -0,0 +1,16 @@
+import type { IGateResult } from '../schema/quality-gate.js';
+export interface IStructuralPatternsGateOptions {
+    /**
+     * When true, an invalid registry entry fails the gate. Default
+     * `false` (warn) — broken patterns are a config issue, not a
+     * shippability blocker by themselves.
+     */
+    failOnInvalid?: boolean;
+}
+/**
+ * Validate the structural-pattern registry. Skipped when the registry
+ * file doesn't exist. Re-validates every entry in-memory (no fs writes
+ * here — the CLI's `registry validate` is the persistence path).
+ */
+export declare function structuralPatternsGate(projectRoot: string, options?: IStructuralPatternsGateOptions): IGateResult;
+//# sourceMappingURL=structural-patterns-gate.d.ts.map

package/dist/gates/structural-patterns-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structural-patterns-gate.d.ts","sourceRoot":"","sources":["../../src/gates/structural-patterns-gate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,8BAAmC,GAC3C,WAAW,CA2Cb"}

package/dist/gates/structural-patterns-gate.js

@@ -0,0 +1,50 @@
+import { PatternRegistryStore } from '@shrkcrft/structural-search';
+/**
+ * Validate the structural-pattern registry. Skipped when the registry
+ * file doesn't exist. Re-validates every entry in-memory (no fs writes
+ * here — the CLI's `registry validate` is the persistence path).
+ */
+export function structuralPatternsGate(projectRoot, options = {}) {
+    const start = Date.now();
+    const failOnInvalid = options.failOnInvalid ?? false;
+    const store = new PatternRegistryStore(projectRoot);
+    if (!store.exists()) {
+        return {
+            id: 'structural-patterns',
+            label: 'Structural pattern registry',
+            status: 'skipped',
+            message: 'No pattern registry — feature is opt-in.',
+            durationMs: Date.now() - start,
+        };
+    }
+    const reg = store.read();
+    if (reg.patterns.length === 0) {
+        return {
+            id: 'structural-patterns',
+            label: 'Structural pattern registry',
+            status: 'skipped',
+            message: 'Pattern registry is empty.',
+            durationMs: Date.now() - start,
+        };
+    }
+    const result = store.validateAll();
+    if (result.failed === 0) {
+        return {
+            id: 'structural-patterns',
+            label: 'Structural pattern registry',
+            status: 'pass',
+            message: `${result.total} pattern(s) valid.`,
+            details: { total: result.total },
+            durationMs: Date.now() - start,
+        };
+    }
+    return {
+        id: 'structural-patterns',
+        label: 'Structural pattern registry',
+        status: failOnInvalid ? 'fail' : 'warn',
+        message: `${result.failed}/${result.total} pattern(s) failed validation.`,
+        details: { total: result.total, failed: result.failed, errors: result.errors },
+        nextCommands: ['shrk search-structural registry validate', 'shrk search-structural registry list'],
+        durationMs: Date.now() - start,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './schema/quality-gate.js';
+export * from './gates/graph-fresh-gate.js';
+export * from './gates/arch-gate.js';
+export * from './gates/impact-gate.js';
+export * from './gates/api-diff-gate.js';
+export * from './gates/graph-cycles-gate.js';
+export * from './gates/graph-unresolved-gate.js';
+export * from './gates/impact-baseline-gate.js';
+export * from './gates/structural-patterns-gate.js';
+export * from './gates/intent-classifier-gate.js';
+export * from './runner/run-gates.js';
+export * from './runner/report-store.js';
+export * from './runner/render-markdown.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from "./schema/quality-gate.js";
+export * from "./gates/graph-fresh-gate.js";
+export * from "./gates/arch-gate.js";
+export * from "./gates/impact-gate.js";
+export * from "./gates/api-diff-gate.js";
+export * from "./gates/graph-cycles-gate.js";
+export * from "./gates/graph-unresolved-gate.js";
+export * from "./gates/impact-baseline-gate.js";
+export * from "./gates/structural-patterns-gate.js";
+export * from "./gates/intent-classifier-gate.js";
+export * from "./runner/run-gates.js";
+export * from "./runner/report-store.js";
+export * from "./runner/render-markdown.js";

package/dist/runner/render-markdown.d.ts

@@ -0,0 +1,15 @@
+import type { IQualityGateReport } from '../schema/quality-gate.js';
+/**
+ * PR-comment-ready markdown rendering of a quality-gate report.
+ *
+ * Sections (top-down):
+ *   1. Header with overall status badge.
+ *   2. Counts table (pass / warn / fail / skipped).
+ *   3. Per-gate detail rows with status icon, label, message, and
+ *      a fenced code block of next commands when present.
+ *
+ * Stable structure so downstream GitHub bots can diff it across runs
+ * without parsing JSON. Pure function — no I/O.
+ */
+export declare function renderGateReportMarkdown(report: IQualityGateReport): string;
+//# sourceMappingURL=render-markdown.d.ts.map

package/dist/runner/render-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-markdown.d.ts","sourceRoot":"","sources":["../../src/runner/render-markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEjF;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CA6B3E"}

package/dist/runner/render-markdown.js

@@ -0,0 +1,82 @@
+/**
+ * PR-comment-ready markdown rendering of a quality-gate report.
+ *
+ * Sections (top-down):
+ *   1. Header with overall status badge.
+ *   2. Counts table (pass / warn / fail / skipped).
+ *   3. Per-gate detail rows with status icon, label, message, and
+ *      a fenced code block of next commands when present.
+ *
+ * Stable structure so downstream GitHub bots can diff it across runs
+ * without parsing JSON. Pure function — no I/O.
+ */
+export function renderGateReportMarkdown(report) {
+    const lines = [];
+    lines.push(`# SharkCraft quality gates: ${statusBadge(report.overall)}`);
+    lines.push('');
+    lines.push(`Total duration: \`${report.totalDurationMs}ms\`.`);
+    lines.push('');
+    lines.push('| pass | warn | fail | skipped |');
+    lines.push('|---|---|---|---|');
+    lines.push(`| ${report.counts.pass} | ${report.counts.warn} | ${report.counts.fail} | ${report.counts.skipped} |`);
+    lines.push('');
+    if (report.gates.length === 0) {
+        lines.push('_(no gates ran)_');
+        return lines.join('\n') + '\n';
+    }
+    lines.push('## Gates');
+    lines.push('');
+    for (const gate of report.gates) {
+        lines.push(renderGate(gate));
+        lines.push('');
+    }
+    if (report.diagnostics.length > 0) {
+        lines.push('## Diagnostics');
+        for (const d of report.diagnostics.slice(0, 20)) {
+            lines.push(`- ${d}`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function statusBadge(status) {
+    switch (status) {
+        case 'pass':
+            return '✅ PASS';
+        case 'warn':
+            return '⚠️ WARN';
+        case 'fail':
+            return '❌ FAIL';
+        case 'skipped':
+            return '⏭️ SKIPPED';
+    }
+}
+function gateIcon(status) {
+    switch (status) {
+        case 'pass':
+            return '✅';
+        case 'warn':
+            return '⚠️';
+        case 'fail':
+            return '❌';
+        case 'skipped':
+            return '⏭️';
+    }
+}
+function renderGate(gate) {
+    const parts = [];
+    parts.push(`### ${gateIcon(gate.status)} \`${gate.id}\` — ${gate.label}`);
+    parts.push('');
+    parts.push(`**Status:** \`${gate.status}\` · **Duration:** \`${gate.durationMs}ms\``);
+    parts.push('');
+    parts.push(gate.message);
+    if (gate.nextCommands && gate.nextCommands.length > 0) {
+        parts.push('');
+        parts.push('Next steps:');
+        parts.push('');
+        parts.push('```bash');
+        for (const c of gate.nextCommands)
+            parts.push(c);
+        parts.push('```');
+    }
+    return parts.join('\n');
+}

package/dist/runner/report-store.d.ts

@@ -0,0 +1,19 @@
+import type { IQualityGateReport } from '../schema/quality-gate.js';
+/**
+ * Persist + load the most recent quality-gate report for a project.
+ *
+ * The dashboard's `/api/quality-gates` endpoint prefers a recent saved
+ * report over running the gates fresh on every page load. The CLI's
+ * `shrk gate` writes here after each run so the two paths agree.
+ */
+export declare class QualityGateReportStore {
+    private readonly projectRoot;
+    readonly absPath: string;
+    constructor(projectRoot: string);
+    exists(): boolean;
+    read(): IQualityGateReport | undefined;
+    write(report: IQualityGateReport): void;
+    /** Age of the saved report in milliseconds, or `undefined` when missing. */
+    ageMs(): number | undefined;
+}
+//# sourceMappingURL=report-store.d.ts.map

package/dist/runner/report-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-store.d.ts","sourceRoot":"","sources":["../../src/runner/report-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE;;;;;;GAMG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAFxC,SAAgB,OAAO,EAAE,MAAM,CAAC;gBAEH,WAAW,EAAE,MAAM;IAIhD,MAAM,IAAI,OAAO;IAIjB,IAAI,IAAI,kBAAkB,GAAG,SAAS;IAStC,KAAK,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAKvC,4EAA4E;IAC5E,KAAK,IAAI,MAAM,GAAG,SAAS;CAO5B"}

package/dist/runner/report-store.js

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const REPORT_REL = '.sharkcraft/quality-gates/last.json';
+/**
+ * Persist + load the most recent quality-gate report for a project.
+ *
+ * The dashboard's `/api/quality-gates` endpoint prefers a recent saved
+ * report over running the gates fresh on every page load. The CLI's
+ * `shrk gate` writes here after each run so the two paths agree.
+ */
+export class QualityGateReportStore {
+    projectRoot;
+    absPath;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.absPath = nodePath.join(projectRoot, REPORT_REL);
+    }
+    exists() {
+        return existsSync(this.absPath);
+    }
+    read() {
+        if (!this.exists())
+            return undefined;
+        try {
+            return JSON.parse(readFileSync(this.absPath, 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    write(report) {
+        mkdirSync(nodePath.dirname(this.absPath), { recursive: true });
+        writeFileSync(this.absPath, JSON.stringify(report, null, 2), 'utf8');
+    }
+    /** Age of the saved report in milliseconds, or `undefined` when missing. */
+    ageMs() {
+        const r = this.read();
+        if (!r)
+            return undefined;
+        const t = Date.parse(r.startedAt);
+        if (Number.isNaN(t))
+            return undefined;
+        return Date.now() - t;
+    }
+}

package/dist/runner/run-gates.d.ts

@@ -0,0 +1,53 @@
+import { type IApiDiffGateOptions } from '../gates/api-diff-gate.js';
+import { type IGraphCyclesGateOptions } from '../gates/graph-cycles-gate.js';
+import { type IGraphUnresolvedGateOptions } from '../gates/graph-unresolved-gate.js';
+import { type IImpactGateOptions } from '../gates/impact-gate.js';
+import { type IImpactBaselineGateOptions } from '../gates/impact-baseline-gate.js';
+import { type IIntentClassifierGateOptions } from '../gates/intent-classifier-gate.js';
+import { type IStructuralPatternsGateOptions } from '../gates/structural-patterns-gate.js';
+import { type IQualityGateReport } from '../schema/quality-gate.js';
+export interface IRunGatesOptions {
+    projectRoot: string;
+    /** Optional impact-gate config (sinceRef, failOn). */
+    impact?: IImpactGateOptions;
+    /**
+     * Optional api-diff gate config. When omitted, the api-diff gate is
+     * skipped — the baseline file is what opts a project in.
+     */
+    apiDiff?: IApiDiffGateOptions;
+    /** Optional graph-cycles gate config. */
+    graphCycles?: IGraphCyclesGateOptions;
+    /** Optional graph-unresolved gate config. */
+    graphUnresolved?: IGraphUnresolvedGateOptions;
+    /** Optional impact-baseline gate config. */
+    impactBaseline?: IImpactBaselineGateOptions;
+    /** Optional structural-patterns gate config. */
+    structuralPatterns?: IStructuralPatternsGateOptions;
+    /** Optional intent-classifier gate config. */
+    intentClassifier?: IIntentClassifierGateOptions;
+    /** Disable specific gates by id. */
+    disable?: readonly string[];
+}
+/**
+ * Run the quality-gate aggregator over a project.
+ *
+ * Default gate set:
+ *   - `graph-fresh`: code graph exists + digest matches
+ *   - `arch`: architecture-guard checks pass (no errors)
+ *   - `impact`: impact-engine risk is below threshold (since `main`)
+ *   - `graph-cycles`: surface import cycles (warn on threshold)
+ *   - `graph-unresolved`: surface unresolved imports (warn by default)
+ *   - `impact-baseline`: skipped unless a baseline is frozen, warn
+ *     when worsened since baseline
+ *   - `structural-patterns`: skipped unless a registry exists, warn
+ *     on any invalid entry
+ *   - `intent-classifier`: skipped unless a fixture exists, warn /
+ *     fail below the configured accuracy threshold
+ *   - `api-diff`: skipped unless options.apiDiff is provided
+ *
+ * Returns a single structured report with an `overall` status that's
+ * `fail` if any gate failed, `warn` if any gate warned, `pass`
+ * otherwise.
+ */
+export declare function runQualityGates(options: IRunGatesOptions): IQualityGateReport;
+//# sourceMappingURL=run-gates.d.ts.map

package/dist/runner/run-gates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-gates.d.ts","sourceRoot":"","sources":["../../src/runner/run-gates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAElF,OAAO,EAAmB,KAAK,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE9F,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B;;;OAGG;IACH,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,yCAAyC;IACzC,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC,6CAA6C;IAC7C,eAAe,CAAC,EAAE,2BAA2B,CAAC;IAC9C,4CAA4C;IAC5C,cAAc,CAAC,EAAE,0BAA0B,CAAC;IAC5C,gDAAgD;IAChD,kBAAkB,CAAC,EAAE,8BAA8B,CAAC;IACpD,8CAA8C;IAC9C,gBAAgB,CAAC,EAAE,4BAA4B,CAAC;IAChD,oCAAoC;IACpC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,kBAAkB,CAkD7E"}

package/dist/runner/run-gates.js

@@ -0,0 +1,79 @@
+import { apiDiffGate } from "../gates/api-diff-gate.js";
+import { archGate } from "../gates/arch-gate.js";
+import { graphCyclesGate } from "../gates/graph-cycles-gate.js";
+import { graphFreshGate } from "../gates/graph-fresh-gate.js";
+import { graphUnresolvedGate, } from "../gates/graph-unresolved-gate.js";
+import { impactGate } from "../gates/impact-gate.js";
+import { impactBaselineGate, } from "../gates/impact-baseline-gate.js";
+import { intentClassifierGate, } from "../gates/intent-classifier-gate.js";
+import { structuralPatternsGate, } from "../gates/structural-patterns-gate.js";
+import { QUALITY_GATE_SCHEMA, } from "../schema/quality-gate.js";
+/**
+ * Run the quality-gate aggregator over a project.
+ *
+ * Default gate set:
+ *   - `graph-fresh`: code graph exists + digest matches
+ *   - `arch`: architecture-guard checks pass (no errors)
+ *   - `impact`: impact-engine risk is below threshold (since `main`)
+ *   - `graph-cycles`: surface import cycles (warn on threshold)
+ *   - `graph-unresolved`: surface unresolved imports (warn by default)
+ *   - `impact-baseline`: skipped unless a baseline is frozen, warn
+ *     when worsened since baseline
+ *   - `structural-patterns`: skipped unless a registry exists, warn
+ *     on any invalid entry
+ *   - `intent-classifier`: skipped unless a fixture exists, warn /
+ *     fail below the configured accuracy threshold
+ *   - `api-diff`: skipped unless options.apiDiff is provided
+ *
+ * Returns a single structured report with an `overall` status that's
+ * `fail` if any gate failed, `warn` if any gate warned, `pass`
+ * otherwise.
+ */
+export function runQualityGates(options) {
+    const startedAt = new Date().toISOString();
+    const start = Date.now();
+    const disabled = new Set(options.disable ?? []);
+    const diagnostics = [];
+    const gates = [];
+    // graph-fresh is always first — other gates depend on it.
+    if (!disabled.has('graph-fresh')) {
+        gates.push(graphFreshGate(options.projectRoot));
+    }
+    if (!disabled.has('arch')) {
+        gates.push(archGate(options.projectRoot));
+    }
+    if (!disabled.has('impact')) {
+        gates.push(impactGate(options.projectRoot, options.impact ?? {}));
+    }
+    if (!disabled.has('graph-cycles')) {
+        gates.push(graphCyclesGate(options.projectRoot, options.graphCycles ?? {}));
+    }
+    if (!disabled.has('graph-unresolved')) {
+        gates.push(graphUnresolvedGate(options.projectRoot, options.graphUnresolved ?? {}));
+    }
+    if (!disabled.has('impact-baseline')) {
+        gates.push(impactBaselineGate(options.projectRoot, options.impactBaseline ?? {}));
+    }
+    if (!disabled.has('structural-patterns')) {
+        gates.push(structuralPatternsGate(options.projectRoot, options.structuralPatterns ?? {}));
+    }
+    if (!disabled.has('intent-classifier')) {
+        gates.push(intentClassifierGate(options.projectRoot, options.intentClassifier ?? {}));
+    }
+    if (!disabled.has('api-diff') && options.apiDiff) {
+        gates.push(apiDiffGate(options.projectRoot, options.apiDiff));
+    }
+    const counts = { pass: 0, fail: 0, warn: 0, skipped: 0 };
+    for (const g of gates)
+        counts[g.status] += 1;
+    const overall = counts.fail > 0 ? 'fail' : counts.warn > 0 ? 'warn' : counts.pass > 0 ? 'pass' : 'skipped';
+    return {
+        schema: QUALITY_GATE_SCHEMA,
+        overall,
+        startedAt,
+        totalDurationMs: Date.now() - start,
+        counts,
+        gates,
+        diagnostics,
+    };
+}

package/dist/schema/quality-gate.d.ts

@@ -0,0 +1,28 @@
+export declare const QUALITY_GATE_SCHEMA: "sharkcraft.quality-gate-report/v1";
+export type GateStatus = 'pass' | 'fail' | 'warn' | 'skipped';
+export interface IGateResult {
+    /** Stable id (e.g. 'graph-fresh', 'arch', 'impact'). */
+    id: string;
+    /** Display label. */
+    label: string;
+    status: GateStatus;
+    /** Short human-readable headline. */
+    message: string;
+    /** Optional details a renderer can use (counts, severity, etc.). */
+    details?: Readonly<Record<string, unknown>>;
+    /** Suggested follow-up command(s) the human / agent can run. */
+    nextCommands?: readonly string[];
+    /** Wall-clock duration of the gate, in ms. */
+    durationMs: number;
+}
+export interface IQualityGateReport {
+    schema: typeof QUALITY_GATE_SCHEMA;
+    overall: GateStatus;
+    startedAt: string;
+    totalDurationMs: number;
+    /** Counts by status, for fast renderers. */
+    counts: Readonly<Record<GateStatus, number>>;
+    gates: readonly IGateResult[];
+    diagnostics: readonly string[];
+}
+//# sourceMappingURL=quality-gate.d.ts.map

package/dist/schema/quality-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-gate.d.ts","sourceRoot":"","sources":["../../src/schema/quality-gate.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,EAAG,mCAA4C,CAAC;AAEhF,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAE9D,MAAM,WAAW,WAAW;IAC1B,wDAAwD;IACxD,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC5C,gEAAgE;IAChE,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,mBAAmB,CAAC;IACnC,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7C,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC"}

package/dist/schema/quality-gate.js

@@ -0,0 +1 @@
+export const QUALITY_GATE_SCHEMA = 'sharkcraft.quality-gate-report/v1';

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@shrkcrft/quality-gates",
+  "version": "0.1.0-alpha.10",
+  "description": "SharkCraft quality gates: single aggregator that runs the code-intelligence checks (graph index, boundaries, architecture, impact summary) and emits one pass/fail report. The pre-merge gate for AI-agent-authored changes.",
+  "license": "MIT",
+  "author": "SharkCraft contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sharkcraft/sharkcraft.git",
+    "directory": "packages/quality-gates"
+  },
+  "homepage": "https://github.com/sharkcraft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/sharkcraft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "quality-gates",
+    "pre-merge",
+    "code-intelligence"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.10",
+    "@shrkcrft/graph": "^0.1.0-alpha.10",
+    "@shrkcrft/architecture-guard": "^0.1.0-alpha.10",
+    "@shrkcrft/impact-engine": "^0.1.0-alpha.10",
+    "@shrkcrft/api-surface-diff": "^0.1.0-alpha.10",
+    "@shrkcrft/boundaries": "^0.1.0-alpha.10",
+    "@shrkcrft/structural-search": "^0.1.0-alpha.10",
+    "@shrkcrft/context-planner": "^0.1.0-alpha.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}