tribunal-kit 5.8.5 → 6.0.1

package/bin/mcp-server.js

@@ -93,6 +93,10 @@ function searchCaseLaw(query) {
       timeout: SPAWN_TIMEOUT_MS,
     },
   );
+  if (result.error) {
+    if (result.error.code === "ETIMEDOUT") return "Error: Case law search timed out (exceeded 30s limit)";
+    return `Error executing case law search: ${result.error.message}`;
+  }
   return result.stdout || result.stderr || "No results";
 }
 
@@ -106,13 +110,30 @@ function stripBoilerplate(text) {
   return minified.trim();
 }
 
+function getAgentDir() {
+  const fs = require("fs");
+  const local = path.join(process.cwd(), ".agent");
+  if (fs.existsSync(local)) return local;
+  return path.resolve(__dirname, "../.agent");
+}
+
 function handleRequest(req) {
+  const fs = require("fs");
+  if (req.method === "notifications/initialized" || req.method === "notifications/cancelled") {
+    return null;
+  }
+  if (req.method === "ping") {
+    return {};
+  }
+
   // MCP spec: method names follow path-style convention
   if (req.method === "initialize") {
     return {
-      protocolVersion: "2024-11-05",
+      protocolVersion: "2025-03-26",
       capabilities: {
         tools: {},
+        resources: { subscribe: false, listChanged: false },
+        prompts: { listChanged: false },
       },
       serverInfo: {
         name: "tribunal-kit-mcp",
@@ -121,6 +142,148 @@ function handleRequest(req) {
     };
   }
 
+  if (req.method === "resources/list") {
+    const agentDir = getAgentDir();
+    const resources = [];
+    
+    // Agents
+    const agentsDir = path.join(agentDir, "agents");
+    if (fs.existsSync(agentsDir)) {
+      const files = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
+      for (const f of files) {
+        const name = path.basename(f, ".md");
+        resources.push({
+          uri: `tribunal://agent/${name}`,
+          name: `Agent: ${name}`,
+          description: `Tribunal Specialist Agent rule file for ${name}`,
+          mimeType: "text/markdown",
+        });
+      }
+    }
+
+    // Skills
+    const skillsDir = path.join(agentDir, "skills");
+    if (fs.existsSync(skillsDir)) {
+      const dirs = fs.readdirSync(skillsDir, { withFileTypes: true });
+      for (const d of dirs) {
+        if (d.isDirectory()) {
+          const skillFile = path.join(skillsDir, d.name, "SKILL.md");
+          if (fs.existsSync(skillFile)) {
+            resources.push({
+              uri: `tribunal://skill/${d.name}`,
+              name: `Skill: ${d.name}`,
+              description: `Tribunal Skill instruction file for ${d.name}`,
+              mimeType: "text/markdown",
+            });
+          }
+        }
+      }
+    }
+
+    // Workflows
+    const workflowsDir = path.join(agentDir, "workflows");
+    if (fs.existsSync(workflowsDir)) {
+      const files = fs.readdirSync(workflowsDir).filter((f) => f.endsWith(".md"));
+      for (const f of files) {
+        const name = path.basename(f, ".md");
+        resources.push({
+          uri: `tribunal://workflow/${name}`,
+          name: `Workflow: ${name}`,
+          description: `Tribunal Workflow guide for ${name}`,
+          mimeType: "text/markdown",
+        });
+      }
+    }
+
+    return { resources };
+  }
+
+  if (req.method === "resources/read") {
+    const uri = req.params && req.params.uri;
+    if (!uri) throw new Error("Missing uri parameter");
+    const agentDir = getAgentDir();
+    let filePath = null;
+
+    if (uri.startsWith("tribunal://agent/")) {
+      const name = uri.replace("tribunal://agent/", "");
+      filePath = path.join(agentDir, "agents", `${name}.md`);
+    } else if (uri.startsWith("tribunal://skill/")) {
+      const name = uri.replace("tribunal://skill/", "");
+      filePath = path.join(agentDir, "skills", name, "SKILL.md");
+    } else if (uri.startsWith("tribunal://workflow/")) {
+      const name = uri.replace("tribunal://workflow/", "");
+      filePath = path.join(agentDir, "workflows", `${name}.md`);
+    }
+
+    if (!filePath || !fs.existsSync(filePath)) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+
+    const text = fs.readFileSync(filePath, "utf8");
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/markdown",
+          text,
+        },
+      ],
+    };
+  }
+
+  if (req.method === "prompts/list") {
+    const agentDir = getAgentDir();
+    const prompts = [];
+    const workflowsDir = path.join(agentDir, "workflows");
+
+    if (fs.existsSync(workflowsDir)) {
+      const files = fs.readdirSync(workflowsDir).filter((f) => f.endsWith(".md"));
+      for (const f of files) {
+        const name = path.basename(f, ".md");
+        prompts.push({
+          name,
+          description: `Execute tribunal workflow /${name}`,
+          arguments: [
+            {
+              name: "task",
+              description: "The task or target file to execute the workflow against",
+              required: false,
+            },
+          ],
+        });
+      }
+    }
+
+    return { prompts };
+  }
+
+  if (req.method === "prompts/get") {
+    const name = req.params && req.params.name;
+    const task = (req.params && req.params.arguments && req.params.arguments.task) || "";
+    if (!name) throw new Error("Missing prompt name parameter");
+
+    const agentDir = getAgentDir();
+    const workflowPath = path.join(agentDir, "workflows", `${name}.md`);
+    if (!fs.existsSync(workflowPath)) {
+      throw new Error(`Prompt workflow not found: ${name}`);
+    }
+
+    const content = fs.readFileSync(workflowPath, "utf8");
+    const promptText = task ? `${content}\n\nTarget Task/File: ${task}` : content;
+
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: promptText,
+          },
+        },
+      ],
+    };
+  }
+
   if (req.method === "tools/list") {
     return {
       tools: [
@@ -318,26 +481,28 @@ function handleRequest(req) {
           ],
         };
       }
-      // Run synchronously by spawning a minimal script
-      const result = spawnSync(
-        process.execPath,
-        [
-          "-e",
-          `
-                const { generateIDEBridges } = require('${path.resolve(__dirname, "../dist/commands/init.js").replace(/\\/g, "\\\\")}');
-                generateIDEBridges('${cwd.replace(/\\/g, "\\\\")}', '${agentDest.replace(/\\/g, "\\\\")}', false).then(() => console.log('Sync complete'));
-            `,
-        ],
-        { encoding: "utf8", timeout: SPAWN_TIMEOUT_MS },
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: result.stdout || result.stderr || "Sync complete",
-          },
-        ],
-      };
+      try {
+        const { generateIDEBridges } = require(path.resolve(__dirname, "../dist/commands/init.js"));
+        // generateIDEBridges is async — execute synchronously in MCP context
+        generateIDEBridges(cwd, agentDest, true).then(() => {}).catch(() => {});
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Sync complete",
+            },
+          ],
+        };
+      } catch (e) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Sync failed: ${e.message}`,
+            },
+          ],
+        };
+      }
     }
 
     if (toolName === "search_case_law") {
@@ -355,7 +520,7 @@ function handleRequest(req) {
 
     if (toolName === "list_tribunal_agents") {
       const fs = require("fs");
-      const agentDir = path.join(process.cwd(), ".agent", "agents");
+      const agentDir = path.join(getAgentDir(), "agents");
       if (!fs.existsSync(agentDir)) return { content: [{ type: "text", text: "No agents found or .agent directory missing." }] };
       const agents = fs.readdirSync(agentDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
       return { content: [{ type: "text", text: "Available Agents:\n- " + agents.join("\n- ") }] };
@@ -364,10 +529,12 @@ function handleRequest(req) {
     if (toolName === "get_tribunal_agent") {
       const fs = require("fs");
       const name = req.params?.arguments?.name;
-      if (!name) throw { code: -32602, message: "Missing argument: name" };
-      const path = require("path");
+      if (!name || typeof name !== "string") throw { code: -32602, message: "Missing or invalid argument: name (string)" };
       const sanitizedName = path.basename(name);
-      const agentPath = path.join(process.cwd(), ".agent", "agents", `${sanitizedName}.md`);
+      const agentsDir = path.resolve(getAgentDir(), "agents");
+      const agentPath = path.resolve(agentsDir, `${sanitizedName}.md`);
+      // Path containment: ensure resolved path stays within agents directory
+      if (!agentPath.startsWith(agentsDir)) throw { code: -32602, message: "Invalid agent name: path traversal detected" };
       if (!fs.existsSync(agentPath)) return { content: [{ type: "text", text: `Agent '${sanitizedName}' not found.` }] };
       const text = fs.readFileSync(agentPath, "utf8");
       return { content: [{ type: "text", text: stripBoilerplate(text) }] };
@@ -375,7 +542,7 @@ function handleRequest(req) {
 
     if (toolName === "list_tribunal_skills") {
       const fs = require("fs");
-      const skillsDir = path.join(process.cwd(), ".agent", "skills");
+      const skillsDir = path.join(getAgentDir(), "skills");
       if (!fs.existsSync(skillsDir)) return { content: [{ type: "text", text: "No skills found or .agent directory missing." }] };
       const skills = fs.readdirSync(skillsDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name);
       return { content: [{ type: "text", text: "Available Skills:\n- " + skills.join("\n- ") }] };
@@ -384,10 +551,12 @@ function handleRequest(req) {
     if (toolName === "get_tribunal_skill") {
       const fs = require("fs");
       const name = req.params?.arguments?.name;
-      if (!name) throw { code: -32602, message: "Missing argument: name" };
-      const path = require("path");
+      if (!name || typeof name !== "string") throw { code: -32602, message: "Missing or invalid argument: name (string)" };
       const sanitizedName = path.basename(name);
-      const skillPath = path.join(process.cwd(), ".agent", "skills", sanitizedName, "SKILL.md");
+      const skillsDir = path.resolve(getAgentDir(), "skills");
+      const skillPath = path.resolve(skillsDir, sanitizedName, "SKILL.md");
+      // Path containment: ensure resolved path stays within skills directory
+      if (!skillPath.startsWith(skillsDir)) throw { code: -32602, message: "Invalid skill name: path traversal detected" };
       if (!fs.existsSync(skillPath)) return { content: [{ type: "text", text: `Skill '${sanitizedName}' not found.` }] };
       const text = fs.readFileSync(skillPath, "utf8");
       return { content: [{ type: "text", text: stripBoilerplate(text) }] };
@@ -400,14 +569,15 @@ function handleRequest(req) {
 
       if (!task) throw { code: -32602, message: "Missing required argument: task" };
 
-      const agentDest = path.join(process.cwd(), ".agent");
+      const agentDest = getAgentDir();
       const fs = require("fs");
       if (!fs.existsSync(agentDest)) {
         return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
       }
 
       try {
-        const { broker } = require("../.agent/scripts/context_broker.js");
+        const brokerScript = path.join(agentDest, "scripts", "context_broker.js");
+        const { broker } = require(brokerScript);
         const brokerResult = broker(task, files, model, agentDest);
         return { content: [{ type: "text", text: stripBoilerplate(brokerResult.promptText) }] };
       } catch (e) {
@@ -421,7 +591,7 @@ function handleRequest(req) {
         throw { code: -32602, message: "Missing or invalid required argument: query (string)" };
       }
       const budget = req.params?.arguments?.budget || 2000;
-      const agentDest = path.join(process.cwd(), ".agent");
+      const agentDest = getAgentDir();
       const fs = require("fs");
       if (!fs.existsSync(agentDest)) {
         return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
@@ -455,7 +625,7 @@ function handleRequest(req) {
       if (!validTypes.includes(memType)) {
         throw { code: -32602, message: `Invalid memory type: "${memType}". Must be one of: ${validTypes.join(", ")}` };
       }
-      const agentDest = path.join(process.cwd(), ".agent");
+      const agentDest = getAgentDir();
       const fs = require("fs");
       if (!fs.existsSync(agentDest)) {
         return { content: [{ type: "text", text: "Error: .agent/ directory not found. Run `tk init` first." }] };
@@ -498,7 +668,42 @@ function handleRequest(req) {
   throw { code: -32601, message: `Unknown method: ${req.method}` };
 }
 
+function processSingleRequest(req) {
+  try {
+    const result = handleRequest(req);
+    // If it's a notification, do not send a response
+    if (req.id === undefined || req.id === null) {
+      return null;
+    }
+    return { jsonrpc: "2.0", id: req.id, result };
+  } catch (e) {
+    const code = e && typeof e.code === "number" ? e.code : -32603;
+    const message = e && e.message ? e.message : "Internal server error";
+    if (req.id === undefined || req.id === null) {
+      return {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code, message },
+      };
+    }
+    return {
+      jsonrpc: "2.0",
+      id: req.id,
+      error: { code, message },
+    };
+  }
+}
+
 rl.on("line", (line) => {
+  if (line.length > 1048576) { // 1MB limit
+    const errorRes = {
+      jsonrpc: "2.0",
+      id: null,
+      error: { code: -32700, message: "Parse error: input line too long (exceeds 1MB limit)" },
+    };
+    console.log(JSON.stringify(errorRes));
+    return;
+  }
   if (!line.trim()) return;
 
   let req;
@@ -515,31 +720,22 @@ rl.on("line", (line) => {
     return;
   }
 
-  try {
-    const result = handleRequest(req);
-    const res = { jsonrpc: "2.0", id: req.id, result };
-    console.log(JSON.stringify(res));
-
-    // After initialize, send the initialized notification per MCP spec
-    if (req.method === "initialize") {
-      console.log(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/initialized",
-          params: {},
-        }),
-      );
+  if (Array.isArray(req)) {
+    const responses = [];
+    for (const singleReq of req) {
+      const response = processSingleRequest(singleReq);
+      if (response) {
+        responses.push(response);
+      }
+    }
+    if (responses.length > 0) {
+      console.log(JSON.stringify(responses));
+    }
+  } else {
+    const response = processSingleRequest(req);
+    if (response) {
+      console.log(JSON.stringify(response));
     }
-  } catch (e) {
-    // Send proper JSON-RPC error response
-    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/bin/wrapper.js

@@ -24,7 +24,9 @@ const RUST_COMMANDS = new Set([
   "min-context",
   "dag-schedule",
   "context-compress",
+  "context-broker",
   "optimize-step",
+  "impact-tier",
 ]);
 
 
@@ -87,6 +89,7 @@ function getBinaryPath() {
       const buildResult = spawnSync("cargo", ["build", "--release"], {
         cwd: path.resolve(__dirname, ".."),
         stdio: "ignore",
+        timeout: 60000,
       });
       if (buildResult.status === 0) {
         const releasePath = candidatePaths[0];
@@ -115,10 +118,13 @@ function runRustBinary(binPath, args) {
   });
 
   if (result.error) {
-    console.error(
-      `\x1b[91m✖ Failed to execute Rust engine:\x1b[0m ${result.error.message}`,
+    // Graceful degradation: fall back to JS engine instead of hard-crashing.
+    // Spawn errors include missing binaries, permission denied, corrupted
+    // executables, missing shared libraries, and OS-level exec failures.
+    console.warn(
+      `\x1b[93m⚠ Rust engine failed (${result.error.code || result.error.message}). Falling back to JS engine.\x1b[0m`,
     );
-    process.exit(1);
+    return false; // Signal caller to fall back
   }
 
   process.exit(result.status || 0);
@@ -128,7 +134,10 @@ function runLegacyFallback() {
   // Use the modular dist/ CLI with lazy-loaded commands for faster cold-start.
   // Each command module is require()'d only when invoked (~70% fewer files loaded).
   const { main } = require("../dist/cli.js");
-  main();
+  main().catch((err) => {
+    console.error(`\x1b[91m✖ Fatal Error:\x1b[0m ${err.message || err}`);
+    process.exit(1);
+  });
 }
 
 function main() {
@@ -150,13 +159,18 @@ function main() {
 
       // Route to Rust engine
       // console.log('\x1b[90m⚡ Executing via Rust Core Engine\x1b[0m');
-      runRustBinary(binPath, args);
-      return;
+      const rustResult = runRustBinary(binPath, args);
+      if (rustResult !== false) {
+        return; // Rust engine handled it (process.exit was called)
+      }
+      // rustResult === false means spawn error; fall through to JS fallback
     } else {
-      // Warn if Rust command was requested but binary is missing
-      console.warn(
-        "\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m",
-      );
+      // Warn if Rust command was requested but binary is missing (in verbose mode)
+      if (process.env.TK_VERBOSE || process.env.VERBOSE) {
+        console.warn(
+          "\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m",
+        );
+      }
     }
   }
 

package/dist/cli.js

@@ -42,6 +42,15 @@ function parseArgs(argv) {
             args.flags.minimal = true;
             continue;
         }
+        if (arg.startsWith('--profile=')) {
+            args.flags.profile = arg.split('=').slice(1).join('=');
+            continue;
+        }
+        if (arg === '--profile') {
+            const idx = raw.indexOf('--profile');
+            args.flags.profile = raw[idx + 1] || 'full';
+            continue;
+        }
         if (arg === '--skip-update-check') {
             args.flags.skipUpdateCheck = true;
             continue;
@@ -112,6 +121,7 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(cmd('context-compress', 'Compress a context file while retaining VERIFY comments'));
     (0, logger_1.log)(cmd('optimize-step', 'Apply bounded SkillOpt edits from a JSON payload'));
     (0, logger_1.log)(cmd('guardrail', 'Validate .agent/ integrity (phantom refs, count mismatches, drift)'));
+    (0, logger_1.log)(cmd('impact-tier', 'Classify task governance impact tier (0-3)'));
     (0, logger_1.log)(cmd('uninstall', 'Remove .agent/ folder from project'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Options'));
@@ -126,6 +136,7 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(opt('--skip-update-check', 'Skip auto-update version check'));
     (0, logger_1.log)(opt('--head', '(learn) Diff against last commit instead of staged'));
     (0, logger_1.log)(opt('--write', '(align) Write aligned output in-place to the target file'));
+    (0, logger_1.log)(opt('--version, -v', 'Print installed version'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Aliases'));
     (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
@@ -247,6 +258,11 @@ async function runWithUpdateCheck(command, flags) {
             await cmdMarathon(flags, process.argv, quiet);
             break;
         }
+        case 'minimal': {
+            const cmdMinimal = loadCmd('./commands/minimal', 'cmdMinimal');
+            cmdMinimal(flags, quiet);
+            break;
+        }
         case 'compile': {
             const cmdCompile = loadCmd('./commands/compile', 'cmdCompile');
             await cmdCompile(flags, quiet);
@@ -297,12 +313,21 @@ async function runWithUpdateCheck(command, flags) {
             cmdOptimizeStep(process.argv, quiet);
             break;
         }
+        case 'impact-tier': {
+            const cmdImpactTier = loadCmd('./commands/native', 'cmdImpactTier');
+            cmdImpactTier(process.argv, quiet);
+            break;
+        }
         case 'help':
         case '--help':
         case '-h':
         case null:
             cmdHelp(quiet);
             break;
+        case '--version':
+        case '-v':
+            (0, logger_1.log)(CURRENT_VERSION);
+            break;
         default:
             (0, logger_1.err)(`Unknown command: "${command}"`);
             console.log();
@@ -317,5 +342,8 @@ async function main() {
     await runWithUpdateCheck(command, flags);
 }
 if (require.main === module) {
-    main();
+    main().catch(err => {
+        console.error(`\x1b[91m✖ Fatal Error:\x1b[0m ${err.message || err}`);
+        process.exit(1);
+    });
 }

package/dist/commands/compile.js

@@ -74,6 +74,13 @@ async function cmdCompile(flags, quiet) {
         if (flags.target === "claude") targetFile = ".claude.json";
     }
     
+    const byteLength = Buffer.byteLength(compiledContext, "utf-8");
+    const mbSize = byteLength / (1024 * 1024);
+    if (mbSize > 5.0 && !quiet) {
+        const { warn } = require("../utils/logger");
+        warn(`Compiled context is very large (~${mbSize.toFixed(2)} MB). This might overload some LLM context windows.`);
+    }
+
     const outputPath = path.join(cwd, targetFile);
     fs.writeFileSync(outputPath, compiledContext, "utf-8");
     

package/dist/commands/context.js

@@ -19,11 +19,16 @@ function cmdContext(flags, processArgs) {
         console.error('Usage: npx tribunal-kit context <target_file>');
         process.exit(1);
     }
-    const targetFile = args[0].replace(/\\/g, '/');
-    const snapshotName = targetFile.replace(/[\\\/]/g, '__') + '.json';
+    const resolvedTarget = path_1.default.resolve(targetDir, args[0]);
+    const relativePath = path_1.default.relative(targetDir, resolvedTarget).replace(/\\/g, '/');
+    if (relativePath.startsWith('../') || relativePath === '..' || path_1.default.isAbsolute(relativePath)) {
+        console.error('  \x1b[91m✖\x1b[0m File must be within the project directory: ' + args[0]);
+        process.exit(1);
+    }
+    const snapshotName = relativePath.replace(/[\\\/]/g, '__') + '.json';
     const snapshotPath = path_1.default.join(agentDest, 'history', 'snapshots', snapshotName);
     if (!fs_1.default.existsSync(snapshotPath)) {
-        console.error('  \x1b[91m✖\x1b[0m Context Snapshot not found for: ' + targetFile);
+        console.error('  \x1b[91m✖\x1b[0m Context Snapshot not found for: ' + args[0]);
         console.log('    Run: npx tribunal-kit graph  (to generate snapshots)');
         process.exit(1);
     }

package/dist/commands/graph.js

@@ -23,8 +23,14 @@ async function cmdGraph(flags, quiet = false) {
         await (0, helpers_1.runShellAsync)(`node "${builderScript}"`, { stdio: 'inherit', cwd: targetDir });
         await (0, helpers_1.runShellAsync)(`node "${visualizerScript}"`, { stdio: 'inherit', cwd: targetDir });
         (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '▸')} Opening visualizer in browser...`);
-        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-        await (0, helpers_1.runShellAsync)(`${opener} "${htmlFile}"`, { stdio: 'ignore' });
+        const child_process = require('child_process');
+        if (process.platform === 'win32') {
+            child_process.spawn('cmd.exe', ['/c', 'start', '', htmlFile], { stdio: 'ignore', detached: true }).unref();
+        } else if (process.platform === 'darwin') {
+            child_process.spawn('open', [htmlFile], { stdio: 'ignore', detached: true }).unref();
+        } else {
+            child_process.spawn('xdg-open', [htmlFile], { stdio: 'ignore', detached: true }).unref();
+        }
     }
     catch (e) {
         if (e instanceof Error) {

package/dist/commands/init.js

@@ -26,13 +26,22 @@ const CORE_AGENTS = new Set([
     'explorer-agent.md',
     'project-planner.md',
     'test-engineer.md',
+    'ui-ux-auditor.md',
+    'ui-visual-auditor.md',
+    'accessibility-reviewer.md',
+    'ux-reviewer.md',
+    'visual-reviewer.md',
+    'interaction-reviewer.md',
+    'anti-pattern-reviewer.md',
+    'product-reviewer.md',
 ]);
 // Core skills to install in --minimal mode
 const CORE_SKILLS = new Set([
     'clean-code', 'architecture', 'testing-patterns', 'systematic-debugging',
     'frontend-design', 'database-design', 'api-patterns', 'nodejs-best-practices',
     'vulnerability-scanner', 'typescript-advanced', 'python-pro', 'nextjs-react-expert',
-    'react-specialist', 'performance-profiling', 'lint-and-validate',
+    'react-specialist', 'performance-profiling', 'lint-and-validate', 'ui-ux-pro-max',
+    'ui-reasoning-engine', 'product-aware-heuristics', 'web-design-guidelines',
 ]);
 async function cmdInit(flags, quiet = false) {
     const agentSrc = (0, helpers_1.getKitAgent)();
@@ -267,7 +276,7 @@ async function cmdInit(flags, quiet = false) {
             console.log(drawRow('  Next Steps:', (0, logger_1.c)('gray', '  Next Steps:')));
             console.log(stepRow('/generate', 'Generate code with reviews'));
             console.log(stepRow('/review', 'Audit existing code for issues'));
-            console.log(stepRow('/tribunal-full', 'Run all 19 reviewers in parallel'));
+            console.log(stepRow('/tribunal-full', 'Run all 21 reviewers in parallel'));
             console.log(drawRow('', ''));
             console.log(`  ${(0, logger_1.c)(borderCol, '└' + '─'.repeat(W) + '┘')}`);
             console.log();
@@ -399,4 +408,6 @@ async function scaffoldDesignSystem(targetDir, agentSrc, dryRun = false) {
     await copyIfMissing(designMdSrc, designMdDest, 'DESIGN.md System');
     await copyIfMissing(designTokensSrc, designTokensDest, 'Design Tokens');
 }
+exports.CORE_AGENTS = CORE_AGENTS;
+exports.CORE_SKILLS = CORE_SKILLS;