@rigour-labs/core 6.6.5 → 6.7.0

package/dist/review/typed/schema-nullability.js

@@ -0,0 +1,218 @@
+/**
+ * Which table columns are NOT NULL, replayed from SQL migrations in file order, so a row type that
+ * says `| null` for one can be called out: every guard on it is dead. The migrations may live in
+ * another repository (`gates.redundancy.schema_migrations`), read only.
+ *
+ * Conservative by construction: a column is NOT NULL only when a statement Rigour understands made
+ * it so (a column definition, a primary key, `SET NOT NULL`). A table created any other way
+ * (`AS SELECT`, `LIKE`, `PARTITION OF`) or altered in a way not followed here is unknown, and an
+ * unknown table or column is never reported.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const DEFAULT_SCHEMA = 'public';
+/** The migrations in `dirs` (relative to the repository, absolute, or `~/`), replayed in file-name order. Missing folders are skipped. */
+export function loadSchemaNullability(root, dirs) {
+    const files = [];
+    for (const dir of dirs) {
+        const full = dir.startsWith('~/') ? path.join(os.homedir(), dir.slice(2)) : path.resolve(root, dir);
+        let names;
+        try {
+            names = fs.readdirSync(full).filter(name => name.endsWith('.sql'));
+        }
+        catch {
+            continue;
+        }
+        files.push(...names.map(name => path.join(full, name)));
+    }
+    files.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+    const schema = new Map();
+    for (const file of files)
+        applyMigration(schema, fs.readFileSync(file, 'utf8'));
+    return schema;
+}
+/** Applies one migration's statements to the schema in place. */
+function applyMigration(schema, sql) {
+    for (const statement of statements(sql)) {
+        const create = /^create\s+(?:(?:global|local)\s+)?(?:(?:temp|temporary|unlogged)\s+)?table\s+(?:if\s+not\s+exists\s+)?([\w."]+)\s*([\s\S]*)$/i.exec(statement);
+        if (create) {
+            createTable(schema, tableKey(create[1]), create[2]);
+            continue;
+        }
+        const alter = /^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?([\w."]+)\s+([\s\S]*)$/i.exec(statement);
+        if (alter) {
+            alterTable(schema, tableKey(alter[1]), alter[2]);
+            continue;
+        }
+        const drop = /^drop\s+table\s+(?:if\s+exists\s+)?([\w.",\s]+?)(?:\s+(?:cascade|restrict))?$/i.exec(statement);
+        if (drop)
+            for (const name of splitTopLevel(drop[1]))
+                schema.delete(tableKey(name));
+    }
+}
+function createTable(schema, key, rest) {
+    const body = /^\(([\s\S]*)\)/.exec(rest.trim());
+    if (!body || /^\(\s*like\s/i.test(rest.trim()) || /partition\s+of/i.test(rest)) {
+        schema.set(key, null);
+        return;
+    }
+    const columns = new Map();
+    for (const part of splitTopLevel(matchingParen(rest.trim()))) {
+        const primary = /^(?:constraint\s+[\w"]+\s+)?primary\s+key\s*\(([^)]*)\)/i.exec(part);
+        if (primary) {
+            for (const col of primary[1].split(','))
+                columns.set(ident(col), true);
+            continue;
+        }
+        if (/^(?:constraint|unique|check|foreign\s+key|exclude|like)\b/i.test(part))
+            continue;
+        const column = columnDefinition(part);
+        if (column)
+            columns.set(column.name, column.notNull);
+    }
+    schema.set(key, columns);
+}
+function alterTable(schema, key, actions) {
+    const rename = /^rename\s+to\s+([\w."]+)$/i.exec(actions.trim());
+    if (rename) {
+        const table = schema.get(key);
+        schema.delete(key);
+        schema.set(`${key.split('.')[0]}.${ident(rename[1].split('.').pop())}`, table ?? null);
+        return;
+    }
+    const columns = schema.get(key);
+    if (!columns)
+        return; // unknown table: stays unknown
+    for (const action of splitTopLevel(actions)) {
+        const add = /^add\s+(?:column\s+)?(?:if\s+not\s+exists\s+)?([\s\S]+)$/i.exec(action);
+        if (add && !/^(?:constraint|primary|unique|check|foreign)\b/i.test(add[1])) {
+            const column = columnDefinition(add[1]);
+            if (column)
+                columns.set(column.name, column.notNull);
+            continue;
+        }
+        const primary = /^add\s+(?:constraint\s+[\w"]+\s+)?primary\s+key\s*\(([^)]*)\)/i.exec(action);
+        if (primary) {
+            for (const col of primary[1].split(','))
+                columns.set(ident(col), true);
+            continue;
+        }
+        const nullability = /^alter\s+(?:column\s+)?([\w"]+)\s+(set|drop)\s+not\s+null$/i.exec(action);
+        if (nullability) {
+            columns.set(ident(nullability[1]), nullability[2].toLowerCase() === 'set');
+            continue;
+        }
+        const dropColumn = /^drop\s+(?:column\s+)?(?:if\s+exists\s+)?([\w"]+)/i.exec(action);
+        if (dropColumn && !/^drop\s+constraint\b/i.test(action)) {
+            columns.delete(ident(dropColumn[1]));
+            continue;
+        }
+        const renameColumn = /^rename\s+(?:column\s+)?([\w"]+)\s+to\s+([\w"]+)$/i.exec(action);
+        if (renameColumn && columns.has(ident(renameColumn[1]))) {
+            columns.set(ident(renameColumn[2]), columns.get(ident(renameColumn[1])));
+            columns.delete(ident(renameColumn[1]));
+        }
+    }
+}
+function columnDefinition(text) {
+    const match = /^("(?:[^"]|"")+"|[a-z_][\w$]*)\s+([\s\S]+)$/i.exec(text.trim());
+    if (!match)
+        return undefined;
+    // Strings and parenthesised expressions (a CHECK, a default, a generated column) say nothing about this column's own constraint.
+    let rest = match[2].replace(/'(?:[^']|'')*'/g, "''");
+    while (/\([^()]*\)/.test(rest))
+        rest = rest.replace(/\([^()]*\)/g, '');
+    return { name: ident(match[1]), notNull: /\bnot\s+null\b|\bprimary\s+key\b/i.test(rest) };
+}
+/** `schema.table` with Postgres's folding: unquoted names lower-cased, the schema `public` by default. */
+export function tableKey(name) {
+    const parts = name.trim().match(/"(?:[^"]|"")+"|[^.]+/g) ?? [];
+    const table = parts.at(-1) ?? '';
+    const schema = (parts.length > 1 && parts[0]) || DEFAULT_SCHEMA;
+    return `${ident(schema)}.${ident(table)}`;
+}
+function ident(name) {
+    const trimmed = name.trim();
+    return trimmed.startsWith('"') ? trimmed.slice(1, -1).replace(/""/g, '"') : trimmed.toLowerCase();
+}
+/** The text inside the parenthesis that opens `text`. */
+function matchingParen(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '(')
+            depth++;
+        else if (text[i] === ')' && --depth === 0)
+            return text.slice(1, i);
+    }
+    return text.slice(1);
+}
+/** Splits on commas outside parentheses and quotes. */
+function splitTopLevel(text) {
+    const parts = [];
+    let depth = 0;
+    let quote = '';
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === quote)
+                quote = '';
+        }
+        else if (c === "'" || c === '"')
+            quote = c;
+        else if (c === '(')
+            depth++;
+        else if (c === ')')
+            depth--;
+        else if (c === ',' && depth === 0) {
+            parts.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start).trim());
+    return parts.filter(Boolean);
+}
+/** The statements of a migration, comments removed, function bodies and strings kept whole. */
+function statements(sql) {
+    const out = [];
+    let current = '';
+    let i = 0;
+    while (i < sql.length) {
+        const rest = sql.slice(i);
+        const dollar = /^\$[\w]*\$/.exec(rest);
+        if (rest.startsWith('--')) {
+            const end = sql.indexOf('\n', i);
+            i = end === -1 ? sql.length : end;
+        }
+        else if (rest.startsWith('/*')) {
+            const end = sql.indexOf('*/', i + 2);
+            i = end === -1 ? sql.length : end + 2;
+        }
+        else if (dollar) {
+            const end = sql.indexOf(dollar[0], i + dollar[0].length);
+            const stop = end === -1 ? sql.length : end + dollar[0].length;
+            current += sql.slice(i, stop);
+            i = stop;
+        }
+        else if (sql[i] === "'" || sql[i] === '"') {
+            let j = i + 1;
+            while (j < sql.length && !(sql[j] === sql[i] && sql[j + 1] !== sql[i]))
+                j += sql[j] === sql[i] ? 2 : 1;
+            current += sql.slice(i, j + 1);
+            i = j + 1;
+        }
+        else if (sql[i] === ';') {
+            out.push(current.trim().replace(/\s+/g, ' '));
+            current = '';
+            i++;
+        }
+        else {
+            current += sql[i];
+            i++;
+        }
+    }
+    if (current.trim())
+        out.push(current.trim().replace(/\s+/g, ' '));
+    return out.filter(Boolean);
+}

package/dist/review/typed/schema-nullability.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/review/typed/schema-nullability.test.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, expect, it } from 'vitest';
+import { loadSchemaNullability, tableKey } from './schema-nullability.js';
+/** The migrations as numbered files in a folder of their own, replayed. */
+const replay = (...migrations) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'migrations-'));
+    try {
+        migrations.forEach((sql, i) => fs.writeFileSync(path.join(dir, `${String(i).padStart(3, '0')}_step.sql`), sql));
+        return loadSchemaNullability(dir, ['.']);
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+};
+const columns = (schema, table) => Object.fromEntries(schema.get(tableKey(table)) ?? []);
+describe('NOT NULL columns from migrations', () => {
+    it('reads column definitions, primary keys and quoted names, ignoring strings, comments and CHECK text', () => {
+        const schema = replay(`
+-- a comment; with a semicolon
+create table if not exists public.study_set (
+    id uuid primary key default gen_random_uuid(),
+    "OwnerId" uuid not null references auth.users(id),
+    title text default 'not null' ,
+    archived_at timestamptz check (archived_at is not null or title is null),
+    kind text NOT NULL,
+    /* block; comment */
+    constraint study_set_title_unique unique (title)
+);`);
+        expect(columns(schema, 'study_set')).toEqual({ id: true, OwnerId: true, title: false, archived_at: false, kind: true });
+    });
+    it('follows ALTER TABLE in file order: add, set and drop NOT NULL, rename, drop column, rename table', () => {
+        const schema = replay('create table app.card (id bigint, set_id bigint, body text);', `alter table only app.card add column if not exists due_at timestamptz not null default now(),
+                alter column set_id set not null, add constraint card_pk primary key (id);`, 'alter table app.card alter column body set not null; alter table app.card alter column body drop not null;', 'alter table app.card rename column due_at to next_due_at; alter table app.card drop column if exists body;', 'alter table app.card rename to flashcard;');
+        expect(schema.has(tableKey('app.card'))).toBe(false);
+        expect(columns(schema, 'app.flashcard')).toEqual({ id: true, set_id: true, next_due_at: true });
+    });
+    it('keeps a function body whole and treats tables it cannot read as unknown', () => {
+        const schema = replay(`create function touch() returns trigger language plpgsql as $$ begin new.updated_at = now(); return new; end; $$;
+             create table copy as select * from other;
+             create table part partition of parent for values in (1);
+             create table gone (id int not null); drop table if exists gone cascade;`);
+        expect(schema.get(tableKey('copy'))).toBeNull();
+        expect(schema.get(tableKey('part'))).toBeNull();
+        expect(schema.has(tableKey('gone'))).toBe(false);
+    });
+    it('loads every folder named, in file-name order across them, skipping one that does not exist', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-'));
+        try {
+            fs.mkdirSync(path.join(root, 'a'));
+            fs.mkdirSync(path.join(root, 'b'));
+            fs.writeFileSync(path.join(root, 'b', '20240101_create.sql'), 'create table t (id int, note text);');
+            fs.writeFileSync(path.join(root, 'a', '20240202_tighten.sql'), 'alter table t alter column note set not null;');
+            fs.writeFileSync(path.join(root, 'a', 'README.md'), 'not sql');
+            const schema = loadSchemaNullability(root, ['a', path.join(root, 'b'), 'missing']);
+            expect(columns(schema, 't')).toEqual({ id: false, note: true });
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/review/unused-exports.js

@@ -5,16 +5,19 @@
  * dead exports pile up in agent-written code. Only exports on added lines are checked. Another
  * file uses an export when it names the symbol as a whole word AND points at the module: an import,
  * re-export, dynamic import or mock whose specifier ends in the module's name (its folder's, for an
- * index file). A same-named word elsewhere, such as an unrelated route parameter, is not a use. What a framework calls by convention
- * (SvelteKit and Next.js route modules, hooks, serverless functions) is never reported.
+ * index file). A same-named word elsewhere, such as an unrelated route parameter, is not a use, and
+ * neither is a test: an export only its tests import is dead in production, and exporting a thing
+ * for its test is the habit that keeps it so. What a framework calls by convention (SvelteKit and
+ * Next.js route modules, hooks, serverless functions) is never reported.
  */
 import { spawnSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 import { emitsDeclarations, isPackageEntry } from './package-layout.js';
+import { isTestFile } from './test-files.js';
 const GIT_TIMEOUT_MS = 10_000;
 const CODE = /\.(ts|tsx|js|jsx|mjs|svelte)$/;
-const SKIPPED = /\.(test|spec)\.|\.d\.ts$|(^|\/)(dist|build|out|coverage|\.next|[\w-]+-dist)\//;
+const SKIPPED = /\.d\.ts$|(^|\/)(dist|build|out|coverage|\.next|[\w-]+-dist)\//;
 /** What a route or hook module exports for its framework, not for an importer. */
 const FRAMEWORK_EXPORTS = new Set([
     'load', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD', 'fallback', 'actions',
@@ -59,7 +62,7 @@ function addedExports(diff) {
         if (!file || text.startsWith('-'))
             continue;
         if (text.startsWith('+')) {
-            if (CODE.test(file) && !SKIPPED.test(file))
+            if (CODE.test(file) && !SKIPPED.test(file) && !isTestFile(file))
                 found.push(...exportsOn(text.slice(1), file, line));
             line++;
         }
@@ -109,7 +112,7 @@ export function unusedExportFailures(cwd, diff, config) {
         return []; // git could not answer: say nothing rather than guess
     const points = pointsAtCache(cwd);
     return candidates
-        .filter(exp => ![...(users.get(exp.name) ?? [])].some(user => !isOwnFile(user, exp) && points(user, exp.file)))
+        .filter(exp => ![...(users.get(exp.name) ?? [])].some(user => !isOwnFile(user, exp) && !isTestFile(user) && points(user, exp.file)))
         .map(unused);
 }
 /**
@@ -178,8 +181,8 @@ function filesNaming(cwd, names, excluded) {
 function unused(exp) {
     return {
         id: 'unused-export',
-        title: 'Unused export',
-        details: `\`${exp.name}\` is exported but no other file uses it. An export nothing imports is dead code that readers and agents treat as part of the module's contract.`,
+        title: `Unused export \`${exp.name}\``,
+        details: `\`${exp.name}\` is exported but no other file uses it (a test is not a consumer). An export nothing imports is dead code that readers and agents treat as part of the module's contract.`,
         severity: 'medium',
         provenance: 'traditional',
         files: [exp.file],

package/dist/semantic/learn/types.d.ts

@@ -384,7 +384,6 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         maxHits: number;
         repoHits: string[];
     };
-    version: 1;
     id: string;
     severity: "high" | "medium" | "low";
     source: {
@@ -392,6 +391,7 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         file: string;
         commit?: string | undefined;
     };
+    version: 1;
     pattern: {
         template: "require-option";
         callee: {
@@ -427,7 +427,6 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         maxHits: number;
         repoHits: string[];
     };
-    version: 1;
     id: string;
     severity: "high" | "medium" | "low";
     source: {
@@ -435,6 +434,7 @@ export declare const LearnedRuleSchema: z.ZodObject<{
         file: string;
         commit?: string | undefined;
     };
+    version: 1;
     pattern: {
         template: "require-option";
         callee: {

package/dist/services/adaptive-thresholds.d.ts

@@ -1,45 +1,8 @@
 /**
- * Adaptive Thresholds Service (v2)
- *
- * Dynamically adjusts quality gate thresholds based on:
- * - Project maturity (age, commit count, file count)
- * - Historical failure rates with Z-score anomaly detection
- * - Complexity tier (hobby/startup/enterprise)
- * - Per-provenance trend analysis (ai-drift, structural, security separate)
- *
- * v2 upgrades:
- * - Z-score replaces naive delta comparison for trend detection
- * - Per-provenance failure tracking (AI drift vs structural vs security)
- * - Statistical anomaly detection normalizes across project sizes
- *
+ * Quality history: every gate run's failures by provenance, kept in .rigour/adaptive-history.json, and the
+ * trends read from it (Z-score of recent runs against the earlier baseline), overall and per provenance.
  */
-export type ComplexityTier = 'hobby' | 'startup' | 'enterprise';
 export type QualityTrend = 'improving' | 'stable' | 'degrading';
-export interface ProjectMetrics {
-    fileCount: number;
-    commitCount?: number;
-    ageInDays?: number;
-    testCoverage?: number;
-    recentFailureRate?: number;
-}
-export interface AdaptiveConfig {
-    enabled?: boolean;
-    base_coverage_threshold?: number;
-    base_quality_threshold?: number;
-    auto_detect_tier?: boolean;
-    forced_tier?: ComplexityTier;
-}
-export interface ThresholdAdjustments {
-    tier: ComplexityTier;
-    trend: QualityTrend;
-    coverageThreshold: number;
-    qualityThreshold: number;
-    securityBlockLevel: 'critical' | 'high' | 'medium' | 'low';
-    leniencyFactor: number;
-    reasoning: string[];
-    /** Per-provenance trend breakdown (new in v5) */
-    provenanceTrends?: ProvenanceTrends;
-}
 export interface ProvenanceRunData {
     aiDriftFailures: number;
     structuralFailures: number;
@@ -88,20 +51,7 @@ export declare function getQualityTrend(cwd: string): QualityTrend;
  * Falls back gracefully for legacy history data without provenance.
  */
 export declare function getProvenanceTrends(cwd: string): ProvenanceTrends;
-/**
- * Detect project complexity tier based on metrics
- */
-export declare function detectComplexityTier(metrics: ProjectMetrics): ComplexityTier;
-/**
- * Calculate adaptive thresholds based on project state.
- * v5: Uses Z-score trending and per-provenance analysis.
- */
-export declare function calculateAdaptiveThresholds(cwd: string, metrics: ProjectMetrics, config?: AdaptiveConfig): ThresholdAdjustments;
 /**
  * Clear adaptive history (for testing)
  */
 export declare function clearAdaptiveHistory(cwd: string): void;
-/**
- * Get summary of adaptive thresholds for logging
- */
-export declare function getAdaptiveSummary(adjustments: ThresholdAdjustments): string;

package/dist/services/adaptive-thresholds.js

@@ -1,17 +1,6 @@
 /**
- * Adaptive Thresholds Service (v2)
- *
- * Dynamically adjusts quality gate thresholds based on:
- * - Project maturity (age, commit count, file count)
- * - Historical failure rates with Z-score anomaly detection
- * - Complexity tier (hobby/startup/enterprise)
- * - Per-provenance trend analysis (ai-drift, structural, security separate)
- *
- * v2 upgrades:
- * - Z-score replaces naive delta comparison for trend detection
- * - Per-provenance failure tracking (AI drift vs structural vs security)
- * - Statistical anomaly detection normalizes across project sizes
- *
+ * Quality history: every gate run's failures by provenance, kept in .rigour/adaptive-history.json, and the
+ * trends read from it (Z-score of recent runs against the earlier baseline), overall and per provenance.
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -182,123 +171,6 @@ export function getProvenanceTrends(cwd) {
         securityZScore: security.z,
     };
 }
-/**
- * Detect project complexity tier based on metrics
- */
-export function detectComplexityTier(metrics) {
-    // Enterprise: Large teams, many files, mature codebase
-    if (metrics.fileCount > 500 || (metrics.commitCount && metrics.commitCount > 1000)) {
-        return 'enterprise';
-    }
-    // Startup: Growing codebase, active development
-    if (metrics.fileCount > 50 || (metrics.commitCount && metrics.commitCount > 100)) {
-        return 'startup';
-    }
-    // Hobby: Small projects, early stage
-    return 'hobby';
-}
-/**
- * Calculate adaptive thresholds based on project state.
- * v5: Uses Z-score trending and per-provenance analysis.
- */
-export function calculateAdaptiveThresholds(cwd, metrics, config = {}) {
-    const reasoning = [];
-    // Determine tier
-    const tier = config.forced_tier ??
-        (config.auto_detect_tier !== false ? detectComplexityTier(metrics) : 'startup');
-    reasoning.push(`Complexity tier: ${tier} (files: ${metrics.fileCount})`);
-    // Get overall trend (Z-score based)
-    const trend = getQualityTrend(cwd);
-    reasoning.push(`Quality trend: ${trend} (Z-score analysis)`);
-    // Get per-provenance trends
-    const provenanceTrends = getProvenanceTrends(cwd);
-    if (provenanceTrends.aiDrift !== 'stable') {
-        reasoning.push(`AI drift trend: ${provenanceTrends.aiDrift} (Z=${provenanceTrends.aiDriftZScore})`);
-    }
-    if (provenanceTrends.structural !== 'stable') {
-        reasoning.push(`Structural trend: ${provenanceTrends.structural} (Z=${provenanceTrends.structuralZScore})`);
-    }
-    if (provenanceTrends.security !== 'stable') {
-        reasoning.push(`Security trend: ${provenanceTrends.security} (Z=${provenanceTrends.securityZScore})`);
-    }
-    // Base thresholds
-    let coverageThreshold = config.base_coverage_threshold ?? 80;
-    let qualityThreshold = config.base_quality_threshold ?? 80;
-    let securityBlockLevel = 'high';
-    let leniencyFactor = 0.5;
-    // Adjust by tier
-    switch (tier) {
-        case 'hobby':
-            coverageThreshold = Math.max(50, coverageThreshold - 30);
-            qualityThreshold = Math.max(60, qualityThreshold - 20);
-            securityBlockLevel = 'critical';
-            leniencyFactor = 0.8;
-            reasoning.push('Hobby tier: relaxed thresholds, only critical security blocks');
-            break;
-        case 'startup':
-            coverageThreshold = Math.max(60, coverageThreshold - 15);
-            qualityThreshold = Math.max(70, qualityThreshold - 10);
-            securityBlockLevel = 'high';
-            leniencyFactor = 0.5;
-            reasoning.push('Startup tier: moderate thresholds, high+ security blocks');
-            break;
-        case 'enterprise':
-            coverageThreshold = coverageThreshold;
-            qualityThreshold = qualityThreshold;
-            securityBlockLevel = 'medium';
-            leniencyFactor = 0.2;
-            reasoning.push('Enterprise tier: strict thresholds, medium+ security blocks');
-            break;
-    }
-    // Adjust by overall trend
-    if (trend === 'improving') {
-        coverageThreshold = Math.max(50, coverageThreshold - 5);
-        qualityThreshold = Math.max(60, qualityThreshold - 5);
-        leniencyFactor = Math.min(1, leniencyFactor + 0.1);
-        reasoning.push('Improving trend: bonus threshold relaxation (+5%)');
-    }
-    else if (trend === 'degrading') {
-        coverageThreshold = Math.min(95, coverageThreshold + 5);
-        qualityThreshold = Math.min(95, qualityThreshold + 5);
-        leniencyFactor = Math.max(0, leniencyFactor - 0.1);
-        reasoning.push('Degrading trend: tightened thresholds (-5%)');
-    }
-    // v5: Per-provenance adjustments
-    // If AI drift is degrading but structural is stable, tighten AI-specific gates
-    if (provenanceTrends.aiDrift === 'degrading' && provenanceTrends.structural !== 'degrading') {
-        leniencyFactor = Math.max(0, leniencyFactor - 0.15);
-        reasoning.push('AI drift degrading while structural stable: AI is the problem, tightening AI gates');
-    }
-    // If security is degrading, escalate security block level
-    if (provenanceTrends.security === 'degrading') {
-        if (securityBlockLevel === 'critical')
-            securityBlockLevel = 'high';
-        else if (securityBlockLevel === 'high')
-            securityBlockLevel = 'medium';
-        reasoning.push(`Security trend degrading: escalated block level to ${securityBlockLevel}+`);
-    }
-    // Recent failure rate adjustment
-    if (metrics.recentFailureRate !== undefined) {
-        if (metrics.recentFailureRate > 50) {
-            leniencyFactor = Math.min(1, leniencyFactor + 0.2);
-            reasoning.push(`High failure rate (${metrics.recentFailureRate.toFixed(0)}%): increased leniency`);
-        }
-        else if (metrics.recentFailureRate < 10) {
-            leniencyFactor = Math.max(0, leniencyFactor - 0.1);
-            reasoning.push(`Low failure rate (${metrics.recentFailureRate.toFixed(0)}%): stricter enforcement`);
-        }
-    }
-    return {
-        tier,
-        trend,
-        coverageThreshold: Math.round(coverageThreshold),
-        qualityThreshold: Math.round(qualityThreshold),
-        securityBlockLevel,
-        leniencyFactor: Math.round(leniencyFactor * 100) / 100,
-        reasoning,
-        provenanceTrends,
-    };
-}
 /**
  * Clear adaptive history (for testing)
  */
@@ -309,20 +181,3 @@ export function clearAdaptiveHistory(cwd) {
         fs.unlinkSync(historyPath);
     }
 }
-/**
- * Get summary of adaptive thresholds for logging
- */
-export function getAdaptiveSummary(adjustments) {
-    let summary = `[${adjustments.tier.toUpperCase()}] ` +
-        `Coverage: ${adjustments.coverageThreshold}%, ` +
-        `Quality: ${adjustments.qualityThreshold}%, ` +
-        `Security: ${adjustments.securityBlockLevel}+, ` +
-        `Trend: ${adjustments.trend}`;
-    if (adjustments.provenanceTrends) {
-        const pt = adjustments.provenanceTrends;
-        if (pt.aiDrift !== 'stable' || pt.structural !== 'stable' || pt.security !== 'stable') {
-            summary += ` | AI:${pt.aiDrift}(Z=${pt.aiDriftZScore}) Struct:${pt.structural}(Z=${pt.structuralZScore}) Sec:${pt.security}(Z=${pt.securityZScore})`;
-        }
-    }
-    return summary;
-}