@safetnsr/vet 1.27.0 → 1.29.0

package/dist/checks/fleet.d.ts

@@ -0,0 +1,29 @@
+import type { CheckResult } from '../types.js';
+export type FleetStatus = 'OK' | 'SILENT_FAIL' | 'CONFLICT';
+export interface FileTouch {
+    session: string;
+    action: 'write' | 'edit' | 'create' | 'delete';
+    timestamp: string;
+}
+export interface FleetSession {
+    id: string;
+    file: string;
+    startTime: string | null;
+    endTime: string | null;
+    durationMin: number;
+    filesWritten: number;
+    filesRead: number;
+    toolCalls: number;
+    status: FleetStatus;
+    conflicts: string[];
+}
+export interface FleetResult {
+    sessions: FleetSession[];
+    conflicts: Map<string, string[]>;
+    silentFails: string[];
+    totalFiles: number;
+    totalToolCalls: number;
+}
+export declare function analyzeFleet(sessionsDir?: string, since?: string): FleetResult;
+export declare function checkFleet(sessionsDir?: string, since?: string): CheckResult;
+export declare function runFleetCommand(format: string, sessionsDir?: string, since?: string): Promise<void>;

package/dist/checks/fleet.js

@@ -0,0 +1,286 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c } from '../util.js';
+import { findSessionFiles } from './receipt.js';
+const WRITE_TOOLS = new Set(['Write', 'write_to_file', 'write', 'MultiEdit']);
+const EDIT_TOOLS = new Set(['Edit', 'edit_file', 'edit']);
+const READ_TOOLS = new Set(['Read', 'read_file', 'read', 'View']);
+function classifyTool(name) {
+    if (WRITE_TOOLS.has(name))
+        return 'write';
+    if (EDIT_TOOLS.has(name))
+        return 'edit';
+    if (READ_TOOLS.has(name))
+        return 'read';
+    if (name === 'Bash' || name === 'bash' || name === 'execute_command')
+        return 'bash';
+    return 'other';
+}
+function extractFilePath(input) {
+    // Try common field names
+    for (const key of ['file_path', 'path', 'filePath', 'filename']) {
+        if (typeof input[key] === 'string')
+            return input[key];
+    }
+    // For Edit tool, check old_string path
+    if (typeof input['file'] === 'string')
+        return input['file'];
+    return null;
+}
+function parseSessionJsonl(filePath, sinceMs) {
+    const calls = [];
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return calls;
+    }
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const timestamp = entry['timestamp'] || '';
+        if (sinceMs && timestamp) {
+            const entryTime = new Date(timestamp).getTime();
+            if (!isNaN(entryTime) && entryTime < sinceMs)
+                continue;
+        }
+        // Extract tool_use blocks from content arrays
+        const contents = [];
+        if (Array.isArray(entry['content'])) {
+            contents.push(...entry['content']);
+        }
+        if (entry['message'] && typeof entry['message'] === 'object') {
+            const msg = entry['message'];
+            if (Array.isArray(msg['content'])) {
+                contents.push(...msg['content']);
+            }
+        }
+        for (const block of contents) {
+            if (typeof block !== 'object' || block === null)
+                continue;
+            const b = block;
+            if (b['type'] !== 'tool_use')
+                continue;
+            const toolName = b['name'] || '';
+            const input = b['input'] || {};
+            const action = classifyTool(toolName);
+            const fp = extractFilePath(input);
+            calls.push({ timestamp, toolName, filePath: fp, action });
+        }
+    }
+    return calls;
+}
+// ── Core analysis ────────────────────────────────────────────────────────────
+function parseSinceFlag(since) {
+    if (!since)
+        return null;
+    // "8h", "24h", "1d", "30m"
+    const match = since.match(/^(\d+)(h|d|m)$/i);
+    if (match) {
+        const val = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        const ms = unit === 'h' ? val * 3600000 : unit === 'd' ? val * 86400000 : val * 60000;
+        return Date.now() - ms;
+    }
+    // ISO date or timestamp
+    const ts = new Date(since).getTime();
+    return isNaN(ts) ? null : ts;
+}
+function sessionIdFromPath(filePath) {
+    const base = path.basename(filePath, '.jsonl');
+    // Shorten long UUIDs for display
+    if (base.length > 20)
+        return base.slice(0, 8);
+    return base;
+}
+export function analyzeFleet(sessionsDir, since) {
+    const sinceMs = parseSinceFlag(since);
+    const sessionFiles = findSessionFiles(sessionsDir);
+    // Filter by mtime if --since
+    const filteredFiles = sinceMs
+        ? sessionFiles.filter(f => {
+            try {
+                return fs.statSync(f).mtimeMs >= sinceMs;
+            }
+            catch {
+                return false;
+            }
+        })
+        : sessionFiles;
+    // Limit to last 20 sessions to avoid scanning entire history
+    const recentFiles = filteredFiles.slice(-20);
+    const fileTouches = new Map(); // filepath → touches
+    const sessions = [];
+    for (const sessionFile of recentFiles) {
+        const sid = sessionIdFromPath(sessionFile);
+        const calls = parseSessionJsonl(sessionFile, sinceMs);
+        if (calls.length === 0) {
+            sessions.push({
+                id: sid, file: sessionFile,
+                startTime: null, endTime: null, durationMin: 0,
+                filesWritten: 0, filesRead: 0, toolCalls: 0,
+                status: 'OK', conflicts: [],
+            });
+            continue;
+        }
+        const timestamps = calls.filter(c => c.timestamp).map(c => c.timestamp);
+        const startTime = timestamps.length > 0 ? timestamps[0] : null;
+        const endTime = timestamps.length > 0 ? timestamps[timestamps.length - 1] : null;
+        const durationMs = startTime && endTime
+            ? new Date(endTime).getTime() - new Date(startTime).getTime()
+            : 0;
+        const durationMin = Math.round(durationMs / 60000);
+        const writtenFiles = new Set();
+        const readFiles = new Set();
+        for (const call of calls) {
+            if ((call.action === 'write' || call.action === 'edit') && call.filePath) {
+                writtenFiles.add(call.filePath);
+                // Track file touches for conflict detection
+                const touches = fileTouches.get(call.filePath) || [];
+                touches.push({ session: sid, action: call.action, timestamp: call.timestamp });
+                fileTouches.set(call.filePath, touches);
+            }
+            else if (call.action === 'read' && call.filePath) {
+                readFiles.add(call.filePath);
+            }
+        }
+        // Silent fail: session had tool calls but zero writes
+        const isSilentFail = calls.length > 3 && writtenFiles.size === 0;
+        sessions.push({
+            id: sid, file: sessionFile,
+            startTime, endTime, durationMin,
+            filesWritten: writtenFiles.size,
+            filesRead: readFiles.size,
+            toolCalls: calls.length,
+            status: isSilentFail ? 'SILENT_FAIL' : 'OK',
+            conflicts: [],
+        });
+    }
+    // Detect cross-agent conflicts
+    const conflicts = new Map();
+    for (const [fp, touches] of fileTouches) {
+        const uniqueSessions = [...new Set(touches.map(t => t.session))];
+        if (uniqueSessions.length >= 2) {
+            conflicts.set(fp, uniqueSessions);
+            // Mark sessions as conflicting
+            for (const s of sessions) {
+                if (uniqueSessions.includes(s.id) && s.status !== 'SILENT_FAIL') {
+                    s.status = 'CONFLICT';
+                    s.conflicts.push(fp);
+                }
+            }
+        }
+    }
+    const silentFails = sessions.filter(s => s.status === 'SILENT_FAIL').map(s => s.id);
+    return {
+        sessions,
+        conflicts,
+        silentFails,
+        totalFiles: fileTouches.size,
+        totalToolCalls: sessions.reduce((sum, s) => sum + s.toolCalls, 0),
+    };
+}
+// ── CheckResult integration ──────────────────────────────────────────────────
+export function checkFleet(sessionsDir, since) {
+    const result = analyzeFleet(sessionsDir, since);
+    const issues = [];
+    for (const sid of result.silentFails) {
+        issues.push({
+            severity: 'error',
+            message: `session ${sid}: SILENT FAIL — ran but produced 0 file changes`,
+            fixable: false,
+            fixHint: 'check session logs for errors or stuck loops',
+        });
+    }
+    for (const [fp, sids] of result.conflicts) {
+        issues.push({
+            severity: 'warning',
+            message: `file conflict: ${fp} — written by sessions: ${sids.join(', ')}`,
+            file: fp,
+            fixable: false,
+            fixHint: 'review file for merge conflicts or overwritten changes',
+        });
+    }
+    const score = Math.max(0, 100
+        - result.silentFails.length * 25
+        - result.conflicts.size * 15);
+    const summary = result.sessions.length === 0
+        ? 'no session files found'
+        : `${result.sessions.length} sessions — ${result.silentFails.length} silent fails, ${result.conflicts.size} file conflicts`;
+    return { name: 'fleet', score, maxScore: 100, issues, summary };
+}
+// ── Subcommand output ────────────────────────────────────────────────────────
+export async function runFleetCommand(format, sessionsDir, since) {
+    const result = analyzeFleet(sessionsDir, since);
+    if (format === 'json') {
+        console.log(JSON.stringify({
+            sessions: result.sessions.map(s => ({
+                id: s.id,
+                startTime: s.startTime,
+                endTime: s.endTime,
+                durationMin: s.durationMin,
+                filesWritten: s.filesWritten,
+                toolCalls: s.toolCalls,
+                status: s.status,
+                conflicts: s.conflicts,
+            })),
+            conflicts: Object.fromEntries(result.conflicts),
+            silentFails: result.silentFails,
+            totalFiles: result.totalFiles,
+            totalToolCalls: result.totalToolCalls,
+        }, null, 2));
+        return;
+    }
+    console.log(`\n  ${c.bold}vet fleet${c.reset} — multi-agent session audit\n`);
+    if (result.sessions.length === 0) {
+        console.log(`  ${c.dim}no session files found${c.reset}`);
+        console.log(`  ${c.dim}default path: ~/.claude/projects/*/sessions/*.jsonl${c.reset}\n`);
+        return;
+    }
+    // Session table
+    const padId = Math.max(8, ...result.sessions.map(s => s.id.length));
+    const header = `  ${'SESSION'.padEnd(padId)}  ${'DURATION'.padEnd(8)}  ${'FILES'.padEnd(7)}  ${'CALLS'.padEnd(7)}  STATUS`;
+    console.log(`  ${c.dim}${header}${c.reset}`);
+    console.log(`  ${c.dim}${'─'.repeat(header.length)}${c.reset}`);
+    for (const s of result.sessions) {
+        const dur = s.durationMin > 0 ? `${s.durationMin}m` : '—';
+        const files = String(s.filesWritten);
+        const calls = String(s.toolCalls);
+        const statusColor = s.status === 'SILENT_FAIL' ? c.red
+            : s.status === 'CONFLICT' ? c.yellow
+                : c.green;
+        const statusIcon = s.status === 'SILENT_FAIL' ? '✗'
+            : s.status === 'CONFLICT' ? '⚠'
+                : '✓';
+        console.log(`  ${s.id.padEnd(padId)}  ${dur.padEnd(8)}  ${files.padEnd(7)}  ${calls.padEnd(7)}  ${statusColor}${statusIcon} ${s.status}${c.reset}`);
+    }
+    console.log();
+    // Conflicts
+    if (result.conflicts.size > 0) {
+        console.log(`  ${c.yellow}${c.bold}conflicts${c.reset}  ${c.dim}(same file written by multiple sessions)${c.reset}`);
+        for (const [fp, sids] of result.conflicts) {
+            console.log(`  ${c.yellow}⚠${c.reset} ${fp}  ${c.dim}— sessions: ${sids.join(', ')}${c.reset}`);
+        }
+        console.log();
+    }
+    // Silent failures
+    if (result.silentFails.length > 0) {
+        console.log(`  ${c.red}${c.bold}silent failures${c.reset}  ${c.dim}(sessions with 0 file changes)${c.reset}`);
+        for (const sid of result.silentFails) {
+            const s = result.sessions.find(x => x.id === sid);
+            console.log(`  ${c.red}✗${c.reset} ${sid}  ${c.dim}— ${s?.toolCalls ?? 0} tool calls, 0 writes${c.reset}`);
+        }
+        console.log();
+    }
+    // Summary
+    const ok = result.sessions.filter(s => s.status === 'OK').length;
+    console.log(`  ${c.dim}summary: ${result.sessions.length} sessions. ${ok} ok, ${result.silentFails.length} silent fails, ${result.conflicts.size} conflicts.${c.reset}\n`);
+}

package/dist/checks/review.d.ts

@@ -0,0 +1,3 @@
+import type { CheckResult } from '../types.js';
+export declare function checkReview(cwd: string): Promise<CheckResult>;
+export declare function runReviewCommand(cwd: string, format: string): Promise<void>;

package/dist/checks/review.js

@@ -0,0 +1,189 @@
+import { join, relative } from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
+import { readFile, c } from '../util.js';
+const SECTIONS = [
+    {
+        name: 'FOCUS AREAS',
+        points: 20,
+        patterns: [/focus/i, /priority/i, /look for/i, /check for/i, /pay attention/i, /concentrate on/i],
+        missingImpact: 'Claude Code Review will leave generic comments',
+    },
+    {
+        name: 'OUT-OF-SCOPE',
+        points: 20,
+        patterns: [/out of scope/i, /out-of-scope/i, /ignore/i, /skip/i, /don't review/i, /exclude/i, /not relevant/i],
+        missingImpact: 'Reviews may flag irrelevant code patterns',
+    },
+    {
+        name: 'PERSONA',
+        points: 20,
+        patterns: [/act as/i, /you are/i, /persona/i, /role/i, /reviewer/i, /behave as/i],
+        missingImpact: 'Reviewer has no defined expertise or tone',
+    },
+    {
+        name: 'TOOL LIST',
+        points: 20,
+        patterns: [/tools/i, /allowed tools/i, /disallowed/i, /permitted/i, /use the following/i],
+        missingImpact: 'No tool restrictions — agent may use unexpected tools',
+    },
+    {
+        name: 'EXAMPLES',
+        points: 20,
+        patterns: [], // special: checks for fenced code blocks
+        missingImpact: 'No example review comments — output style unpredictable',
+    },
+];
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function findReviewFiles(dir, maxDepth) {
+    const results = [];
+    function walk(d, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === 'node_modules' || entry === '.git' || entry === 'dist' || entry === 'build')
+                continue;
+            const full = join(d, entry);
+            try {
+                const stat = statSync(full);
+                if (stat.isFile() && entry === 'REVIEW.md') {
+                    results.push(full);
+                }
+                else if (stat.isDirectory()) {
+                    walk(full, depth + 1);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    walk(dir, 0);
+    return results;
+}
+function scoreFile(content) {
+    const sections = [];
+    for (const section of SECTIONS) {
+        let passed = false;
+        if (section.name === 'EXAMPLES') {
+            // Check for fenced code blocks
+            passed = /```/.test(content);
+        }
+        else {
+            passed = section.patterns.some(re => re.test(content));
+        }
+        sections.push({
+            name: section.name,
+            passed,
+            points: section.points,
+            missingImpact: section.missingImpact,
+        });
+    }
+    const score = sections.reduce((sum, s) => sum + (s.passed ? s.points : 0), 0);
+    return { score, sections };
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export async function checkReview(cwd) {
+    const files = findReviewFiles(cwd, 3);
+    const issues = [];
+    if (files.length === 0) {
+        return {
+            name: 'review',
+            score: 0,
+            maxScore: 100,
+            issues: [{
+                    severity: 'info',
+                    message: 'No REVIEW.md found — create one to enable Claude Code Review',
+                    fixable: false,
+                }],
+            summary: 'no REVIEW.md found',
+        };
+    }
+    let totalScore = 0;
+    for (const file of files) {
+        const content = readFile(file) || '';
+        const result = scoreFile(content);
+        totalScore += result.score;
+        const rel = relative(cwd, file);
+        if (result.score === 0) {
+            issues.push({
+                severity: 'warning',
+                message: `${rel}: score 0/100 — no behavioral sections detected`,
+                file: rel,
+                fixable: false,
+            });
+        }
+        else if (result.score < 100) {
+            const missing = result.sections.filter(s => !s.passed).map(s => s.name);
+            issues.push({
+                severity: 'warning',
+                message: `${rel}: score ${result.score}/100 — missing: ${missing.join(', ')}`,
+                file: rel,
+                fixable: false,
+            });
+        }
+    }
+    const avgScore = Math.round(totalScore / files.length);
+    const summary = files.length === 1
+        ? `REVIEW.md score ${avgScore}/100`
+        : `${files.length} REVIEW.md files — average score ${avgScore}/100`;
+    return {
+        name: 'review',
+        score: avgScore,
+        maxScore: 100,
+        issues,
+        summary,
+    };
+}
+// ── Subcommand output ────────────────────────────────────────────────────────
+export async function runReviewCommand(cwd, format) {
+    const files = findReviewFiles(cwd, 3);
+    if (format === 'json') {
+        const results = files.map(file => {
+            const content = readFile(file) || '';
+            const result = scoreFile(content);
+            return { file: relative(cwd, file), score: result.score, sections: result.sections };
+        });
+        console.log(JSON.stringify({
+            files: results,
+            score: files.length > 0 ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length) : 0,
+        }, null, 2));
+        return;
+    }
+    console.log(`\n  ${c.bold}vet review${c.reset} — REVIEW.md behavioral completeness\n`);
+    if (files.length === 0) {
+        console.log(`  ${c.dim}no REVIEW.md found${c.reset}`);
+        console.log(`  ${c.dim}create one to guide Claude Code Review behavior${c.reset}\n`);
+        return;
+    }
+    for (const file of files) {
+        const content = readFile(file) || '';
+        const result = scoreFile(content);
+        const rel = relative(cwd, file);
+        console.log(`  ${c.bold}${rel}${c.reset}`);
+        console.log(`  ${c.dim}${'─'.repeat(50)}${c.reset}`);
+        for (const section of result.sections) {
+            if (section.passed) {
+                console.log(`  ${c.green}✓${c.reset} ${section.name}  ${c.dim}(${section.points}pts)${c.reset}`);
+            }
+            else {
+                console.log(`  ${c.red}✗${c.reset} ${section.name}  ${c.dim}(0/${section.points}pts)${c.reset}`);
+                console.log(`    ${c.dim}→ ${section.missingImpact}${c.reset}`);
+            }
+        }
+        const scoreColor = result.score >= 80 ? c.green : result.score >= 40 ? c.yellow : c.red;
+        console.log(`\n  score  ${scoreColor}${result.score}/100${c.reset}\n`);
+    }
+    if (files.length > 1) {
+        const avg = Math.round(files.reduce((sum, f) => {
+            const content = readFile(f) || '';
+            return sum + scoreFile(content).score;
+        }, 0) / files.length);
+        const avgColor = avg >= 80 ? c.green : avg >= 40 ? c.yellow : c.red;
+        console.log(`  ${c.bold}average${c.reset}  ${avgColor}${avg}/100${c.reset}\n`);
+    }
+}

package/dist/cli.js

@@ -35,6 +35,8 @@ import { checkExplain, runExplainCommand } from './checks/explain.js';
 import { checkContext, runContextCommand } from './checks/context.js';
 import { checkSplit, runSplitCommand } from './checks/split.js';
 import { runTriageCommand } from './checks/triage.js';
+import { runFleetCommand } from './checks/fleet.js';
+import { checkReview, runReviewCommand } from './checks/review.js';
 import { checkSourceSecurity } from './checks/source-security.js';
 import { checkCompleteness } from './checks/completeness.js';
 import { score } from './scorer.js';
@@ -96,6 +98,8 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet split [--since HEAD~1] [--apply] [--force] [--json]  split AI mega-commits into atomic commits
     npx @safetnsr/vet sandbox [dir]     score agent runtime blast radius
     npx @safetnsr/vet triage [--since HEAD~1] [--json]  rank diff files by review urgency
+    npx @safetnsr/vet fleet [--sessions dir] [--since 8h] [--json]  multi-agent session audit
+    npx @safetnsr/vet review [dir]        score REVIEW.md behavioral completeness
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -132,7 +136,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context', 'split', 'sandbox', 'triage'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context', 'split', 'sandbox', 'triage', 'fleet', 'review'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -331,6 +335,30 @@ if (command === 'triage') {
     }
     process.exit(0);
 }
+if (command === 'fleet') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        const sessionsDir = args.find(a => a.startsWith('--sessions='))?.split('=')[1]
+            || (args.includes('--sessions') ? args[args.indexOf('--sessions') + 1] : undefined);
+        await runFleetCommand(format, sessionsDir, since);
+    }
+    catch (e) {
+        console.error(`${c.red}fleet failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+if (command === 'review') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        await runReviewCommand(cwd, format);
+    }
+    catch (e) {
+        console.error(`${c.red}review failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -440,7 +468,7 @@ async function runChecks() {
             }
         }
         // Run ALL independent checks in parallel
-        const [scanResult, sourceSecurityResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult, contextResult, splitResult, sandboxResult,] = await Promise.all([
+        const [scanResult, sourceSecurityResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult, contextResult, splitResult, sandboxResult, reviewResult,] = await Promise.all([
             withTimeout('scan', () => checkScan(cwd)),
             withTimeout('source-security', () => checkSourceSecurity(cwd)),
             withTimeout('secrets', () => checkSecrets(cwd)),
@@ -472,6 +500,7 @@ async function runChecks() {
             withTimeout('context', () => checkContext(cwd)),
             withTimeout('split', () => checkSplit(cwd)),
             withTimeout('sandbox', () => checkSandbox(cwd)),
+            withTimeout('review', () => checkReview(cwd)),
         ]);
         // Git-dependent checks (diff + history) — parallel with each other
         const [diffResult, historyResult] = await Promise.all([
@@ -486,7 +515,7 @@ async function runChecks() {
             debt: [readyResult, historyResult, debtResult, bloatResult, clonesResult, splitResult],
             deps: [depsResult],
             architecture: [architectureResult],
-            aiready: [aireadyResult, deepResult, semanticResult, contextResult],
+            aiready: [aireadyResult, deepResult, semanticResult, contextResult, reviewResult],
             history: [hotspotsResult],
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "1.27.0",
+  "version": "1.29.0",
   "description": "vet your AI-generated code — one command, one score card, one letter grade",
   "type": "module",
   "bin": {