@safetnsr/vet 0.2.1 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # vet
 
-vet your AI-generated code. one command, six checks, zero config.
+vet your AI-generated code. one command, ten checks, zero config.
 
 ```bash
 npx @safetnsr/vet
@@ -18,6 +18,10 @@ works with Claude Code, Cursor, Copilot, Codex, Aider, Windsurf, Cline — anyth
 | **links** | broken markdown links? | validates relative links and wikilinks |
 | **config** | agent configs in place? | deep analysis of CLAUDE.md, .cursorrules, copilot-instructions — checks completeness, consistency, and specificity against your actual codebase |
 | **history** | git patterns healthy? | analyzes commit churn, AI attribution, large changes |
+| **scan** | malicious patterns in agent configs? | scans .claude/, .cursorrules, CLAUDE.md, .mcp/ for prompt injection, shell injection, exfiltration endpoints |
+| **secrets** | leaked secrets in build output? | scans dist/, build/, .next/ + .env files for API keys, tokens, connection strings using pattern + entropy analysis |
+| **receipt** | what did the last agent session do? | parses ~/.claude/projects/ JSONL session logs — files changed, commands run, packages installed, SHA256 integrity hash |
+| **edge** | how replaceable is your git history? | classifies commits by human-edge score: architecture (90) → debugging (85) → integration (80) → feature (60) → boilerplate (20) → cosmetic (10) |
 
 ## usage
 
@@ -45,6 +49,14 @@ npx @safetnsr/vet --json
 
 # generate configs + pre-commit hook
 npx @safetnsr/vet init
+
+# show last agent session receipt (ASCII or JSON)
+npx @safetnsr/vet receipt
+npx @safetnsr/vet receipt --json
+
+# show human-edge score for git history
+npx @safetnsr/vet edge
+npx @safetnsr/vet edge --explain
 ```
 
 ## output
@@ -109,13 +121,57 @@ config score breakdown:
   specificity:   3/10 — generic rules, nothing project-specific
 ```
 
+## subcommands
+
+### `vet receipt`
+
+Shows a receipt for the last Claude Code agent session — what files it touched, what commands it ran, what packages it installed, plus a SHA256 integrity hash:
+
+```
+╔══════════════════════════════════════════════╗
+║          AGENT SESSION RECEIPT               ║
+╠══════════════════════════════════════════════╣
+║ Session:  abc123def456                       ║
+║ Date:     2024-01-15 14:32:11 UTC            ║
+║ Duration: 12m 34s                            ║
+╠══════════════════════════════════════════════╣
+║ FILES CREATED (3)                            ║
+║   src/checks/scan.ts                         ║
+║   src/checks/secrets.ts                      ║
+║   test/scan.test.mjs                         ║
+╠══════════════════════════════════════════════╣
+║ SHA256: 3a7f9c2e...                          ║
+╚══════════════════════════════════════════════╝
+```
+
+### `vet edge`
+
+Analyzes git history and scores how AI-replaceable your contributions are:
+
+```
+  Human Edge Report  72/100
+
+  🏗️ Architecture     12  (28%) ████████████
+  🔍 Debugging         8  (19%) ████████
+  🔗 Integration       6  (14%) ██████
+  ⚡ Feature          10  (24%) ██████████
+  📋 Boilerplate       5  (12%) █████
+  🎨 Cosmetic          1   (2%) █
+
+  Top commits
+  90  a3f2b1c  refactor: extract auth middleware across all routes
+  85  7e8d9f1  fix: resolve race condition in session cleanup
+
+  → Strong position. Your work is deeply contextual and hard to automate.
+```
+
 ## config
 
 create `.vetrc` in your project root (optional):
 
 ```json
 {
-  "checks": ["ready", "diff", "models", "links", "config", "history"],
+  "checks": ["ready", "diff", "models", "links", "config", "history", "scan", "secrets", "receipt", "edge"],
   "ignore": ["vendor/", "generated/"],
   "thresholds": { "min": 6 }
 }

package/dist/checks/edge.d.ts

@@ -0,0 +1,30 @@
+import type { CheckResult } from '../types.js';
+type CommitCategory = 'architecture' | 'debugging' | 'integration' | 'feature' | 'boilerplate' | 'cosmetic';
+interface DiffStats {
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+    dirsChanged: number;
+    files: string[];
+}
+interface ClassifiedCommit {
+    hash: string;
+    date: string;
+    message: string;
+    author: string;
+    category: CommitCategory;
+    score: number;
+    reasoning: string;
+    stats: DiffStats;
+}
+export interface EdgeAnalysis {
+    score: number;
+    totalCommits: number;
+    distribution: Record<CommitCategory, number>;
+    topCommits: ClassifiedCommit[];
+    recommendation: string;
+}
+export declare function analyzeEdge(cwd: string, maxCommits?: number): EdgeAnalysis;
+export declare function checkEdge(cwd: string): CheckResult;
+export declare function runEdgeCommand(cwd: string, explain?: boolean): void;
+export {};

package/dist/checks/edge.js

@@ -0,0 +1,230 @@
+import { execFileSync } from 'node:child_process';
+const CATEGORY_SCORES = {
+    architecture: 90,
+    debugging: 85,
+    integration: 80,
+    feature: 60,
+    boilerplate: 20,
+    cosmetic: 10,
+};
+const BOILERPLATE_RE = [/\bcrud\b/i, /\bscaffold/i, /\bgenerat(e|ed|ing)\b/i, /\binit(ial)?\b/i, /\bboilerplate\b/i, /\btemplate\b/i, /\bsetup\b/i];
+const COSMETIC_RE = [/\brenam(e|ed|ing)\b/i, /\bformat(ting)?\b/i, /\blint(ing)?\b/i, /\bprettier\b/i, /\bstyle\b/i, /\bwhitespace\b/i, /\btypo\b/i];
+const DEBUG_RE = [/\bfix(e[ds])?\b/i, /\bbug\b/i, /\bdebug/i, /\bpatch\b/i, /\bhotfix\b/i, /\bresolv(e|ed|ing)\b/i, /\berror\b/i, /\bissue\b/i];
+const INTEGRATION_RE = [/\bintegrat(e|ion|ing)\b/i, /\bapi\b/i, /\bwebhook\b/i, /\bmigrat(e|ion|ing)\b/i, /\bdatabase\b/i, /\bqueue\b/i, /\bconnect/i, /\bpipeline\b/i, /\bauth(entication|orization)?\b/i];
+function getUniqueDirs(files) {
+    const dirs = new Set();
+    for (const f of files) {
+        const parts = f.split('/');
+        dirs.add(parts.length > 1 ? parts.slice(0, -1).join('/') : '.');
+    }
+    return [...dirs];
+}
+function hasMultiSystemFiles(files) {
+    const layers = new Set();
+    for (const f of files) {
+        const lower = f.toLowerCase();
+        if (/route|controller|handler/.test(lower))
+            layers.add('api');
+        if (/model|schema|migration|db/.test(lower))
+            layers.add('db');
+        if (/test|spec/.test(lower))
+            layers.add('test');
+        if (/config|\.env|yaml|yml/.test(lower))
+            layers.add('config');
+        if (/middleware|auth/.test(lower))
+            layers.add('middleware');
+        if (/service|worker/.test(lower))
+            layers.add('service');
+    }
+    return layers.size >= 2;
+}
+function isCosmetic(stats, message) {
+    const total = stats.insertions + stats.deletions;
+    if (total < 10 && COSMETIC_RE.some(p => p.test(message)))
+        return true;
+    if (stats.insertions > 0 && stats.deletions > 0 &&
+        Math.abs(stats.insertions - stats.deletions) <= 2 &&
+        total < 20 && COSMETIC_RE.some(p => p.test(message)))
+        return true;
+    return false;
+}
+function classifyCommit(hash, date, message, author, stats) {
+    const { filesChanged, insertions, deletions, dirsChanged } = stats;
+    const total = insertions + deletions;
+    let category;
+    let reasoning;
+    if (isCosmetic(stats, message)) {
+        category = 'cosmetic';
+        reasoning = `Small change (${total} lines) matching cosmetic patterns`;
+    }
+    else if (BOILERPLATE_RE.some(p => p.test(message)) && (insertions > deletions * 3 || deletions === 0)) {
+        category = 'boilerplate';
+        reasoning = `Scaffolding pattern in commit message (${insertions} insertions, ${deletions} deletions)`;
+    }
+    else if (dirsChanged >= 3 && filesChanged >= 4) {
+        category = 'architecture';
+        reasoning = `Cross-directory changes (${dirsChanged} dirs, ${filesChanged} files) — structural refactoring`;
+    }
+    else if (filesChanged <= 2 && total <= 30 && DEBUG_RE.some(p => p.test(message))) {
+        category = 'debugging';
+        reasoning = `Targeted fix (${total} lines in ${filesChanged} file${filesChanged > 1 ? 's' : ''}) — context-heavy debugging`;
+    }
+    else if (INTEGRATION_RE.some(p => p.test(message)) || (dirsChanged >= 2 && hasMultiSystemFiles(stats.files))) {
+        category = 'integration';
+        reasoning = 'Multi-system wiring — connecting different parts of the stack';
+    }
+    else if (insertions > 100 && deletions < 10 && filesChanged >= 3 && deletions < insertions * 0.1) {
+        category = 'boilerplate';
+        reasoning = `Uniform additions (${insertions} insertions, ${deletions} deletions)`;
+    }
+    else if (total > 0) {
+        if (dirsChanged >= 2 && filesChanged >= 3 && total > 50) {
+            category = 'architecture';
+            reasoning = `Multi-directory changes (${dirsChanged} dirs, ${filesChanged} files, ${total} lines)`;
+        }
+        else if (DEBUG_RE.some(p => p.test(message)) && filesChanged <= 3) {
+            category = 'debugging';
+            reasoning = `Bug fix across ${filesChanged} file${filesChanged > 1 ? 's' : ''}`;
+        }
+        else {
+            category = 'feature';
+            reasoning = `Feature work (${filesChanged} file${filesChanged > 1 ? 's' : ''}, ${total} lines)`;
+        }
+    }
+    else {
+        category = 'cosmetic';
+        reasoning = 'Empty or metadata-only commit';
+    }
+    return { hash: hash.slice(0, 8), date, message: message.slice(0, 80), author, category, score: CATEGORY_SCORES[category], reasoning, stats };
+}
+// ── Git log parsing (no simple-git, uses execSync) ───────────────────────────
+function gitRaw(args, cwd) {
+    try {
+        return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function getCommitStats(hash, cwd) {
+    let raw = gitRaw(['diff', '--numstat', `${hash}^`, hash, '--'], cwd);
+    if (!raw) {
+        raw = gitRaw(['diff-tree', '--numstat', '--root', hash, '--'], cwd);
+    }
+    const files = [];
+    let insertions = 0;
+    let deletions = 0;
+    for (const line of raw.split('\n').filter(Boolean)) {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            insertions += parts[0] === '-' ? 0 : (parseInt(parts[0] ?? '0', 10) || 0);
+            deletions += parts[1] === '-' ? 0 : (parseInt(parts[1] ?? '0', 10) || 0);
+            if (parts[2])
+                files.push(parts[2]);
+        }
+    }
+    return { filesChanged: files.length, insertions, deletions, dirsChanged: getUniqueDirs(files).length, files };
+}
+function getRecommendation(dist, total) {
+    if (total === 0)
+        return 'no commits to analyze';
+    const boilerPct = ((dist.boilerplate + dist.cosmetic) / total) * 100;
+    const archPct = ((dist.architecture + dist.integration) / total) * 100;
+    if (boilerPct > 40)
+        return 'Focus more on cross-system architecture and targeted debugging. Delegate scaffolding to AI.';
+    if (archPct > 50)
+        return 'Strong position. Your work is deeply contextual and hard to automate.';
+    if (dist.debugging > dist.architecture)
+        return 'Good debugging instinct. Level up by taking on more cross-system architecture.';
+    return 'Balanced mix. Push toward more integration and architecture work to increase your irreplaceability.';
+}
+export function analyzeEdge(cwd, maxCommits = 50) {
+    const raw = gitRaw(['log', '--format=%H|%aI|%an|%s', '--no-merges', `-n`, String(maxCommits)], cwd);
+    const lines = raw.split('\n').filter(Boolean);
+    const commits = [];
+    for (const line of lines) {
+        const pipeIdx = line.indexOf('|');
+        const rest = line.slice(pipeIdx + 1);
+        const hash = line.slice(0, pipeIdx);
+        const [date, author, ...msgParts] = rest.split('|');
+        const message = msgParts.join('|');
+        if (!hash)
+            continue;
+        const stats = getCommitStats(hash, cwd);
+        commits.push(classifyCommit(hash, date ?? '', message ?? '', author ?? '', stats));
+    }
+    const dist = { architecture: 0, debugging: 0, integration: 0, feature: 0, boilerplate: 0, cosmetic: 0 };
+    for (const c of commits)
+        dist[c.category]++;
+    const overallScore = commits.length > 0
+        ? Math.round(commits.reduce((s, c) => s + c.score, 0) / commits.length)
+        : 0;
+    const topCommits = [...commits].sort((a, b) => b.score - a.score).slice(0, 3);
+    return { score: overallScore, totalCommits: commits.length, distribution: dist, topCommits, recommendation: getRecommendation(dist, commits.length) };
+}
+// ── CheckResult adapter ──────────────────────────────────────────────────────
+export function checkEdge(cwd) {
+    const analysis = analyzeEdge(cwd);
+    const issues = [];
+    if (analysis.totalCommits === 0) {
+        return { name: 'edge', score: 5, maxScore: 10, issues: [{ severity: 'info', message: 'no commits to analyze', fixable: false }], summary: 'no git history' };
+    }
+    const { distribution: dist, totalCommits: total } = analysis;
+    const boilerPct = Math.round(((dist.boilerplate + dist.cosmetic) / total) * 100);
+    const archPct = Math.round(((dist.architecture + dist.integration) / total) * 100);
+    if (boilerPct > 50) {
+        issues.push({ severity: 'warning', message: `${boilerPct}% of commits are boilerplate/cosmetic — high automation risk`, fixable: false });
+    }
+    if (archPct > 40) {
+        issues.push({ severity: 'info', message: `${archPct}% architecture/integration work — strong human edge`, fixable: false });
+    }
+    if (analysis.topCommits.length > 0) {
+        const top = analysis.topCommits[0];
+        issues.push({ severity: 'info', message: `top commit: ${top.hash} (${top.category}, ${top.score}/100) — ${top.message.slice(0, 50)}`, fixable: false });
+    }
+    // Map 0-100 score to 0-10
+    const vetScore = Math.round(analysis.score / 10);
+    return {
+        name: 'edge',
+        score: vetScore,
+        maxScore: 10,
+        issues,
+        summary: `${total} commits — human edge score ${analysis.score}/100 — ${analysis.recommendation.slice(0, 60)}`,
+    };
+}
+// ── Standalone subcommand output ─────────────────────────────────────────────
+export function runEdgeCommand(cwd, explain = false) {
+    const analysis = analyzeEdge(cwd, explain ? 100 : 50);
+    if (analysis.totalCommits === 0) {
+        console.log('\n  no commits to analyze\n');
+        return;
+    }
+    const { distribution: dist, totalCommits: total, score, topCommits, recommendation } = analysis;
+    const scoreColor = score >= 70 ? '\x1b[32m' : score >= 40 ? '\x1b[33m' : '\x1b[31m';
+    const RESET = '\x1b[0m';
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[2m';
+    console.log('');
+    console.log(`  ${BOLD}Human Edge Report${RESET}  ${scoreColor}${score}/100${RESET}`);
+    console.log(`  ${DIM}${total} commits analyzed${RESET}`);
+    console.log('');
+    const cats = ['architecture', 'debugging', 'integration', 'feature', 'boilerplate', 'cosmetic'];
+    const catEmoji = { architecture: '🏗️', debugging: '🔍', integration: '🔗', feature: '⚡', boilerplate: '📋', cosmetic: '🎨' };
+    for (const cat of cats) {
+        if (dist[cat] === 0)
+            continue;
+        const pct = Math.round((dist[cat] / total) * 100);
+        const bar = '█'.repeat(Math.max(1, Math.round(pct / 5)));
+        const catScore = CATEGORY_SCORES[cat];
+        const color = catScore >= 70 ? '\x1b[32m' : catScore >= 40 ? '\x1b[33m' : '\x1b[31m';
+        console.log(`  ${catEmoji[cat]} ${cat.padEnd(14)} ${color}${String(dist[cat]).padStart(3)}${RESET} ${DIM}(${String(pct).padStart(2)}%)${RESET} ${color}${bar}${RESET}`);
+    }
+    console.log('');
+    console.log(`  ${BOLD}Top commits${RESET}`);
+    for (const c of topCommits) {
+        console.log(`  ${scoreColor}${c.score}${RESET}  ${c.hash}  ${c.message.slice(0, 55)}`);
+    }
+    console.log('');
+    console.log(`  → ${recommendation}`);
+    console.log('');
+}

package/dist/checks/receipt.d.ts

@@ -0,0 +1,48 @@
+import type { CheckResult } from '../types.js';
+interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+interface SessionEntry {
+    type?: string;
+    role?: string;
+    content?: unknown;
+    timestamp?: string;
+    message?: {
+        role?: string;
+        content?: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface GroupedActions {
+    session_id: string;
+    start_time: string | null;
+    end_time: string | null;
+    duration_seconds: number | null;
+    files_modified: string[];
+    files_deleted: string[];
+    files_created: string[];
+    commands_run: string[];
+    urls_fetched: string[];
+    packages_installed: string[];
+}
+export interface SessionReceipt {
+    actions: GroupedActions;
+    sha256: string;
+    generated_at: string;
+}
+export declare function findSessionFiles(baseDir?: string): string[];
+export declare function findLatestSession(baseDir?: string): string | null;
+export declare function parseSessionFile(filePath: string): Promise<{
+    toolUses: ToolUseBlock[];
+    entries: SessionEntry[];
+}>;
+export declare function groupActions(toolUses: ToolUseBlock[], entries: SessionEntry[], sessionPath: string): GroupedActions;
+export declare function computeSha256(content: string): string;
+export declare function renderReceiptText(actions: GroupedActions): string;
+export declare function renderReceiptJson(actions: GroupedActions): SessionReceipt;
+export declare function checkReceipt(cwd: string): Promise<CheckResult>;
+export declare function runReceiptCommand(format?: 'ascii' | 'json'): Promise<void>;
+export {};

package/dist/checks/receipt.js

@@ -0,0 +1,306 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { createInterface } from 'node:readline';
+// ── Session file discovery ───────────────────────────────────────────────────
+function walkDir(dir) {
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                results.push(...walkDir(full));
+            else
+                results.push(full);
+        }
+    }
+    catch { /* skip */ }
+    return results;
+}
+export function findSessionFiles(baseDir) {
+    const dir = baseDir || path.join(process.env['HOME'] || '~', '.claude', 'projects');
+    if (!fs.existsSync(dir))
+        return [];
+    return walkDir(dir).filter(f => f.endsWith('.jsonl')).sort();
+}
+export function findLatestSession(baseDir) {
+    const files = findSessionFiles(baseDir);
+    if (files.length === 0)
+        return null;
+    let latest = files[0];
+    let latestMtime = fs.statSync(latest).mtimeMs;
+    for (let i = 1; i < files.length; i++) {
+        const mtime = fs.statSync(files[i]).mtimeMs;
+        if (mtime > latestMtime) {
+            latest = files[i];
+            latestMtime = mtime;
+        }
+    }
+    return latest;
+}
+// ── JSONL parsing ────────────────────────────────────────────────────────────
+export async function parseSessionFile(filePath) {
+    const toolUses = [];
+    const entries = [];
+    const rl = createInterface({ input: fs.createReadStream(filePath, { encoding: 'utf-8' }), crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const entry = JSON.parse(trimmed);
+            entries.push(entry);
+            for (const content of [entry.content, entry.message?.content]) {
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block && typeof block === 'object' && block.type === 'tool_use') {
+                            toolUses.push(block);
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* skip malformed */ }
+    }
+    return { toolUses, entries };
+}
+// ── Action grouper ───────────────────────────────────────────────────────────
+function getFilePath(input) {
+    const p = (input['file_path'] || input['path'] || input['filePath'] || input['filename'] || '');
+    return p || null;
+}
+function extractPackages(cmd, packages) {
+    const npmM = cmd.match(/npm\s+(?:install|i|add)\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (npmM)
+        npmM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+    const yarnM = cmd.match(/yarn\s+add\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (yarnM)
+        yarnM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+    const pipM = cmd.match(/pip3?\s+install\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (pipM)
+        pipM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+}
+function extractUrls(cmd, urls) {
+    const matches = cmd.match(/https?:\/\/[^\s"'`<>|&;]+/g);
+    if (matches)
+        matches.forEach(u => urls.add(u));
+}
+function extractFileOps(cmd, deleted, created) {
+    const rmM = cmd.match(/(?:rm|trash)\s+(?:-[rf]*\s+)*([^\s&|;]+)/);
+    if (rmM && /^(?:rm|trash)\b/.test(cmd))
+        deleted.add(rmM[1]);
+    const touchM = cmd.match(/(?:touch|mkdir)\s+(?:-[p]*\s+)*([^\s&|;]+)/);
+    if (touchM)
+        created.add(touchM[1]);
+}
+function calculateDuration(start, end) {
+    if (!start || !end)
+        return null;
+    try {
+        const diff = new Date(end).getTime() - new Date(start).getTime();
+        return isNaN(diff) ? null : Math.round(diff / 1000);
+    }
+    catch {
+        return null;
+    }
+}
+export function groupActions(toolUses, entries, sessionPath) {
+    const filesModified = new Set();
+    const filesDeleted = new Set();
+    const filesCreated = new Set();
+    const commandsRun = [];
+    const urlsFetched = new Set();
+    const packagesInstalled = new Set();
+    const timestamps = entries.map(e => e.timestamp).filter((t) => typeof t === 'string').sort();
+    for (const tool of toolUses) {
+        const input = tool.input || {};
+        switch (tool.name) {
+            case 'Write':
+            case 'write':
+            case 'write_file':
+            case 'create_file': {
+                const fp = getFilePath(input);
+                if (fp)
+                    filesCreated.add(fp);
+                break;
+            }
+            case 'Edit':
+            case 'edit':
+            case 'edit_file':
+            case 'str_replace_editor': {
+                const fp = getFilePath(input);
+                if (fp)
+                    filesModified.add(fp);
+                break;
+            }
+            case 'Read':
+            case 'read':
+            case 'read_file': break;
+            case 'exec':
+            case 'execute':
+            case 'bash':
+            case 'terminal':
+            case 'run_command': {
+                const cmd = (input['command'] || input['cmd'] || '');
+                if (cmd) {
+                    commandsRun.push(cmd);
+                    extractPackages(cmd, packagesInstalled);
+                    extractUrls(cmd, urlsFetched);
+                    extractFileOps(cmd, filesDeleted, filesCreated);
+                }
+                break;
+            }
+            case 'web_fetch':
+            case 'fetch':
+            case 'http_request':
+            case 'web_search': {
+                const url = (input['url'] || input['query'] || '');
+                if (url)
+                    urlsFetched.add(url);
+                break;
+            }
+            case 'browser': {
+                const url = (input['targetUrl'] || input['url'] || '');
+                if (url)
+                    urlsFetched.add(url);
+                break;
+            }
+        }
+    }
+    for (const f of filesCreated)
+        filesModified.delete(f);
+    return {
+        session_id: path.basename(sessionPath, '.jsonl'),
+        start_time: timestamps[0] || null,
+        end_time: timestamps[timestamps.length - 1] || null,
+        duration_seconds: calculateDuration(timestamps[0], timestamps[timestamps.length - 1]),
+        files_modified: [...filesModified].sort(),
+        files_deleted: [...filesDeleted].sort(),
+        files_created: [...filesCreated].sort(),
+        commands_run: commandsRun,
+        urls_fetched: [...urlsFetched].sort(),
+        packages_installed: [...packagesInstalled].sort(),
+    };
+}
+// ── SHA256 + rendering ───────────────────────────────────────────────────────
+export function computeSha256(content) {
+    return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
+}
+export function renderReceiptText(actions) {
+    const WIDTH = 46;
+    const BORDER = '═'.repeat(WIDTH);
+    const pad = (s) => (s.length >= WIDTH - 2 ? s.slice(0, WIDTH - 2) : s + ' '.repeat(WIDTH - 2 - s.length));
+    const line = (s) => `║ ${pad(s)} ║`;
+    const fmt = (d) => d ? new Date(d).toISOString().replace('T', ' ').replace(/\.\d+Z$/, ' UTC') : 'unknown';
+    const dur = (s) => s === null ? 'unknown' : s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
+    const lines = [];
+    lines.push(`╔${BORDER}╗`);
+    const title = 'AGENT SESSION RECEIPT';
+    const leftPad = Math.floor((WIDTH - 2 - title.length) / 2);
+    const rightPad = WIDTH - 2 - title.length - leftPad;
+    lines.push(`║ ${' '.repeat(leftPad)}${title}${' '.repeat(rightPad)} ║`);
+    lines.push(`╠${BORDER}╣`);
+    lines.push(line(`Session:  ${actions.session_id.slice(0, 30)}`));
+    lines.push(line(`Date:     ${fmt(actions.start_time)}`));
+    lines.push(line(`Duration: ${dur(actions.duration_seconds)}`));
+    lines.push(`╠${BORDER}╣`);
+    const section = (title, items) => {
+        lines.push(line(`${title} (${items.length})`));
+        if (items.length === 0)
+            lines.push(line('  (none)'));
+        else
+            for (const item of items)
+                lines.push(line(`  ${item.slice(0, WIDTH - 6)}`));
+        lines.push(line(''));
+    };
+    section('FILES CREATED', actions.files_created);
+    section('FILES MODIFIED', actions.files_modified);
+    section('FILES DELETED', actions.files_deleted);
+    section('COMMANDS RUN', actions.commands_run);
+    section('URLS FETCHED', actions.urls_fetched);
+    section('PACKAGES INSTALLED', actions.packages_installed);
+    const body = lines.join('\n');
+    const sha256 = computeSha256(body);
+    lines.push(`╠${BORDER}╣`);
+    lines.push(line(`SHA256: ${sha256.slice(0, 36)}`));
+    lines.push(`╚${BORDER}╝`);
+    return lines.join('\n');
+}
+export function renderReceiptJson(actions) {
+    const body = JSON.stringify(actions, null, 2);
+    return { actions, sha256: computeSha256(body), generated_at: new Date().toISOString() };
+}
+// ── CheckResult adapter ──────────────────────────────────────────────────────
+export async function checkReceipt(cwd) {
+    const sessionFile = findLatestSession();
+    const issues = [];
+    if (!sessionFile) {
+        return {
+            name: 'receipt',
+            score: 10,
+            maxScore: 10,
+            issues: [{ severity: 'info', message: 'no claude session files found (~/.claude/projects/)', fixable: false }],
+            summary: 'no session logs found',
+        };
+    }
+    let toolUses = [];
+    let entries = [];
+    try {
+        const parsed = await parseSessionFile(sessionFile);
+        toolUses = parsed.toolUses;
+        entries = parsed.entries;
+    }
+    catch {
+        return {
+            name: 'receipt',
+            score: 10,
+            maxScore: 10,
+            issues: [{ severity: 'warning', message: 'could not parse session file', fixable: false }],
+            summary: 'session parse error',
+        };
+    }
+    const actions = groupActions(toolUses, entries, sessionFile);
+    // Audit observations
+    if (actions.commands_run.length > 20) {
+        issues.push({ severity: 'info', message: `${actions.commands_run.length} commands run in last session — high activity`, fixable: false });
+    }
+    if (actions.files_deleted.length > 0) {
+        issues.push({ severity: 'info', message: `${actions.files_deleted.length} file(s) deleted: ${actions.files_deleted.slice(0, 3).join(', ')}`, fixable: false });
+    }
+    if (actions.packages_installed.length > 0) {
+        issues.push({ severity: 'info', message: `packages installed: ${actions.packages_installed.join(', ')}`, fixable: false });
+    }
+    if (actions.urls_fetched.length > 5) {
+        issues.push({ severity: 'info', message: `${actions.urls_fetched.length} external URLs fetched`, fixable: false });
+    }
+    const totalActions = actions.files_created.length +
+        actions.files_modified.length +
+        actions.files_deleted.length +
+        actions.commands_run.length;
+    const sessionId = path.basename(sessionFile, '.jsonl').slice(0, 20);
+    return {
+        name: 'receipt',
+        score: 10, // Receipt is informational — always full score
+        maxScore: 10,
+        issues,
+        summary: `session ${sessionId}: ${totalActions} actions, ${actions.files_created.length} created, ${actions.files_modified.length} modified`,
+    };
+}
+// ── Standalone subcommand output ─────────────────────────────────────────────
+export async function runReceiptCommand(format = 'ascii') {
+    const sessionFile = findLatestSession();
+    if (!sessionFile) {
+        console.error('no claude session files found in ~/.claude/projects/');
+        process.exit(1);
+    }
+    const { toolUses, entries } = await parseSessionFile(sessionFile);
+    const actions = groupActions(toolUses, entries, sessionFile);
+    if (format === 'json') {
+        const receipt = renderReceiptJson(actions);
+        console.log(JSON.stringify(receipt, null, 2));
+    }
+    else {
+        console.log(renderReceiptText(actions));
+    }
+}

package/dist/checks/scan.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult } from '../types.js';
+export declare function checkScan(cwd: string): CheckResult;

package/dist/checks/scan.js

@@ -0,0 +1,225 @@
+import { join, relative } from 'node:path';
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+const CRITICAL_PATTERNS = [
+    {
+        id: 'base64-url',
+        severity: 'critical',
+        description: 'Base64-encoded URL in config — potential exfiltration endpoint',
+        regex: /(?:aHR0c|data:text\/html;base64)/i,
+    },
+    {
+        id: 'curl-wget',
+        severity: 'critical',
+        description: 'Network download command in agent config — potential remote payload fetch',
+        regex: /(?:curl|wget|fetch)\s+(?:https?:\/\/|[-])/i,
+    },
+    {
+        id: 'shell-injection',
+        severity: 'critical',
+        description: 'Shell injection pattern — command substitution or eval/exec call',
+        regex: /\$\(|`[^`]+`|\beval\b|\bexec\b/,
+    },
+    {
+        id: 'powershell-download',
+        severity: 'critical',
+        description: 'PowerShell download cradle — remote code execution pattern',
+        regex: /powershell.*downloadstring|iex.*webclient/i,
+    },
+];
+const HIGH_PATTERNS = [
+    {
+        id: 'prompt-injection',
+        severity: 'high',
+        description: 'Prompt injection — instructs agent to ignore previous instructions',
+        regex: /ignore\s+(?:all\s+)?previous\s+instructions?/i,
+    },
+    {
+        id: 'system-prompt-override',
+        severity: 'high',
+        description: 'Attempts to override or replace the system prompt',
+        regex: /system\s*prompt\s*(?:override|replace|ignore)/i,
+    },
+    {
+        id: 'forget-prior',
+        severity: 'high',
+        description: 'Instructs agent to forget prior/previous context',
+        regex: /forget\s+(?:all\s+)?(?:prior|previous|earlier)/i,
+    },
+    {
+        id: 'env-var-exfiltration',
+        severity: 'high',
+        description: 'Env var referenced in URL context — potential key exfiltration',
+        regex: /https?:\/\/[^\s"']*\$(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY)/i,
+    },
+    {
+        id: 'permission-escalation',
+        severity: 'high',
+        description: 'Attempts to escalate permissions — sudo, chmod 777, chown root',
+        regex: /sudo|chmod\s+777|chown\s+root/i,
+    },
+    {
+        id: 'hidden-file-write',
+        severity: 'high',
+        description: 'Redirects output to hidden dotfiles or system directories',
+        regex: />\s*~\/\.|>\s*\/etc\//i,
+    },
+];
+const INFO_PATTERNS = [
+    {
+        id: 'external-url',
+        severity: 'info',
+        description: 'External URL in config — often legitimate but worth reviewing',
+        regex: /https?:\/\/[^\s"']+/,
+    },
+    {
+        id: 'sensitive-path',
+        severity: 'info',
+        description: 'Reference to sensitive path (.ssh, .aws, .env, .gnupg)',
+        regex: /\.ssh|\.gnupg|\.aws|\.env/,
+    },
+];
+const ALL_SCAN_PATTERNS = [...CRITICAL_PATTERNS, ...HIGH_PATTERNS, ...INFO_PATTERNS];
+// ── Config file targets ──────────────────────────────────────────────────────
+const CONFIG_TARGETS = [
+    '.claude', 'CLAUDE.md', 'AGENTS.md',
+    '.cursorrules', '.cursor',
+    '.github',
+    '.aider.conf.yml',
+    '.continue',
+    '.mcp',
+    '.roomodes', '.roo',
+];
+// ── File helpers ─────────────────────────────────────────────────────────────
+function isTextFile(filePath) {
+    try {
+        const buf = readFileSync(filePath);
+        const sampleSize = Math.min(512, buf.length);
+        for (let i = 0; i < sampleSize; i++) {
+            if (buf[i] === 0)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function collectDirFiles(dir) {
+    const files = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isFile()) {
+                files.push(full);
+            }
+            else if (entry.isDirectory()) {
+                files.push(...collectDirFiles(full));
+            }
+        }
+    }
+    catch { /* skip */ }
+    return files;
+}
+function collectConfigFiles(cwd) {
+    const files = [];
+    for (const target of CONFIG_TARGETS) {
+        const full = join(cwd, target);
+        if (!existsSync(full))
+            continue;
+        try {
+            const s = statSync(full);
+            if (s.isFile()) {
+                files.push(full);
+            }
+            else if (s.isDirectory()) {
+                files.push(...collectDirFiles(full));
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Copilot instructions
+    const copilot = join(cwd, '.github', 'copilot-instructions.md');
+    if (existsSync(copilot) && !files.includes(copilot)) {
+        files.push(copilot);
+    }
+    return [...new Set(files)];
+}
+function scanContent(content, relPath) {
+    const findings = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of ALL_SCAN_PATTERNS) {
+            if (pattern.regex.test(line)) {
+                pattern.regex.lastIndex = 0;
+                findings.push({
+                    file: relPath,
+                    line: i + 1,
+                    severity: pattern.severity,
+                    description: pattern.description,
+                });
+            }
+            if (pattern.regex.global)
+                pattern.regex.lastIndex = 0;
+        }
+        // Special: base64 that decodes to URL
+        const b64Matches = line.match(/[A-Za-z0-9+/]{20,}={0,2}/g);
+        if (b64Matches) {
+            for (const m of b64Matches) {
+                try {
+                    const decoded = Buffer.from(m, 'base64').toString('utf-8');
+                    if (/https?:\/\//i.test(decoded) && !/[^\x00-\x7F]/.test(decoded)) {
+                        findings.push({
+                            file: relPath,
+                            line: i + 1,
+                            severity: 'critical',
+                            description: 'Base64 string decodes to HTTP URL — likely encoded exfiltration endpoint',
+                        });
+                        break;
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    return findings;
+}
+// ── CheckResult adapter ──────────────────────────────────────────────────────
+export function checkScan(cwd) {
+    const configFiles = collectConfigFiles(cwd);
+    const findings = [];
+    let filesScanned = 0;
+    for (const filePath of configFiles) {
+        if (!isTextFile(filePath))
+            continue;
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const relPath = relative(cwd, filePath);
+            filesScanned++;
+            findings.push(...scanContent(content, relPath));
+        }
+        catch { /* skip */ }
+    }
+    const issues = findings.map(f => ({
+        severity: f.severity === 'critical' ? 'error' : f.severity === 'high' ? 'warning' : 'info',
+        message: f.description,
+        file: f.file,
+        line: f.line,
+        fixable: false,
+    }));
+    const criticals = findings.filter(f => f.severity === 'critical').length;
+    const highs = findings.filter(f => f.severity === 'high').length;
+    const score = Math.max(0, Math.min(10, 10 - criticals * 4 - highs * 1.5));
+    return {
+        name: 'scan',
+        score: Math.round(score * 10) / 10,
+        maxScore: 10,
+        issues,
+        summary: filesScanned === 0
+            ? 'no agent config files found'
+            : findings.length === 0
+                ? `${filesScanned} config file${filesScanned !== 1 ? 's' : ''} scanned, clean`
+                : `${findings.length} finding${findings.length !== 1 ? 's' : ''} in ${filesScanned} config file${filesScanned !== 1 ? 's' : ''}`,
+    };
+}

package/dist/checks/secrets.d.ts

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

package/dist/checks/secrets.js

@@ -0,0 +1,280 @@
+import { existsSync, readdirSync, readFileSync, statSync, createReadStream } from 'node:fs';
+import { join, relative, extname, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+// ── Shannon entropy ──────────────────────────────────────────────────────────
+function calculateEntropy(str) {
+    if (str.length === 0)
+        return 0;
+    const freq = {};
+    for (const ch of str)
+        freq[ch] = (freq[ch] ?? 0) + 1;
+    let entropy = 0;
+    const len = str.length;
+    for (const count of Object.values(freq)) {
+        const p = count / len;
+        entropy -= p * Math.log2(p);
+    }
+    return entropy;
+}
+function isHighEntropy(str) {
+    if (str.length < 20)
+        return false;
+    if (!/^[a-zA-Z0-9+/=_-]+$/.test(str))
+        return false;
+    return calculateEntropy(str) > 4.5;
+}
+const LEAK_PATTERNS = [
+    { name: 'Google API Key', regex: /AIza[0-9A-Za-z_-]{35}/g, severity: 'high' },
+    { name: 'Stripe Secret Key', regex: /sk_live_[0-9a-zA-Z]{24,}/g, severity: 'critical' },
+    { name: 'Stripe Publishable Key', regex: /pk_live_[0-9a-zA-Z]{24,}/g, severity: 'info' },
+    { name: 'Anthropic API Key', regex: /sk-ant-[a-zA-Z0-9_-]{40,}/g, severity: 'critical' },
+    { name: 'OpenAI API Key', regex: /sk-(?!live_)[a-zA-Z0-9]{20,}/g, severity: 'critical' },
+    { name: 'GitHub Token (ghp)', regex: /ghp_[a-zA-Z0-9]{36}/g, severity: 'critical' },
+    { name: 'GitHub Token (gho)', regex: /gho_[a-zA-Z0-9]{36}/g, severity: 'critical' },
+    { name: 'GitHub Token (ghu)', regex: /ghu_[a-zA-Z0-9]{36}/g, severity: 'critical' },
+    { name: 'GitHub Token (ghs)', regex: /ghs_[a-zA-Z0-9]{36}/g, severity: 'critical' },
+    { name: 'GitHub Token (ghr)', regex: /ghr_[a-zA-Z0-9]{36}/g, severity: 'critical' },
+    { name: 'AWS Access Key', regex: /AKIA[0-9A-Z]{16}/g, severity: 'critical' },
+    { name: 'JWT Token', regex: /eyJ[a-zA-Z0-9_-]{10,}\.eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]+/g, severity: 'medium' },
+    { name: 'Private Key', regex: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/g, severity: 'critical' },
+    { name: 'MongoDB Connection String', regex: /mongodb:\/\/[^\s'"]+/g, severity: 'high' },
+    { name: 'Postgres Connection String', regex: /postgres:\/\/[^\s'"]+/g, severity: 'high' },
+    { name: 'MySQL Connection String', regex: /mysql:\/\/[^\s'"]+/g, severity: 'high' },
+    { name: 'Redis Connection String', regex: /redis:\/\/[^\s'"]+/g, severity: 'high' },
+    { name: 'Slack Token', regex: /xox[bpsa]-[a-zA-Z0-9-]+/g, severity: 'critical' },
+    { name: 'Twilio API Key', regex: /SK[a-f0-9]{32}/g, severity: 'high' },
+    { name: 'SendGrid API Key', regex: /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/g, severity: 'high' },
+];
+const ENV_PATTERNS = [
+    { provider: 'Anthropic', pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/, envVars: ['ANTHROPIC_API_KEY'], costEstimate: '$20-500/mo' },
+    { provider: 'OpenAI', pattern: /sk-proj-[a-zA-Z0-9_-]{20,}/, envVars: ['OPENAI_API_KEY'], costEstimate: '$20-1000/mo' },
+    { provider: 'Google AI', pattern: /AIza[a-zA-Z0-9_-]{35}/, envVars: ['GOOGLE_AI_API_KEY', 'GEMINI_API_KEY'], costEstimate: '$10-500/mo' },
+    { provider: 'Replicate', pattern: /r8_[a-zA-Z0-9]{37}/, envVars: ['REPLICATE_API_TOKEN'], costEstimate: '$5-200/mo' },
+    { provider: 'HuggingFace', pattern: /hf_[a-zA-Z0-9]{34}/, envVars: ['HF_TOKEN', 'HUGGINGFACE_API_KEY'], costEstimate: '$0-100/mo' },
+    { provider: 'Groq', pattern: /gsk_[a-zA-Z0-9]{48,}/, envVars: ['GROQ_API_KEY'], costEstimate: '$0-50/mo' },
+    { provider: 'Fireworks', pattern: /fw_[a-zA-Z0-9]{30,}/, envVars: ['FIREWORKS_API_KEY'], costEstimate: '$5-200/mo' },
+    { provider: 'DeepSeek', pattern: /sk-[a-f0-9]{32,}/, envVars: ['DEEPSEEK_API_KEY'], costEstimate: '$5-100/mo' },
+];
+const ENV_ONLY_PROVIDERS = new Set(['Cohere', 'Mistral', 'Together']);
+function detectEnvKeys(line) {
+    const matches = [];
+    const seen = new Set();
+    for (const p of ENV_PATTERNS) {
+        if (p.envVars) {
+            for (const envVar of p.envVars) {
+                const envRe = new RegExp(`${envVar}\\s*=\\s*["']?([^"'\\s#]+)["']?`);
+                const m = line.match(envRe);
+                if (m && m[1] && m[1].length >= 8 && !seen.has(m[1])) {
+                    seen.add(m[1]);
+                    matches.push({ provider: p.provider, key: m[1], costEstimate: p.costEstimate });
+                }
+            }
+        }
+        if (ENV_ONLY_PROVIDERS.has(p.provider))
+            continue;
+        const m = line.match(p.pattern);
+        if (m && m[0] && !seen.has(m[0])) {
+            seen.add(m[0]);
+            matches.push({ provider: p.provider, key: m[0], costEstimate: p.costEstimate });
+        }
+    }
+    return matches;
+}
+function isGitTracked(filePath) {
+    try {
+        const result = execSync(`git ls-files --error-unmatch "${filePath}"`, {
+            cwd: dirname(filePath),
+            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf-8',
+        });
+        return result.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function maskKey(key) {
+    if (key.length <= 8)
+        return '****';
+    return key.slice(0, 4) + '…' + key.slice(-4);
+}
+// ── Build output scanning ────────────────────────────────────────────────────
+const SCANNABLE_EXTS = new Set(['.js', '.mjs', '.cjs', '.css', '.html', '.json', '.map']);
+const SKIP_EXTS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.wasm', '.zip', '.gz', '.br',
+    '.mp4', '.mp3', '.wav', '.webm', '.pdf',
+]);
+const BUILD_DIRS = ['dist', 'build', '.next', 'out', 'public'];
+function detectBuildDir(cwd) {
+    for (const candidate of BUILD_DIRS) {
+        const full = join(cwd, candidate);
+        if (existsSync(full) && statSync(full).isDirectory())
+            return full;
+    }
+    return null;
+}
+function walkBuild(dir) {
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules')
+                    continue;
+                results.push(...walkBuild(full));
+            }
+            else {
+                results.push(full);
+            }
+        }
+    }
+    catch { /* skip */ }
+    return results;
+}
+function shouldScan(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (SKIP_EXTS.has(ext))
+        return false;
+    return SCANNABLE_EXTS.has(ext);
+}
+async function scanBuildFile(filePath) {
+    const findings = [];
+    const ext = extname(filePath).toLowerCase();
+    if (ext === '.map') {
+        findings.push({ name: 'Source Map', severity: 'medium', preview: 'Source map exposes original source code', line: 0 });
+        return findings;
+    }
+    const rl = createInterface({ input: createReadStream(filePath, { encoding: 'utf8' }), crlfDelay: Infinity });
+    let lineNumber = 0;
+    for await (const lineText of rl) {
+        lineNumber++;
+        for (const pattern of LEAK_PATTERNS) {
+            pattern.regex.lastIndex = 0;
+            let m;
+            while ((m = pattern.regex.exec(lineText)) !== null) {
+                const masked = lineText.replace(m[0], m[0].slice(0, 4) + '****' + m[0].slice(-4));
+                findings.push({ name: pattern.name, severity: pattern.severity, preview: masked.slice(0, 120), line: lineNumber });
+                if (m[0].length === 0) {
+                    pattern.regex.lastIndex++;
+                    break;
+                }
+            }
+            pattern.regex.lastIndex = 0;
+        }
+    }
+    return findings;
+}
+// ── Dev environment scanning ─────────────────────────────────────────────────
+function findEnvFiles(dir, maxDepth = 3, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const files = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isFile()) {
+                if (entry.name === '.env' || entry.name.startsWith('.env.') || entry.name.endsWith('.env')) {
+                    files.push(full);
+                }
+            }
+            else if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                files.push(...findEnvFiles(full, maxDepth, depth + 1));
+            }
+        }
+    }
+    catch { /* skip */ }
+    return files;
+}
+function scanEnvFile(filePath) {
+    const findings = [];
+    try {
+        const lines = readFileSync(filePath, 'utf-8').split('\n');
+        const gitTracked = isGitTracked(filePath);
+        for (const line of lines) {
+            if (line.trimStart().startsWith('#'))
+                continue;
+            for (const m of detectEnvKeys(line)) {
+                findings.push({ ...m, gitTracked, file: filePath });
+            }
+        }
+    }
+    catch { /* skip */ }
+    return findings;
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export async function checkSecrets(cwd) {
+    const issues = [];
+    // 1. Build output scan
+    const buildDir = detectBuildDir(cwd);
+    if (buildDir) {
+        const buildFiles = walkBuild(buildDir).filter(f => shouldScan(f));
+        for (const file of buildFiles) {
+            try {
+                const findings = await scanBuildFile(file);
+                for (const f of findings) {
+                    issues.push({
+                        severity: f.severity === 'critical' ? 'error' : f.severity === 'high' ? 'warning' : 'info',
+                        message: `[build] ${f.name}: ${f.preview}`,
+                        file: relative(cwd, file),
+                        line: f.line || undefined,
+                        fixable: false,
+                    });
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    // 2. .env files in project
+    const envFiles = findEnvFiles(cwd);
+    for (const envFile of envFiles) {
+        const findings = scanEnvFile(envFile);
+        for (const f of findings) {
+            const relPath = relative(cwd, f.file);
+            const severity = f.gitTracked ? 'error' : 'warning';
+            issues.push({
+                severity,
+                message: `[env] ${f.provider} key in ${relPath}${f.gitTracked ? ' (git-tracked!)' : ''} — ${maskKey(f.key)} (${f.costEstimate})`,
+                file: relPath,
+                fixable: false,
+                fixHint: f.gitTracked ? 'remove from git: git rm --cached ' + relPath : undefined,
+            });
+        }
+    }
+    // 3. Home dotfiles (shell history, rc files)
+    const home = homedir();
+    const dotfiles = ['.bashrc', '.zshrc', '.bash_profile', '.profile', '.zprofile'];
+    for (const name of dotfiles) {
+        const fp = join(home, name);
+        if (!existsSync(fp))
+            continue;
+        const findings = scanEnvFile(fp);
+        for (const f of findings) {
+            issues.push({
+                severity: 'warning',
+                message: `[home] ${f.provider} key in ~/${name} — ${maskKey(f.key)} (${f.costEstimate})`,
+                file: `~/${name}`,
+                fixable: false,
+            });
+        }
+    }
+    // Score: each critical issue = -3, warning = -1
+    const errors = issues.filter(i => i.severity === 'error').length;
+    const warnings = issues.filter(i => i.severity === 'warning').length;
+    const score = Math.max(0, Math.min(10, 10 - errors * 3 - warnings * 1));
+    const buildNote = buildDir ? '' : ' (no build dir found)';
+    return {
+        name: 'secrets',
+        score: Math.round(score * 10) / 10,
+        maxScore: 10,
+        issues,
+        summary: issues.length === 0
+            ? `no leaked secrets detected${buildNote}`
+            : `${issues.length} secret${issues.length !== 1 ? 's' : ''} found${buildNote}`,
+    };
+}

package/dist/cli.js

@@ -8,6 +8,10 @@ import { checkModels } from './checks/models.js';
 import { checkLinks } from './checks/links.js';
 import { checkConfig } from './checks/config.js';
 import { checkHistory } from './checks/history.js';
+import { checkScan } from './checks/scan.js';
+import { checkSecrets } from './checks/secrets.js';
+import { checkReceipt, runReceiptCommand } from './checks/receipt.js';
+import { checkEdge, runEdgeCommand } from './checks/edge.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON } from './reporter.js';
 const args = process.argv.slice(2);
@@ -35,6 +39,20 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet --since HEAD~5     check specific commit range
     npx @safetnsr/vet --watch            live monitoring during AI sessions
     npx @safetnsr/vet init               generate configs + hooks
+    npx @safetnsr/vet receipt            show last agent session receipt
+    npx @safetnsr/vet edge               show human-edge score for git history
+
+  ${c.dim}checks:${c.reset}
+    ready     codebase readiness for AI agents
+    diff      AI-specific anti-patterns in recent changes
+    models    deprecated/risky model usage
+    links     dead markdown links
+    config    agent config hygiene
+    history   git history quality
+    scan      malicious patterns in agent config files
+    secrets   leaked secrets in build output and .env files
+    receipt   last agent session audit (informational)
+    edge      human replaceability score from git history
 
   ${c.dim}options:${c.reset}
     --ci          CI mode (exit 1 if score < threshold)
@@ -43,6 +61,7 @@ if (flags.has('--help') || flags.has('-h')) {
     --watch       re-run on file changes
     --json        JSON output
     --pretty      force pretty output (even in pipes)
+    --explain     show detailed reasoning (edge subcommand)
     -h, --help    show this help
     -v, --version show version
 `);
@@ -54,11 +73,11 @@ if (flags.has('--version') || flags.has('-v')) {
         console.log(pkg.version);
     }
     catch {
-        console.log('0.2.0');
+        console.log('0.3.0');
     }
     process.exit(0);
 }
-const COMMANDS = ['init'];
+const COMMANDS = ['init', 'receipt', 'edge'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -81,6 +100,16 @@ if (command === 'init') {
     await init(cwd);
     process.exit(0);
 }
+if (command === 'receipt') {
+    const format = isJSON ? 'json' : 'ascii';
+    await runReceiptCommand(format);
+    process.exit(0);
+}
+if (command === 'edge') {
+    const explain = flags.has('--explain');
+    runEdgeCommand(cwd, explain);
+    process.exit(0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -104,7 +133,7 @@ if (isFix) {
     process.exit(0);
 }
 async function runChecks() {
-    const allChecks = ['ready', 'diff', 'models', 'links', 'config', 'history'];
+    const allChecks = ['ready', 'diff', 'models', 'links', 'config', 'history', 'scan', 'secrets', 'receipt', 'edge'];
     const enabledChecks = config.checks || allChecks;
     const results = [];
     // ready and models are async (try rich subpackages first, fallback to built-in)
@@ -120,6 +149,14 @@ async function runChecks() {
         results.push(checkConfig(cwd, ignore));
     if (enabledChecks.includes('history'))
         results.push(checkHistory(cwd));
+    if (enabledChecks.includes('scan'))
+        results.push(checkScan(cwd));
+    if (enabledChecks.includes('secrets'))
+        results.push(await checkSecrets(cwd));
+    if (enabledChecks.includes('receipt'))
+        results.push(await checkReceipt(cwd));
+    if (enabledChecks.includes('edge'))
+        results.push(checkEdge(cwd));
     return score(cwd, results);
 }
 // --watch mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "vet your AI-generated code — one command, six checks, zero config",
   "type": "module",
   "bin": {
@@ -12,7 +12,8 @@
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/cli.ts"
+    "dev": "tsx src/cli.ts",
+    "test": "node --import tsx/esm --test 'test/*.test.mjs'"
   },
   "keywords": [
     "ai",