@safetnsr/vet 1.26.1 → 1.28.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/triage.d.ts

@@ -0,0 +1,12 @@
+import type { CheckResult } from '../types.js';
+export type TriageRank = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'SKIP';
+export interface TriageEntry {
+    file: string;
+    rank: TriageRank;
+    reason: string;
+    signals: string[];
+    estimateMin: number;
+}
+export declare function analyzeTriage(cwd: string, since?: string): TriageEntry[];
+export declare function checkTriage(cwd: string, since?: string): CheckResult;
+export declare function runTriageCommand(format: string, cwd?: string, since?: string): Promise<void>;

package/dist/checks/triage.js

@@ -0,0 +1,261 @@
+import { extname } from 'node:path';
+import { gitExec, c } from '../util.js';
+// ── Constants ────────────────────────────────────────────────────────────────
+const SECURITY_PATH_RE = /auth|middleware|permission|secret|crypt|jwt|session|cors|password|login|token/i;
+const SECURITY_SKIP_EXTS = new Set(['.css', '.md', '.json', '.svg', '.png']);
+const SCHEMA_PATH_RE = /migration|schema|model|entity|prisma|knex|sequelize|drizzle/i;
+const ERROR_HANDLER_RE = /try\s*\{|\.catch\(|}\s*catch|catch\s*\(/;
+const TEST_PATH_RE = /test|spec|__tests__/;
+const COMMENT_LINE_RE = /^\s*(\/\/|\/\*|\*|#)/;
+const WHITESPACE_ONLY_RE = /^\s*$/;
+function parseStatLine(line) {
+    // Format: " src/foo.ts | 12 +++---"  or  " src/foo.ts | Bin 0 -> 1234 bytes"
+    const match = line.match(/^\s*(.+?)\s*\|\s*(\d+)/);
+    if (!match)
+        return null;
+    const file = match[1].trim();
+    const total = parseInt(match[2], 10);
+    // Count + and - chars at end of line for approximation
+    const plusMinus = line.match(/\|\s*\d+\s*([+\-]+)\s*$/);
+    if (!plusMinus)
+        return { file, added: 0, removed: 0 };
+    const symbols = plusMinus[1];
+    const added = (symbols.match(/\+/g) || []).length;
+    const removed = (symbols.match(/-/g) || []).length;
+    // Scale up: the stat line shows proportional +/- not exact counts
+    // We'll use the full diff to get exact counts — this is just for file list
+    return { file, added, removed };
+}
+function parseDiff(diffOutput) {
+    const result = new Map();
+    if (!diffOutput.trim())
+        return result;
+    const fileDiffs = diffOutput.split(/^diff --git /m).filter(Boolean);
+    for (const fileDiff of fileDiffs) {
+        const lines = fileDiff.split('\n');
+        const headerMatch = lines[0]?.match(/a\/.+? b\/(.+)/);
+        if (!headerMatch)
+            continue;
+        const file = headerMatch[1].trim();
+        const removedLines = [];
+        const addedLines = [];
+        let inHunk = false;
+        for (const line of lines) {
+            if (line.startsWith('@@')) {
+                inHunk = true;
+                continue;
+            }
+            if (!inHunk)
+                continue;
+            if (line.startsWith('---') || line.startsWith('+++'))
+                continue;
+            if (line.startsWith('-')) {
+                removedLines.push(line.slice(1));
+            }
+            else if (line.startsWith('+')) {
+                addedLines.push(line.slice(1));
+            }
+        }
+        result.set(file, {
+            file,
+            added: addedLines.length,
+            removed: removedLines.length,
+            removedLines,
+            addedLines,
+            allChangedLines: [...removedLines, ...addedLines],
+        });
+    }
+    return result;
+}
+// ── Signal detection ─────────────────────────────────────────────────────────
+function isSecurityPath(file) {
+    const ext = extname(file).toLowerCase();
+    if (SECURITY_SKIP_EXTS.has(ext))
+        return false;
+    return SECURITY_PATH_RE.test(file);
+}
+function hasErrorHandlerRemoval(fileDiff) {
+    return fileDiff.removedLines.some(line => ERROR_HANDLER_RE.test(line));
+}
+function isSchemaPath(file) {
+    return SCHEMA_PATH_RE.test(file);
+}
+function isCosmetic(fileDiff) {
+    const totalChanged = fileDiff.added + fileDiff.removed;
+    if (totalChanged < 5)
+        return true;
+    // All changed lines are comments or whitespace
+    const allCommentOrWhitespace = fileDiff.allChangedLines.every(line => WHITESPACE_ONLY_RE.test(line) || COMMENT_LINE_RE.test(line));
+    return allCommentOrWhitespace;
+}
+function isLargeChange(fileDiff, testFilesChanged) {
+    return fileDiff.added >= 50 && !testFilesChanged;
+}
+// ── Ranking ──────────────────────────────────────────────────────────────────
+function rankFile(file, fileDiff, anyTestChanged) {
+    const sig1 = isSecurityPath(file);
+    const sig2 = hasErrorHandlerRemoval(fileDiff);
+    const sig3 = isSchemaPath(file);
+    const sig4 = isCosmetic(fileDiff);
+    const sig5 = isLargeChange(fileDiff, anyTestChanged);
+    const signals = [];
+    if (sig1)
+        signals.push('security path');
+    if (sig2)
+        signals.push('error handler removed');
+    if (sig3)
+        signals.push('schema/db path');
+    if (sig5)
+        signals.push(`${fileDiff.added} lines added, no tests changed`);
+    // CRITICAL: sig1 AND (sig2 OR sig3)
+    if (sig1 && (sig2 || sig3)) {
+        const reasonParts = ['security path'];
+        if (sig2)
+            reasonParts.push('error handler removed');
+        if (sig3)
+            reasonParts.push('schema change');
+        return { file, rank: 'CRITICAL', reason: reasonParts.join(' + '), signals, estimateMin: 5 };
+    }
+    // HIGH: sig1 OR sig2 OR sig3
+    if (sig1)
+        return { file, rank: 'HIGH', reason: 'security-relevant path', signals, estimateMin: 2 };
+    if (sig2)
+        return { file, rank: 'HIGH', reason: 'error handler removed', signals, estimateMin: 2 };
+    if (sig3)
+        return { file, rank: 'HIGH', reason: 'schema/db path', signals, estimateMin: 2 };
+    // MEDIUM: sig5
+    if (sig5) {
+        return {
+            file,
+            rank: 'MEDIUM',
+            reason: `${fileDiff.added} lines added, no tests changed`,
+            signals,
+            estimateMin: 1,
+        };
+    }
+    // SKIP: sig4 or no signals
+    const skipReason = sig4 ? 'cosmetic' : 'no signals';
+    return { file, rank: 'SKIP', reason: skipReason, signals: [], estimateMin: 0 };
+}
+// ── Core logic ───────────────────────────────────────────────────────────────
+export function analyzeTriage(cwd, since = 'HEAD~1') {
+    const statOutput = gitExec(['diff', '--stat', since], cwd);
+    const diffOutput = gitExec(['diff', since], cwd);
+    if (!statOutput && !diffOutput)
+        return [];
+    // Parse full diff for per-file line data
+    const fileDiffs = parseDiff(diffOutput);
+    // Get file list from stat (in case diff missed any)
+    const statFiles = [];
+    for (const line of statOutput.split('\n')) {
+        const parsed = parseStatLine(line);
+        if (parsed)
+            statFiles.push(parsed.file);
+    }
+    // Union of files from stat and diff
+    const allFiles = new Set([...statFiles, ...fileDiffs.keys()]);
+    if (allFiles.size === 0)
+        return [];
+    // Determine if any test file changed
+    const anyTestChanged = [...allFiles].some(f => TEST_PATH_RE.test(f));
+    const entries = [];
+    for (const file of allFiles) {
+        const fd = fileDiffs.get(file) ?? {
+            file,
+            added: 0,
+            removed: 0,
+            removedLines: [],
+            addedLines: [],
+            allChangedLines: [],
+        };
+        entries.push(rankFile(file, fd, anyTestChanged));
+    }
+    // Sort: CRITICAL first, then HIGH, MEDIUM, SKIP
+    const rankOrder = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, SKIP: 3 };
+    entries.sort((a, b) => rankOrder[a.rank] - rankOrder[b.rank]);
+    return entries;
+}
+// ── CheckResult integration ──────────────────────────────────────────────────
+export function checkTriage(cwd, since) {
+    const entries = analyzeTriage(cwd, since ?? 'HEAD~1');
+    const issues = [];
+    for (const entry of entries) {
+        if (entry.rank === 'SKIP')
+            continue;
+        const severity = entry.rank === 'CRITICAL' ? 'error' : entry.rank === 'HIGH' ? 'warning' : 'info';
+        issues.push({
+            severity,
+            message: `[${entry.rank}] ${entry.file} — ${entry.reason}`,
+            file: entry.file,
+            fixable: false,
+            fixHint: `review ${entry.file} (~${entry.estimateMin} min)`,
+        });
+    }
+    const critical = entries.filter(e => e.rank === 'CRITICAL').length;
+    const high = entries.filter(e => e.rank === 'HIGH').length;
+    const medium = entries.filter(e => e.rank === 'MEDIUM').length;
+    const skip = entries.filter(e => e.rank === 'SKIP').length;
+    const totalMin = entries.reduce((sum, e) => sum + e.estimateMin, 0);
+    const score = critical > 0 ? Math.max(0, 100 - critical * 25 - high * 10 - medium * 5)
+        : high > 0 ? Math.max(0, 100 - high * 10 - medium * 5)
+            : Math.max(0, 100 - medium * 5);
+    const summary = entries.length === 0
+        ? 'no diff to analyze'
+        : `${entries.length} files changed — ${critical} critical, ${high} high, ${medium} medium, ${skip} skip (~${totalMin} min)`;
+    return { name: 'triage', score, maxScore: 100, issues, summary };
+}
+// ── Subcommand output ────────────────────────────────────────────────────────
+export async function runTriageCommand(format, cwd, since) {
+    const dir = cwd || process.cwd();
+    const sinceRef = since ?? 'HEAD~1';
+    const entries = analyzeTriage(dir, sinceRef);
+    if (format === 'json') {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    console.log(`\n  ${c.bold}vet triage${c.reset} — diff review urgency\n`);
+    if (entries.length === 0) {
+        console.log(`  ${c.dim}no diff to analyze${c.reset}\n`);
+        return;
+    }
+    const critical = entries.filter(e => e.rank === 'CRITICAL');
+    const high = entries.filter(e => e.rank === 'HIGH');
+    const medium = entries.filter(e => e.rank === 'MEDIUM');
+    const skip = entries.filter(e => e.rank === 'SKIP');
+    if (critical.length > 0) {
+        console.log(`  ${c.red}${c.bold}CRITICAL${c.reset}  ${c.dim}(est. 5 min each)${c.reset}`);
+        for (const e of critical) {
+            console.log(`  ${c.red}✗${c.reset} ${e.file}  ${c.dim}— ${e.reason}${c.reset}`);
+        }
+        console.log();
+    }
+    if (high.length > 0) {
+        console.log(`  ${c.yellow}${c.bold}HIGH${c.reset}  ${c.dim}(est. 2 min each)${c.reset}`);
+        for (const e of high) {
+            console.log(`  ${c.yellow}⚠${c.reset} ${e.file}  ${c.dim}— ${e.reason}${c.reset}`);
+        }
+        console.log();
+    }
+    if (medium.length > 0) {
+        console.log(`  ${c.green}${c.bold}MEDIUM${c.reset}  ${c.dim}(est. 1 min each)${c.reset}`);
+        for (const e of medium) {
+            console.log(`  ${c.green}○${c.reset} ${e.file}  ${c.dim}— ${e.reason}${c.reset}`);
+        }
+        console.log();
+    }
+    if (skip.length > 0) {
+        console.log(`  ${c.dim}SKIP  (${skip.length} file${skip.length !== 1 ? 's' : ''})${c.reset}`);
+        const shown = skip.slice(0, 3);
+        const rest = skip.length - shown.length;
+        for (const e of shown) {
+            console.log(`  ${c.dim}· ${e.file}  — ${e.reason}${c.reset}`);
+        }
+        if (rest > 0) {
+            console.log(`  ${c.dim}· ... and ${rest} more${c.reset}`);
+        }
+        console.log();
+    }
+    const reviewCount = critical.length + high.length + medium.length;
+    const totalMin = entries.reduce((sum, e) => sum + e.estimateMin, 0);
+    console.log(`  ${c.dim}summary: ${entries.length} files changed. review ${reviewCount} files (~${totalMin} min). skip ${skip.length}.${c.reset}\n`);
+}

package/dist/cli.js

@@ -34,6 +34,8 @@ import { checkSandbox, runSandboxCommand } from './checks/sandbox.js';
 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 { checkSourceSecurity } from './checks/source-security.js';
 import { checkCompleteness } from './checks/completeness.js';
 import { score } from './scorer.js';
@@ -94,6 +96,8 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet context [dir]    audit agent context files for token cost + stale sections
     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
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -130,7 +134,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'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context', 'split', 'sandbox', 'triage', 'fleet'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -318,6 +322,30 @@ if (command === 'sandbox') {
     }
     process.exit(0);
 }
+if (command === 'triage') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        await runTriageCommand(format, cwd, since);
+    }
+    catch (e) {
+        console.error(`${c.red}triage failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    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 (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);

package/package.json

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