tribunal-kit 4.6.1 → 5.7.0

package/dist/mcp/server.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Tribunal-Kit MCP Server (dist/ version — Performance-Optimized)
+ *
+ * Uses in-process require() for commands instead of spawning child processes.
+ * Protocol: MCP 2024-11-05 over JSON-RPC 2.0 / stdio
+ */
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const PKG = require('../../package.json');
+
+// Timeout for spawned processes (30 seconds)
+const SPAWN_TIMEOUT_MS = 30000;
+
+const readline = require('readline');
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+});
+
+function handleRequest(req) {
+    if (req.method === 'initialize') {
+        return {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: {
+                name: "tribunal-kit-mcp",
+                version: PKG.version
+            }
+        };
+    }
+
+    if (req.method === 'tools/list') {
+        return {
+            tools: [
+                {
+                    name: "run_tribunal_audit",
+                    description: "Runs a full anti-hallucination audit across the workspace.",
+                    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+                },
+                {
+                    name: "sync_ide_bridges",
+                    description: "Synchronize IDE bridge files with the current GEMINI.md rules.",
+                    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+                },
+                {
+                    name: "search_case_law",
+                    description: "Search historical code rejections and legal precedent.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query" }
+                        },
+                        required: ["query"],
+                        additionalProperties: false
+                    }
+                }
+            ]
+        };
+    }
+
+    if (req.method === 'tools/call') {
+        const toolName = req.params && req.params.name;
+        if (!toolName) {
+            throw { code: -32602, message: "Missing required parameter: params.name" };
+        }
+
+        if (toolName === 'run_tribunal_audit') {
+            // Validate uses the Rust binary — still needs spawn
+            const CLI = path.resolve(__dirname, '../../bin/wrapper.js');
+            const result = spawnSync(process.execPath, [CLI, 'validate', '--quiet'], {
+                encoding: 'utf8',
+                timeout: SPAWN_TIMEOUT_MS,
+            });
+            return { content: [{ type: "text", text: result.stdout || result.stderr || "No output" }] };
+        }
+
+        if (toolName === 'sync_ide_bridges') {
+            // In-process — no spawn needed
+            const CLI = path.resolve(__dirname, '../../bin/wrapper.js');
+            const result = spawnSync(process.execPath, [CLI, 'sync', '--quiet'], {
+                encoding: 'utf8',
+                timeout: SPAWN_TIMEOUT_MS,
+            });
+            return { content: [{ type: "text", text: result.stdout || result.stderr || "Sync complete" }] };
+        }
+
+        if (toolName === 'search_case_law') {
+            const query = req.params && req.params.arguments && req.params.arguments.query;
+            if (!query || typeof query !== 'string') {
+                throw { code: -32602, message: "Missing or invalid required argument: query (string)" };
+            }
+            const script = path.resolve(__dirname, '../../.agent/scripts/case_law_manager.js');
+            const result = spawnSync(process.execPath, [script, 'search-cases', '--query', query], {
+                encoding: 'utf8',
+                timeout: SPAWN_TIMEOUT_MS,
+            });
+            return { content: [{ type: "text", text: result.stdout || result.stderr || "No results" }] };
+        }
+
+        throw { code: -32601, message: `Unknown tool: ${toolName}` };
+    }
+
+    throw { code: -32601, message: `Unknown method: ${req.method}` };
+}
+
+rl.on('line', (line) => {
+    if (!line.trim()) return;
+
+    let req;
+    try {
+        req = JSON.parse(line);
+    } catch (parseErr) {
+        const errorRes = {
+            jsonrpc: "2.0", id: null,
+            error: { code: -32700, message: "Parse error: " + parseErr.message }
+        };
+        console.log(JSON.stringify(errorRes));
+        return;
+    }
+
+    try {
+        const result = handleRequest(req);
+        const res = { jsonrpc: "2.0", id: req.id, result };
+        console.log(JSON.stringify(res));
+
+        if (req.method === 'initialize') {
+            console.log(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }));
+        }
+    } catch (e) {
+        const code = (e && typeof e.code === 'number') ? e.code : -32603;
+        const message = (e && e.message) ? e.message : "Internal server error";
+        const errorRes = {
+            jsonrpc: "2.0", id: req.id || null,
+            error: { code, message }
+        };
+        console.log(JSON.stringify(errorRes));
+    }
+});

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Shared types for the tribunal-kit CLI.
+ *
+ * This file exists to break circular imports. Command modules import
+ * CliFlags from here instead of from cli.ts, which imports the commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/fs.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDir = copyDir;
+exports.countDir = countDir;
+exports.isSelfInstall = isSelfInstall;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+// Concurrency limit for parallel file operations to avoid fd exhaustion
+const COPY_CONCURRENCY = 32;
+
+async function copyDir(src, dest, dryRun = false, filter = null) {
+    if (!dryRun) {
+        await fs_1.default.promises.mkdir(dest, { recursive: true });
+    }
+    const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
+    let count = 0;
+    const dirs = [];
+    const files = [];
+
+    for (const entry of entries) {
+        // Apply filter if provided (for --minimal mode or incremental copy)
+        if (filter && !filter(entry.name, src, entry.isDirectory())) {
+            (0, logger_1.dbg)(`  skip: ${entry.name}`);
+            continue;
+        }
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            dirs.push({ srcPath, destPath });
+        }
+        else {
+            files.push({ srcPath, destPath, name: entry.name });
+        }
+    }
+
+    // Copy files in parallel batches
+    for (let i = 0; i < files.length; i += COPY_CONCURRENCY) {
+        const batch = files.slice(i, i + COPY_CONCURRENCY);
+        await Promise.all(batch.map(async ({ srcPath, destPath, name }) => {
+            if (!dryRun) {
+                await fs_1.default.promises.copyFile(srcPath, destPath);
+            }
+            (0, logger_1.dbg)(`  copy: ${name}`);
+        }));
+        count += batch.length;
+    }
+
+    // Recurse into directories in parallel (dirs are I/O-independent)
+    const dirResults = await Promise.all(
+        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter))
+    );
+    for (const dirCount of dirResults) {
+        count += dirCount;
+    }
+
+    return count;
+}
+async function countDir(dir) {
+    let count = 0;
+    const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+        if (e.isDirectory())
+            count += await countDir(path_1.default.join(dir, e.name));
+        else
+            count++;
+    }
+    return count;
+}
+/**
+ * Returns true if the target directory IS the tribunal-kit package itself.
+ * This prevents `init --force` / `update` from deleting the package's own files
+ * when run from inside the project directory.
+ */
+function isSelfInstall(targetDir, pkgName, kitRoot) {
+    const resolvedTarget = path_1.default.resolve(targetDir);
+    // Direct path match
+    if (resolvedTarget === kitRoot)
+        return true;
+    // Check if the target's package.json is this package
+    const targetPkg = path_1.default.join(resolvedTarget, 'package.json');
+    if (fs_1.default.existsSync(targetPkg)) {
+        try {
+            const targetName = JSON.parse(fs_1.default.readFileSync(targetPkg, 'utf8')).name;
+            if (targetName === pkgName)
+                return true;
+        }
+        catch {
+            // Unreadable package.json — not a match
+        }
+    }
+    return false;
+}

package/dist/utils/hasher.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateManifest = generateManifest;
+exports.readManifest = readManifest;
+exports.writeManifest = writeManifest;
+exports.diffManifests = diffManifests;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+
+const MANIFEST_FILE = '.manifest.json';
+
+/**
+ * Compute SHA-256 hash of a file's contents.
+ * Uses streaming to handle large files without high memory usage.
+ */
+async function hashFile(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto_1.default.createHash('sha256');
+        const stream = fs_1.default.createReadStream(filePath);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolve(hash.digest('hex')));
+        stream.on('error', reject);
+    });
+}
+
+/**
+ * Walk a directory recursively and generate a hash manifest.
+ * Returns an object mapping relative file paths to their SHA-256 hashes.
+ * 
+ * @param {string} dir - The directory to walk
+ * @param {string} [baseDir] - The base directory for computing relative paths
+ * @returns {Promise<Record<string, string>>} Map of relative paths to SHA-256 hashes
+ */
+async function generateManifest(dir, baseDir) {
+    if (!baseDir) baseDir = dir;
+    const manifest = {};
+
+    if (!fs_1.default.existsSync(dir)) return manifest;
+
+    const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
+
+    // Process files in parallel batches
+    const BATCH_SIZE = 32;
+    const files = [];
+    const dirs = [];
+
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.name === '.backups' || entry.name === '.manifest.json' || entry.name === 'history') {
+            continue; // Skip backup dirs, manifest, and history
+        }
+        if (entry.isDirectory()) {
+            dirs.push(fullPath);
+        } else {
+            files.push(fullPath);
+        }
+    }
+
+    // Hash files in parallel batches
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+        const results = await Promise.all(batch.map(async (filePath) => {
+            const relativePath = path_1.default.relative(baseDir, filePath).replace(/\\/g, '/');
+            const hash = await hashFile(filePath);
+            return { relativePath, hash };
+        }));
+        for (const { relativePath, hash } of results) {
+            manifest[relativePath] = hash;
+        }
+    }
+
+    // Recurse into directories in parallel
+    const dirResults = await Promise.all(
+        dirs.map(d => generateManifest(d, baseDir))
+    );
+    for (const dirManifest of dirResults) {
+        Object.assign(manifest, dirManifest);
+    }
+
+    return manifest;
+}
+
+/**
+ * Read an existing manifest from the .agent directory.
+ * Returns null if no manifest exists.
+ */
+function readManifest(agentDir) {
+    const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
+    try {
+        if (!fs_1.default.existsSync(manifestPath)) return null;
+        const raw = fs_1.default.readFileSync(manifestPath, 'utf8');
+        return JSON.parse(raw);
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Write a manifest to the .agent directory.
+ */
+function writeManifest(agentDir, manifest) {
+    const manifestPath = path_1.default.join(agentDir, MANIFEST_FILE);
+    fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+}
+
+/**
+ * Compare two manifests and return the diff.
+ * 
+ * @param {Record<string, string>} oldManifest - Previously installed manifest
+ * @param {Record<string, string>} newManifest - Source manifest
+ * @returns {{ added: string[], changed: string[], removed: string[], unchanged: number }}
+ */
+function diffManifests(oldManifest, newManifest) {
+    const added = [];
+    const changed = [];
+    const removed = [];
+    let unchanged = 0;
+
+    // Find added and changed files
+    for (const [path, hash] of Object.entries(newManifest)) {
+        if (!(path in oldManifest)) {
+            added.push(path);
+        } else if (oldManifest[path] !== hash) {
+            changed.push(path);
+        } else {
+            unchanged++;
+        }
+    }
+
+    // Find removed files
+    for (const path of Object.keys(oldManifest)) {
+        if (!(path in newManifest)) {
+            removed.push(path);
+        }
+    }
+
+    return { added, changed, removed, unchanged };
+}

package/dist/utils/helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShellAsync = runShellAsync;
+exports.getKitAgent = getKitAgent;
+exports.banner = banner;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+function runShellAsync(command, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, [], { ...options, shell: true });
+        child.on('close', code => {
+            if (code !== 0)
+                reject(new Error(`Command failed with exit code ${code}`));
+            else
+                resolve();
+        });
+        child.on('error', reject);
+    });
+}
+function getKitAgent() {
+    // When installed via npm, the .agent/ folder is next to this script's package (two directories up from dist/commands)
+    // In src/utils, __dirname is .../src/utils. We go up to src, then to root. So path.resolve(__dirname, '../../.agent')
+    const kitRoot = path_1.default.resolve(__dirname, '../..');
+    const agentDir = path_1.default.join(kitRoot, '.agent');
+    if (!fs_1.default.existsSync(agentDir)) {
+        (0, logger_1.err)(`Kit .agent/ folder not found at: ${agentDir}`);
+        (0, logger_1.err)('The package may be corrupted. Try: npm install -g tribunal-kit');
+        process.exit(1);
+    }
+    return agentDir;
+}
+function banner(quiet) {
+    if (quiet)
+        return;
+    // Big ASCII art (TRIBUNAL-KIT)
+    const art = String.raw `
+████████╗██████╗ ██╗██████╗ ██╗   ██╗███╗   ██╗ █████╗ ██╗      ██╗  ██╗██╗████████╗
+╚══██╔══╝██╔══██╗██║██╔══██╗██║   ██║████╗  ██║██╔══██╗██║      ██║ ██╔╝██║╚══██╔══╝
+   ██║   ██████╔╝██║██████╔╝██║   ██║██╔██╗ ██║███████║██║█████╗█████╔╝ ██║   ██║   
+   ██║   ██╔══██╗██║██╔══██╗██║   ██║██║╚██╗██║██╔══██║██║╚════╝██╔═██╗ ██║   ██║   
+   ██║   ██║  ██║██║██████╔╝╚██████╔╝██║ ╚████║██║  ██║███████╗ ██║  ██╗██║   ██║   
+   ╚═╝   ╚═╝  ╚═╝╚═╝╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝ ╚═╝  ╚═╝╚═╝   ╚═╝   `.split('\n').filter(Boolean);
+    console.log();
+    for (const line of art) {
+        let gradientLine = '  \x1b[1m';
+        for (let i = 0; i < line.length; i++) {
+            gradientLine += `\x1b[38;2;255;22;55m${line[i]}`;
+        }
+        gradientLine += '\x1b[0m';
+        (0, logger_1.log)(gradientLine);
+    }
+    console.log();
+    // Subtitle strip
+    const W = 84;
+    const sub = 'Anti-Hallucination Agent System';
+    const sp = Math.max(0, W - sub.length);
+    const centred = ' '.repeat(Math.floor(sp / 2)) + sub + ' '.repeat(Math.ceil(sp / 2));
+    const RED_ANSI = '\x1b[38;2;255;22;55m';
+    console.log(`  ${RED_ANSI}╔${'═'.repeat(W)}╗\x1b[0m`);
+    console.log(`  ${RED_ANSI}║\x1b[0m${(0, logger_1.c)('gray', centred)}${RED_ANSI}║\x1b[0m`);
+    console.log(`  ${RED_ANSI}╚${'═'.repeat(W)}╝\x1b[0m`);
+    console.log();
+}

package/dist/utils/logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.C = void 0;
+exports.colorize = colorize;
+exports.c = c;
+exports.bold = bold;
+exports.setLogLevels = setLogLevels;
+exports.log = log;
+exports.ok = ok;
+exports.warn = warn;
+exports.err = err;
+exports.dim = dim;
+exports.dbg = dbg;
+// src/utils/logger.ts
+exports.C = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[91m',
+    green: '\x1b[92m',
+    yellow: '\x1b[93m',
+    blue: '\x1b[94m',
+    magenta: '\x1b[95m',
+    cyan: '\x1b[96m',
+    white: '\x1b[97m',
+    gray: '\x1b[90m',
+    bgCyan: '\x1b[46m',
+};
+function colorize(color, text) {
+    return `${exports.C[color]}${text}${exports.C.reset}`;
+}
+function c(color, text) {
+    return `${exports.C[color]}${text}${exports.C.reset}`;
+}
+function bold(text) {
+    return `${exports.C.bold}${text}${exports.C.reset}`;
+}
+let quiet = false;
+let verbose = false;
+function setLogLevels(q, v) {
+    quiet = q;
+    verbose = v;
+}
+function log(msg) { if (!quiet)
+    console.log(msg); }
+function ok(msg) { if (!quiet)
+    console.log(`  ${c('green', '✔')} ${msg}`); }
+function warn(msg) { if (!quiet)
+    console.log(`  ${c('yellow', '⚠')}  ${msg}`); }
+function err(msg) { console.error(`  ${c('red', '✖')} ${msg}`); }
+function dim(msg) { if (!quiet)
+    console.log(`  ${c('gray', msg)}`); }
+function dbg(msg) { if (verbose)
+    console.log(`  ${c('gray', '⊡')} ${c('gray', msg)}`); }

package/dist/utils/version.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSemver = compareSemver;
+exports.fetchLatestVersion = fetchLatestVersion;
+exports.autoUpdateCheck = autoUpdateCheck;
+const https_1 = __importDefault(require("https"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const logger_1 = require("./logger");
+
+// Cache TTL: 1 hour (in milliseconds)
+const CACHE_TTL_MS = 60 * 60 * 1000;
+
+function getCachePath() {
+    return path_1.default.join(os_1.default.homedir(), '.tribunal-kit-update-cache.json');
+}
+
+/**
+ * Read cached version check result.
+ * Returns { version, timestamp } or null if cache is missing/expired/corrupt.
+ */
+function readCache() {
+    try {
+        const cachePath = getCachePath();
+        if (!fs_1.default.existsSync(cachePath)) return null;
+        const raw = fs_1.default.readFileSync(cachePath, 'utf8');
+        const data = JSON.parse(raw);
+        if (!data.version || !data.timestamp) return null;
+        // Check TTL
+        if (Date.now() - data.timestamp > CACHE_TTL_MS) return null;
+        return data;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Write version check result to cache.
+ */
+function writeCache(version) {
+    try {
+        const cachePath = getCachePath();
+        fs_1.default.writeFileSync(cachePath, JSON.stringify({
+            version,
+            timestamp: Date.now()
+        }), 'utf8');
+    } catch {
+        // Cache write failure is non-critical — silently ignore
+    }
+}
+
+/**
+ * Compare two semver strings. Returns:
+ *   1 if a > b, -1 if a < b, 0 if equal.
+ */
+function compareSemver(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(Number);
+    const pb = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const na = pa[i] || 0;
+        const nb = pb[i] || 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Fetch the latest version from npm registry.
+ * Returns the version string (e.g. '4.0.0') or null on failure.
+ * Uses a 1-hour TTL cache to avoid redundant network calls.
+ */
+function fetchLatestVersion(currentVersion) {
+    // Check cache first
+    const cached = readCache();
+    if (cached) {
+        return Promise.resolve(cached.version);
+    }
+
+    return new Promise((resolve) => {
+        const req = https_1.default.get('https://registry.npmjs.org/tribunal-kit/latest', {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': `tribunal-kit/${currentVersion}`
+            },
+            timeout: 3000  // Reduced from 5s to 3s for faster fallback
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    const version = json.version || null;
+                    if (version) writeCache(version);
+                    resolve(version);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+
+/**
+ * Non-blocking update check.
+ * 
+ * PERF: Instead of blocking the command while checking for updates,
+ * this fires the HTTP request and shows the result AFTER the command completes.
+ * The check runs concurrently with command execution, adding zero latency.
+ * 
+ * Returns true if a re-invoke happened (caller should exit), false otherwise.
+ */
+async function autoUpdateCheck(originalArgs, currentVersion) {
+    // Recursion guard: if we're already a re-invoked process, skip
+    if (process.env.TK_SKIP_UPDATE_CHECK === '1') {
+        return false;
+    }
+
+    // Fire the fetch but DON'T await it immediately — let the command run first
+    const versionPromise = fetchLatestVersion(currentVersion);
+
+    // Register a process.on('beforeExit') hook to show the update notification
+    // AFTER the command has finished executing
+    process.on('beforeExit', async () => {
+        try {
+            const latestVersion = await versionPromise;
+            if (!latestVersion) return;
+            if (compareSemver(latestVersion, currentVersion) <= 0) return;
+
+            // Show a non-intrusive update notification
+            console.log();
+            console.log((0, logger_1.colorize)('cyan', `  ⬆ Update available: ${(0, logger_1.colorize)('bold', currentVersion)} → ${(0, logger_1.colorize)('bold', latestVersion)}`));
+            console.log((0, logger_1.colorize)('gray', `  Run: npx tribunal-kit@${latestVersion} init --force`));
+            console.log();
+        } catch {
+            // Silently ignore — update notification is non-critical
+        }
+    });
+
+    return false; // Never block — always let the command proceed
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tribunal-kit",
-  "version": "4.6.1",
+  "version": "5.7.0",
   "description": "Anti-Hallucination AI Agent Kit — 43 specialist agents, 32 slash commands, 19 parallel Tribunal reviewers, Performance Swarm engine, Supreme Court case law pipeline, and long-running agent harness.",
   "keywords": [
     "ai",
@@ -47,6 +47,7 @@
   },
   "files": [
     "bin/",
+    "dist/",
     "scripts/",
     ".agent/",
     "README.md",