tribunal-kit 6.0.0 → 7.0.0

package/.agent/scripts/migrate_skills_frontmatter.py

@@ -1,64 +1,5 @@
-import os
-import re
-import logging
-from pathlib import Path
+"""
+DEPRECATED — Legacy Python frontmatter migration script.
+Skill frontmatter and VBC protocol verification is managed by node scripts/fix-vbc.js and node .agent/scripts/strengthen_skills.js.
+"""
 
-logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
-
-AGENT_DIR = Path(__file__).parent.parent
-SKILLS_DIR = AGENT_DIR / "skills"
-
-FRONTMATTER_REGEX = re.compile(r"^---\n(.*?)\n---", re.DOTALL | re.MULTILINE)
-
-def inject_routing_frontmatter(content: str) -> str:
-    """Injects a baseline routing block into the YAML frontmatter if it doesn't exist."""
-    match = FRONTMATTER_REGEX.search(content)
-    if not match:
-        return content
-        
-    frontmatter_text = match.group(1)
-    
-    if "\nrouting:" in frontmatter_text or frontmatter_text.startswith("routing:"):
-        # Already migrated
-        return content
-        
-    # Append the routing block to the end of the frontmatter
-    new_routing_block = "\nrouting:\n  domain: general\n  tier: basic"
-    new_frontmatter = frontmatter_text + new_routing_block
-    
-    # Replace the old frontmatter with the new one
-    new_content = content[:match.start(1)] + new_frontmatter + content[match.end(1):]
-    return new_content
-
-def main():
-    if not SKILLS_DIR.exists():
-        logging.error(f"Skills directory not found: {SKILLS_DIR}")
-        return
-
-    skill_dirs = [d for d in SKILLS_DIR.iterdir() if d.is_dir()]
-    migrated_count = 0
-    skipped_count = 0
-    
-    logging.info(f"Scanning {len(skill_dirs)} skill directories for migration...")
-    
-    for skill_dir in skill_dirs:
-        skill_file = skill_dir / "SKILL.md"
-        if not skill_file.exists():
-            continue
-            
-        with open(skill_file, "r", encoding="utf-8") as f:
-            content = f.read()
-            
-        new_content = inject_routing_frontmatter(content)
-        
-        if new_content != content:
-            with open(skill_file, "w", encoding="utf-8") as f:
-                f.write(new_content)
-            migrated_count += 1
-        else:
-            skipped_count += 1
-
-    logging.info(f"Migration complete: {migrated_count} files updated, {skipped_count} skipped.")
-
-if __name__ == "__main__":
-    main()

package/.agent/scripts/minify_context.js

@@ -4,74 +4,70 @@
  * Minifies markdown documentation in the .agent directory to save tokens.
  */
 
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
 function minifyMarkdown(filePath) {
-  let content = fs.readFileSync(filePath, "utf8");
+  let content = fs.readFileSync(filePath, 'utf8');
   const originalLen = content.length;
 
   // 1. Strip repetitive Output Format templates
-  content = content.replace(/## Output Format\n\n```[\s\S]*?```\n/g, "");
+  content = content.replace(/## Output Format\n\n```[\s\S]*?```\n/g, '');
 
   // 2. Convert bloated Cross-Workflow Navigation tables to dense YAML lists
   content = content.replace(
     /## Cross-Workflow Navigation\n\n\|.*?\|[\s\S]*?(?=\n## |\Z)/g,
-    (match) => {
-      const lines = match.trim().split("\n");
+    match => {
+      const lines = match.trim().split('\n');
       const out = [];
       for (const line of lines) {
-        if (
-          line.startsWith("|") &&
-          !line.startsWith("|:") &&
-          !line.startsWith("| After")
-        ) {
+        if (line.startsWith('|') && !line.startsWith('|:') && !line.startsWith('| After')) {
           const parts = line
-            .split("|")
-            .map((p) => p.trim())
+            .split('|')
+            .map(p => p.trim())
             .filter(Boolean);
           if (parts.length >= 2) {
             out.push(`- ${parts[0]} -> ${parts[1]}`);
           }
         }
       }
-      return "## Cross-Workflow Navigation\n" + out.join("\n") + "\n";
+      return '## Cross-Workflow Navigation\n' + out.join('\n') + '\n';
     },
   );
 
   // 3. Collapse multiple empty lines into a single one
-  content = content.replace(/\n{3,}/g, "\n\n");
+  content = content.replace(/\n{3,}/g, '\n\n');
 
   // 4. Remove padding from remaining tables to save space tokens
-  content = content.replace(/^\|.+|$/gm, (match) => {
+  content = content.replace(/^\|.+|$/gm, match => {
     let line = match;
     // remove spaces around |
-    line = line.replace(/\s+\|\s+/g, "|");
-    line = line.replace(/\|\s+/g, "|");
-    line = line.replace(/\s+\|/g, "|");
+    line = line.replace(/\s+\|\s+/g, '|');
+    line = line.replace(/\|\s+/g, '|');
+    line = line.replace(/\s+\|/g, '|');
     return line;
   });
 
   // 5. Remove conversational blockquotes > if they don't contain WARNING/NOTE/IMPORTANT
-  content = content.replace(/^>.*$/gm, (match) => {
+  content = content.replace(/^>.*$/gm, match => {
     if (
-      match.includes("⚠️") ||
-      match.includes("WARNING") ||
-      match.includes("CRITICAL") ||
-      match.includes("!")
+      match.includes('⚠️') ||
+      match.includes('WARNING') ||
+      match.includes('CRITICAL') ||
+      match.includes('!')
     ) {
       return match;
     }
-    return match.replace(/> /g, "").replace(/>/g, "");
+    return match.replace(/> /g, '').replace(/>/g, '');
   });
 
   // 6. Dense Examples (convert ❌ Bad: and ✅ Good: blocks to single lines)
-  content = content.replace(/\n❌ Bad:/g, " ❌");
-  content = content.replace(/\n✅ Good:/g, " ✅");
+  content = content.replace(/\n❌ Bad:/g, ' ❌');
+  content = content.replace(/\n✅ Good:/g, ' ✅');
 
-  fs.writeFileSync(filePath, content, "utf8");
+  fs.writeFileSync(filePath, content, 'utf8');
   return [originalLen, content.length];
 }
 
@@ -89,12 +85,12 @@ function walkDir(dir, callback) {
 }
 
 function main() {
-  const agentDir = path.join(".agent");
+  const agentDir = path.join('.agent');
   let totalOriginal = 0;
   let totalNew = 0;
 
-  walkDir(agentDir, (file) => {
-    if (file.endsWith(".md")) {
+  walkDir(agentDir, file => {
+    if (file.endsWith('.md')) {
       const [orig, newLen] = minifyMarkdown(file);
       totalOriginal += orig;
       totalNew += newLen;
@@ -104,7 +100,7 @@ function main() {
   const saved = totalOriginal - totalNew;
   const percent = totalOriginal > 0 ? (saved / totalOriginal) * 100 : 0;
 
-  console.log("Minification Complete.");
+  console.log('Minification Complete.');
   console.log(`Original size: ${totalOriginal} bytes`);
   console.log(`New size: ${totalNew} bytes`);
   console.log(`Saved: ${saved} bytes (${percent.toFixed(1)}%)`);

package/.agent/scripts/minimal_change_engine.js

@@ -29,42 +29,41 @@
  *   node .agent/scripts/minimal_change_engine.js search --query "fetchRetry"
  */
 
-"use strict";
+'use strict';
 
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
 
 // ── Shared Utilities & Colors ────────────────────────────────────────────────
-const { GREEN, YELLOW, CYAN, RED, BOLD, DIM, RESET } = require("./_colors");
-const { findAgentDir, loadJson, walkDir, DEFAULT_SKIP_DIRS } = require("./_utils");
+const { loadJson, DEFAULT_SKIP_DIRS } = require('./_utils');
 
 // ── Decision Order Hierarchy ─────────────────────────────────────────────────
 const DECISION_HIERARCHY = [
-  "NO_CHANGE",
-  "REUSE",
-  "CONFIGURE",
-  "DELETE",
-  "MODIFY",
-  "EXTEND",
-  "CREATE",
+  'NO_CHANGE',
+  'REUSE',
+  'CONFIGURE',
+  'DELETE',
+  'MODIFY',
+  'EXTEND',
+  'CREATE',
 ];
 
 // ── 14 Standardized Complexity Flag Types ────────────────────────────────────
 const COMPLEXITY_FLAG_TYPES = [
-  "UNNECESSARY_ABSTRACTION",
-  "DUPLICATE_FUNCTIONALITY",
-  "DEPENDENCY_BLOAT",
-  "FILE_PROLIFERATION",
-  "PREMATURE_GENERALIZATION",
-  "SCOPE_EXPANSION",
-  "UNNECESSARY_REWRITE",
-  "FRAMEWORK_REINVENTION",
-  "STANDARD_LIBRARY_REINVENTION",
-  "EXCESSIVE_BOILERPLATE",
-  "SPECULATIVE_FEATURE",
-  "UNJUSTIFIED_INFRASTRUCTURE",
-  "UNNECESSARY_CONFIGURATION",
-  "DEAD_CODE_INTRODUCTION",
+  'UNNECESSARY_ABSTRACTION',
+  'DUPLICATE_FUNCTIONALITY',
+  'DEPENDENCY_BLOAT',
+  'FILE_PROLIFERATION',
+  'PREMATURE_GENERALIZATION',
+  'SCOPE_EXPANSION',
+  'UNNECESSARY_REWRITE',
+  'FRAMEWORK_REINVENTION',
+  'STANDARD_LIBRARY_REINVENTION',
+  'EXCESSIVE_BOILERPLATE',
+  'SPECULATIVE_FEATURE',
+  'UNJUSTIFIED_INFRASTRUCTURE',
+  'UNNECESSARY_CONFIGURATION',
+  'DEAD_CODE_INTRODUCTION',
 ];
 
 // ── Strictness Configurations ────────────────────────────────────────────────
@@ -133,10 +132,10 @@ function calculateMinimalityScore(budget, classification, flags = []) {
   }
 
   // Penalties for complexity flags based on severity
-  flags.forEach((flag) => {
-    if (flag.severity === "high" || flag.severity === "critical") {
+  flags.forEach(flag => {
+    if (flag.severity === 'high' || flag.severity === 'critical') {
       score -= 15;
-    } else if (flag.severity === "medium") {
+    } else if (flag.severity === 'medium') {
       score -= 8;
     } else {
       score -= 4;
@@ -163,55 +162,55 @@ function calculateMinimalityScore(budget, classification, flags = []) {
 /**
  * Detects potential complexity flags within a proposed change or spec.
  */
-function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "balanced") {
+function detectComplexityFlags(proposal = {}, _existingSymbols = [], mode = 'balanced') {
   const flags = [];
   const limits = STRICTNESS_CONFIGS[mode] || STRICTNESS_CONFIGS.balanced;
 
   // Check 1: Dependency Bloat
   if (proposal.dependencies_added > limits.max_deps_warn) {
     flags.push({
-      type: "DEPENDENCY_BLOAT",
-      severity: proposal.dependencies_added > 1 ? "high" : "medium",
+      type: 'DEPENDENCY_BLOAT',
+      severity: proposal.dependencies_added > 1 ? 'high' : 'medium',
       evidence: `${proposal.dependencies_added} new dependency/dependencies proposed.`,
-      location: proposal.target_file || "package.json",
-      reason: "Adding dependencies increases security attack surface and maintenance overhead.",
-      recommended_action: "Use standard library or existing codebase utilities.",
+      location: proposal.target_file || 'package.json',
+      reason: 'Adding dependencies increases security attack surface and maintenance overhead.',
+      recommended_action: 'Use standard library or existing codebase utilities.',
     });
   }
 
   // Check 2: File Proliferation
   if (proposal.files_added > limits.max_files_added_warn) {
     flags.push({
-      type: "FILE_PROLIFERATION",
-      severity: proposal.files_added > 3 ? "high" : "medium",
+      type: 'FILE_PROLIFERATION',
+      severity: proposal.files_added > 3 ? 'high' : 'medium',
       evidence: `${proposal.files_added} new files proposed for creation.`,
-      location: proposal.target_file || "workspace",
-      reason: "Creating multiple new files increases architectural noise and fragmentation.",
-      recommended_action: "Modify or extend existing files instead of creating new ones.",
+      location: proposal.target_file || 'workspace',
+      reason: 'Creating multiple new files increases architectural noise and fragmentation.',
+      recommended_action: 'Modify or extend existing files instead of creating new ones.',
     });
   }
 
   // Check 3: Unnecessary Abstraction
   if (proposal.new_abstractions > limits.max_abstractions_warn) {
     flags.push({
-      type: "UNNECESSARY_ABSTRACTION",
-      severity: "medium",
+      type: 'UNNECESSARY_ABSTRACTION',
+      severity: 'medium',
       evidence: `${proposal.new_abstractions} new abstraction layer(s) proposed.`,
-      location: proposal.target_file || "codebase",
-      reason: "Adding wrappers or single-consumer interfaces increases complexity without benefit.",
-      recommended_action: "Implement concrete logic directly without extra abstraction.",
+      location: proposal.target_file || 'codebase',
+      reason: 'Adding wrappers or single-consumer interfaces increases complexity without benefit.',
+      recommended_action: 'Implement concrete logic directly without extra abstraction.',
     });
   }
 
   // Check 4: Duplicate Functionality
   if (proposal.duplicate_candidates && proposal.duplicate_candidates.length > 0) {
-    proposal.duplicate_candidates.forEach((cand) => {
+    proposal.duplicate_candidates.forEach(cand => {
       flags.push({
-        type: "DUPLICATE_FUNCTIONALITY",
-        severity: "high",
+        type: 'DUPLICATE_FUNCTIONALITY',
+        severity: 'high',
         evidence: `Existing equivalent symbol '${cand.name}' found in ${cand.file}`,
         location: cand.file,
-        reason: "Duplicate functionality leads to fragmented state and maintenance confusion.",
+        reason: 'Duplicate functionality leads to fragmented state and maintenance confusion.',
         recommended_action: `Reuse '${cand.name}' from ${cand.file}`,
       });
     });
@@ -220,11 +219,11 @@ function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "bala
   // Check 5: Framework/Stdlib Reinvention
   if (proposal.reinventing_stdlib) {
     flags.push({
-      type: "STANDARD_LIBRARY_REINVENTION",
-      severity: "medium",
+      type: 'STANDARD_LIBRARY_REINVENTION',
+      severity: 'medium',
       evidence: `Proposed custom utility '${proposal.reinventing_stdlib.name}'`,
-      location: proposal.target_file || "utils",
-      reason: "Language standard library already provides built-in methods for this.",
+      location: proposal.target_file || 'utils',
+      reason: 'Language standard library already provides built-in methods for this.',
       recommended_action: `Use native JS/TS methods (e.g., Array.prototype, URL, crypto).`,
     });
   }
@@ -238,26 +237,26 @@ function detectComplexityFlags(proposal = {}, existingSymbols = [], mode = "bala
 function searchRepositoryForCapability(query, searchDir) {
   const matches = [];
 
-  if (!query || typeof query !== "string") return matches;
+  if (!query || typeof query !== 'string') return matches;
 
   let agentDir = null;
   let current = path.resolve(searchDir || process.cwd());
   const rootPath = path.parse(current).root;
   while (current !== rootPath) {
-    const candidate = path.join(current, ".agent");
+    const candidate = path.join(current, '.agent');
     if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
       agentDir = candidate;
       break;
     }
     current = path.dirname(current);
   }
-  const repoRoot = agentDir ? path.dirname(agentDir) : (searchDir || process.cwd());
+  const repoRoot = agentDir ? path.dirname(agentDir) : searchDir || process.cwd();
 
   const normalizedQuery = query.toLowerCase();
-  const searchKeywords = normalizedQuery.split(/\s+/).filter((k) => k.length > 2);
+  const searchKeywords = normalizedQuery.split(/\s+/).filter(k => k.length > 2);
 
   // Search package.json dependencies
-  const pkgPath = path.join(repoRoot, "package.json");
+  const pkgPath = path.join(repoRoot, 'package.json');
   if (fs.existsSync(pkgPath)) {
     const pkg = loadJson(pkgPath);
     if (pkg) {
@@ -265,12 +264,12 @@ function searchRepositoryForCapability(query, searchDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies,
       };
-      Object.keys(allDeps).forEach((dep) => {
+      Object.keys(allDeps).forEach(dep => {
         if (dep.toLowerCase().includes(normalizedQuery)) {
           matches.push({
-            type: "dependency",
+            type: 'dependency',
             name: dep,
-            file: "package.json",
+            file: 'package.json',
             snippet: `Version: ${allDeps[dep]}`,
           });
         }
@@ -286,28 +285,31 @@ function searchRepositoryForCapability(query, searchDir) {
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (DEFAULT_SKIP_DIRS.has(entry.name) || entry.name === "target") {
+        if (DEFAULT_SKIP_DIRS.has(entry.name) || entry.name === 'target') {
           continue;
         }
         scan(fullPath);
       } else if (entry.isFile() && /\.(js|ts|tsx|jsx|json|md)$/.test(entry.name)) {
         try {
-          const content = fs.readFileSync(fullPath, "utf8");
+          const content = fs.readFileSync(fullPath, 'utf8');
           const lower = content.toLowerCase();
 
-          const hasMatch = searchKeywords.some((kw) => lower.includes(kw));
+          const hasMatch = searchKeywords.some(kw => lower.includes(kw));
           if (hasMatch) {
             const relPath = path.relative(repoRoot, fullPath);
             // Extract function/class exports
-            const symbolRegex = /(?:export\s+(?:function|class|const|let|var|type|interface)|module\.exports\s*=)\s+([A-Za-z0-9_]+)/g;
+            const symbolRegex =
+              /(?:export\s+(?:function|class|const|let|var|type|interface)|module\.exports\s*=)\s+([A-Za-z0-9_]+)/g;
             let m;
             while ((m = symbolRegex.exec(content)) !== null) {
               if (m[1].toLowerCase().includes(normalizedQuery)) {
                 matches.push({
-                  type: "symbol",
+                  type: 'symbol',
                   name: m[1],
                   file: relPath,
-                  snippet: content.substring(Math.max(0, m.index - 40), m.index + 80).replace(/\n/g, " "),
+                  snippet: content
+                    .substring(Math.max(0, m.index - 40), m.index + 80)
+                    .replace(/\n/g, ' '),
                 });
               }
             }
@@ -334,37 +336,37 @@ function classifyProposal(taskDescription, proposal = {}, repoMatches = []) {
   const estimatedLinesAdded = proposal.estimated_lines_added || 0;
 
   if (repoMatches.length > 0 && filesAdded === 0) {
-    return "REUSE";
+    return 'REUSE';
   }
 
   if (filesAdded === 0 && filesModified === 0 && filesDeleted === 0) {
-    return "NO_CHANGE";
+    return 'NO_CHANGE';
   }
 
   if (proposal.is_config_only) {
-    return "CONFIGURE";
+    return 'CONFIGURE';
   }
 
   if (filesDeleted > 0 && filesAdded === 0 && estimatedLinesAdded === 0) {
-    return "DELETE";
+    return 'DELETE';
   }
 
   if (filesAdded === 0 && filesModified <= 2 && newAbstractions === 0) {
-    return "MODIFY";
+    return 'MODIFY';
   }
 
   if (filesAdded <= 2 && newAbstractions <= 1) {
-    return "EXTEND";
+    return 'EXTEND';
   }
 
-  return "CREATE";
+  return 'CREATE';
 }
 
 /**
  * Evaluates an implementation proposal completely.
  */
 function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
-  const mode = options.mode || "balanced";
+  const mode = options.mode || 'balanced';
   const searchDir = options.cwd || process.cwd();
 
   const budget = calculateChangeBudget(proposal);
@@ -379,18 +381,20 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
   const score = calculateMinimalityScore(budget, classification, flags);
 
   const reuseOpportunities = repoMatches.map(
-    (m) => `Reuse existing ${m.type} '${m.name}' in ${m.file}`,
+    m => `Reuse existing ${m.type} '${m.name}' in ${m.file}`,
   );
 
   const recommendedReductions = [];
   if (budget.dependencies_added > 0) {
-    recommendedReductions.push("Avoid introducing new npm dependencies; leverage existing utilities.");
+    recommendedReductions.push(
+      'Avoid introducing new npm dependencies; leverage existing utilities.',
+    );
   }
   if (budget.files_added > 1) {
-    recommendedReductions.push("Combine proposed new files into existing module structure.");
+    recommendedReductions.push('Combine proposed new files into existing module structure.');
   }
   if (budget.new_abstractions > 0) {
-    recommendedReductions.push("Remove single-use interface/class abstractions.");
+    recommendedReductions.push('Remove single-use interface/class abstractions.');
   }
 
   return {
@@ -399,7 +403,7 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
     change_budget: budget,
     complexity_flags: flags,
     reuse_opportunities: reuseOpportunities,
-    unnecessary_changes: flags.map((f) => f.evidence),
+    unnecessary_changes: flags.map(f => f.evidence),
     recommended_reductions: recommendedReductions,
     decision_order: DECISION_HIERARCHY,
     passed: score >= (STRICTNESS_CONFIGS[mode]?.min_score_pass || 75),
@@ -409,14 +413,18 @@ function evaluateMinimalChange(taskDescription, proposal = {}, options = {}) {
 // ── CLI Main Entry Point ────────────────────────────────────────────────────
 if (require.main === module) {
   const args = process.argv.slice(2);
-  const command = args[0] || "evaluate";
-  const taskArg = args.find((a) => a.startsWith("--task="))?.split("=")[1] || "Default Task";
-  const modeArg = args.find((a) => a.startsWith("--mode="))?.split("=")[1] || "balanced";
-
-  if (command === "evaluate" || command === "audit") {
-    const result = evaluateMinimalChange(taskArg, { files_modified: 1, estimated_lines_added: 12 }, { mode: modeArg });
+  const command = args[0] || 'evaluate';
+  const taskArg = args.find(a => a.startsWith('--task='))?.split('=')[1] || 'Default Task';
+  const modeArg = args.find(a => a.startsWith('--mode='))?.split('=')[1] || 'balanced';
+
+  if (command === 'evaluate' || command === 'audit') {
+    const result = evaluateMinimalChange(
+      taskArg,
+      { files_modified: 1, estimated_lines_added: 12 },
+      { mode: modeArg },
+    );
     console.log(JSON.stringify(result, null, 2));
-  } else if (command === "search") {
+  } else if (command === 'search') {
     const matches = searchRepositoryForCapability(taskArg);
     console.log(JSON.stringify(matches, null, 2));
   } else {