tribunal-kit 5.8.3 → 5.8.5

package/bin/wrapper.js

@@ -21,8 +21,13 @@ const RUST_COMMANDS = new Set([
   "hook",
   "uninstall",
   "memory",
+  "min-context",
+  "dag-schedule",
+  "context-compress",
+  "optimize-step",
 ]);
 
+
 // Determine the path to the compiled Rust binary
 // In a full production release, this checks optionalDependencies in node_modules
 // For development, it checks the local target/release folder
@@ -30,6 +35,11 @@ function getBinaryPath() {
   if (process.env.TRIBUNAL_FORCE_JS === "1") {
     return null;
   }
+
+  if (process.env.TRIBUNAL_CORE_PATH && fs.existsSync(process.env.TRIBUNAL_CORE_PATH)) {
+    return process.env.TRIBUNAL_CORE_PATH;
+  }
+
   const isWindows = os.platform() === "win32";
   const ext = isWindows ? ".exe" : "";
   const platform = os.platform();
@@ -38,46 +48,61 @@ function getBinaryPath() {
   // First, try production resolution (from optionalDependencies)
   const pkgName = `@tribunal-kit/core-${platform}-${arch}`;
   try {
-    // Try to resolve the binary from the optional dependency package
     const pkgPath = require.resolve(`${pkgName}/package.json`);
-    const binPath = path.resolve(
-      path.dirname(pkgPath),
-      `bin/tribunal-core${ext}`,
-    );
+    const pkgDir = path.dirname(pkgPath);
+    const binPath = path.resolve(pkgDir, `bin/tribunal-core${ext}`);
     if (fs.existsSync(binPath)) {
       return binPath;
     }
+    const rootBinPath = path.resolve(pkgDir, `tribunal-core${ext}`);
+    if (fs.existsSync(rootBinPath)) {
+      return rootBinPath;
+    }
   } catch {
     // Package not found, ignore and fall back to local dev targets
   }
 
-  // Second, try to find the binary compiled from crates/core/Cargo.toml (Local dev)
-  const devPath = path.resolve(
-    __dirname,
-    "..",
-    "target",
-    "release",
-    `tribunal-core${ext}`,
-  );
-  if (fs.existsSync(devPath)) {
-    return devPath;
+  // Second, try to find the binary in local dev target directories
+  const candidatePaths = [
+    path.resolve(__dirname, "..", "target", "release", `tribunal-core${ext}`),
+    path.resolve(__dirname, "..", "target", "debug", `tribunal-core${ext}`),
+    path.resolve(__dirname, "..", "..", "target", "release", `tribunal-core${ext}`),
+    path.resolve(__dirname, "..", "..", "target", "debug", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "target", "release", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "target", "debug", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "tribunal-kit", "target", "release", `tribunal-core${ext}`),
+    path.resolve(process.cwd(), "tribunal-kit", "target", "debug", `tribunal-core${ext}`),
+  ];
+
+  for (const candidate of candidatePaths) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
   }
 
-  // Third, try target/debug (if they ran `cargo build` instead of `--release`)
-  const debugPath = path.resolve(
-    __dirname,
-    "..",
-    "target",
-    "debug",
-    `tribunal-core${ext}`,
-  );
-  if (fs.existsSync(debugPath)) {
-    return debugPath;
+  // Third, attempt on-demand compilation if Cargo.toml exists locally and cargo is installed
+  const cargoTomlPath = path.resolve(__dirname, "..", "Cargo.toml");
+  if (fs.existsSync(cargoTomlPath)) {
+    try {
+      const buildResult = spawnSync("cargo", ["build", "--release"], {
+        cwd: path.resolve(__dirname, ".."),
+        stdio: "ignore",
+      });
+      if (buildResult.status === 0) {
+        const releasePath = candidatePaths[0];
+        if (fs.existsSync(releasePath)) {
+          return releasePath;
+        }
+      }
+    } catch {
+      // cargo not available or build failed, fallback gracefully
+    }
   }
 
   return null;
 }
 
+
 function runRustBinary(binPath, args) {
   const stdio = [
     "inherit",

package/dist/cli.js

@@ -105,6 +105,13 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(cmd('hook', 'Install pre-push git hook for auto-learning'));
     (0, logger_1.log)(cmd('compile', 'Compile rules into a static instruction file for terminal agents'));
     (0, logger_1.log)(cmd('memory', '4-Type Taxonomy Persistent Memory Engine (store, recall, gc, stats, export)'));
+    (0, logger_1.log)(cmd('optimize-skill', 'Optimize project skills actively using SkillOpt validation gates'));
+    (0, logger_1.log)(cmd('validate', 'Validate a JSON payload against a Tribunal schema'));
+    (0, logger_1.log)(cmd('min-context', 'Remove empty lines from a context file'));
+    (0, logger_1.log)(cmd('dag-schedule', 'Compute parallel execution waves from task dependencies'));
+    (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('uninstall', 'Remove .agent/ folder from project'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Options'));
@@ -153,6 +160,7 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(ex('echo "Certainly! Here is - item 1" | tk align'));
     (0, logger_1.log)(ex('tk align output.md --write'));
     (0, logger_1.log)(ex('tk memory store --type semantic --content "Uses PostgreSQL" --tags db,orm'));
+    (0, logger_1.log)(ex('tk optimize-skill --target project-idioms "npm test"'));
     (0, logger_1.log)(ex('tk memory recall --query "database" --budget 2000'));
     (0, logger_1.log)(ex('tk memory gc'));
     (0, logger_1.log)(ex('tk memory stats'));
@@ -254,6 +262,41 @@ async function runWithUpdateCheck(command, flags) {
             await cmdMemory(flags, process.argv, quiet);
             break;
         }
+        case 'optimize-skill': {
+            const cmdOptimizeSkill = loadCmd('./commands/optimize', 'cmdOptimizeSkill');
+            await cmdOptimizeSkill(flags, process.argv, quiet);
+            break;
+        }
+        case 'guardrail': {
+            const cmdGuardrail = loadCmd('./commands/guardrail', 'cmdGuardrail');
+            await cmdGuardrail(flags, process.argv, quiet);
+            break;
+        }
+        case 'validate': {
+            const cmdValidate = loadCmd('./commands/validate', 'cmdValidate');
+            cmdValidate(flags, process.argv, quiet);
+            break;
+        }
+        case 'min-context': {
+            const cmdMinContext = loadCmd('./commands/native', 'cmdMinContext');
+            cmdMinContext(process.argv, quiet);
+            break;
+        }
+        case 'dag-schedule': {
+            const cmdDagSchedule = loadCmd('./commands/native', 'cmdDagSchedule');
+            cmdDagSchedule(process.argv, quiet);
+            break;
+        }
+        case 'context-compress': {
+            const cmdContextCompress = loadCmd('./commands/native', 'cmdContextCompress');
+            cmdContextCompress(process.argv, quiet);
+            break;
+        }
+        case 'optimize-step': {
+            const cmdOptimizeStep = loadCmd('./commands/native', 'cmdOptimizeStep');
+            cmdOptimizeStep(process.argv, quiet);
+            break;
+        }
         case 'help':
         case '--help':
         case '-h':

package/dist/commands/align.js

@@ -3,7 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const readline = require("readline");
-const { log, err, ok, c, bold, warn } = require("../utils/logger");
+const { _log, err, ok, c, bold, _warn } = require("../utils/logger");
 
 function alignText(text) {
     if (!text) return "";

package/dist/commands/compile.js

@@ -4,7 +4,7 @@ exports.cmdCompile = cmdCompile;
 
 const fs = require("fs");
 const path = require("path");
-const { log, err, ok, c, bold, dbg } = require("../utils/logger");
+const { log, err, ok, c, bold, _dbg } = require("../utils/logger");
 
 async function cmdCompile(flags, quiet) {
     const cwd = process.cwd();

package/dist/commands/guardrail.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * guardrail.js — CLI command handler for `tk guardrail`
+ *
+ * Validates .agent/ files against the integrity manifest using
+ * the Neurosymbolic Guardrail Engine.
+ *
+ * Usage:
+ *   tk guardrail                    → Scan all .agent/ files
+ *   tk guardrail --file output.md   → Validate a specific file
+ *   tk guardrail --fix              → Auto-fix simple violations
+ *   tk guardrail --json             → Output as JSON
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdGuardrail = cmdGuardrail;
+
+const fs = require("fs");
+const path = require("path");
+const logger_1 = require("../utils/logger");
+
+async function cmdGuardrail(flags, argv, quiet) {
+  const projectRoot = flags.path || process.cwd();
+  const agentDir = path.join(projectRoot, ".agent");
+
+  if (!fs.existsSync(agentDir)) {
+    (0, logger_1.err)("No .agent/ directory found. Run `tk init` first.");
+    process.exit(1);
+  }
+
+  // Resolve script paths (installed vs local development)
+  const scriptsDir = path.join(agentDir, "scripts");
+  const manifestScript = path.join(scriptsDir, "integrity_manifest.js");
+  const guardrailScript = path.join(scriptsDir, "guardrail_engine.js");
+
+  if (!fs.existsSync(manifestScript)) {
+    (0, logger_1.err)(
+      "integrity_manifest.js not found in .agent/scripts/. Your installation may be outdated — run `tk update`.",
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(guardrailScript)) {
+    (0, logger_1.err)(
+      "guardrail_engine.js not found in .agent/scripts/. Your installation may be outdated — run `tk update`.",
+    );
+    process.exit(1);
+  }
+
+  // Step 1: Generate manifest
+  if (!quiet) {
+    (0, logger_1.log)(
+      `  ${(0, logger_1.c)("cyan", "◆")} Generating integrity manifest...`,
+    );
+  }
+
+  const { generateManifest, saveManifest } = require(manifestScript);
+  const manifest = generateManifest(projectRoot);
+
+  if (manifest.error) {
+    (0, logger_1.err)(manifest.error);
+    process.exit(1);
+  }
+
+  // Save manifest for future use
+  saveManifest(manifest, projectRoot);
+
+  // Step 2: Determine files to validate
+  const { validate } = require(guardrailScript);
+  const fileArg = extractFileArg(argv);
+  const fixMode = flags.write || argv.includes("--fix");
+  const jsonMode = argv.includes("--json");
+
+  let filesToCheck = [];
+
+  if (fileArg) {
+    const resolved = path.resolve(fileArg);
+    if (!fs.existsSync(resolved)) {
+      (0, logger_1.err)(`File not found: ${fileArg}`);
+      process.exit(1);
+    }
+    filesToCheck.push(resolved);
+  } else {
+    // Scan all .agent/ markdown files
+    filesToCheck = walkAgentFiles(agentDir);
+  }
+
+  if (!quiet) {
+    (0, logger_1.log)(
+      `  ${(0, logger_1.c)("cyan", "◆")} Scanning ${filesToCheck.length} files...`,
+    );
+  }
+
+  // Step 3: Run guardrail engine
+  let totalViolations = 0;
+  let totalCritical = 0;
+  let totalAutoFixed = 0;
+  const allResults = [];
+
+  for (const file of filesToCheck) {
+    const content = fs.readFileSync(file, "utf8");
+    const result = validate(content, manifest, {
+      autoFix: fixMode,
+      context: { projectRoot, filePath: file },
+    });
+
+    if (result.violations.length > 0) {
+      totalViolations += result.violations.length;
+      totalCritical += result.violations.filter(
+        (v) => v.severity === "critical",
+      ).length;
+
+      allResults.push({
+        file: path.relative(projectRoot, file),
+        ...result,
+      });
+
+      // Apply auto-fix
+      if (
+        fixMode &&
+        result.autoFixedContent &&
+        result.autoFixedContent !== content
+      ) {
+        fs.writeFileSync(file, result.autoFixedContent, "utf8");
+        totalAutoFixed++;
+      }
+    }
+  }
+
+  // Step 4: Output results
+  if (jsonMode) {
+    console.log(
+      JSON.stringify(
+        {
+          manifest_summary: {
+            agents: manifest.agents.total,
+            reviewers: manifest.agents.reviewer_count,
+            skills: manifest.skills.total,
+            scripts: manifest.scripts.total,
+            workflows: manifest.workflows.total,
+          },
+          files_scanned: filesToCheck.length,
+          total_violations: totalViolations,
+          critical_violations: totalCritical,
+          auto_fixed: totalAutoFixed,
+          results: allResults,
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  if (quiet) {
+    process.exit(totalCritical > 0 ? 1 : 0);
+    return;
+  }
+
+  // Human-readable output
+  console.log();
+  console.log(
+    `  ${(0, logger_1.c)("cyan", "🛡️")}  ${(0, logger_1.bold)("Guardrail Validation Report")}`,
+  );
+  console.log(`  ${(0, logger_1.c)("gray", "─".repeat(40))}`);
+  console.log(
+    `  Agents:       ${(0, logger_1.c)("white", String(manifest.agents.total))} (${manifest.agents.reviewer_count} reviewers)`,
+  );
+  console.log(
+    `  Skills:       ${(0, logger_1.c)("white", String(manifest.skills.total))}`,
+  );
+  console.log(
+    `  Scripts:      ${(0, logger_1.c)("white", String(manifest.scripts.total))}`,
+  );
+  console.log(
+    `  Workflows:    ${(0, logger_1.c)("white", String(manifest.workflows.total))}`,
+  );
+  console.log(`  ${(0, logger_1.c)("gray", "─".repeat(40))}`);
+  console.log(
+    `  Files scanned: ${(0, logger_1.c)("white", String(filesToCheck.length))}`,
+  );
+  console.log(
+    `  Violations:    ${totalViolations > 0 ? (0, logger_1.c)("yellow", String(totalViolations)) : (0, logger_1.c)("green", "0")}`,
+  );
+  console.log(
+    `  Critical:      ${totalCritical > 0 ? (0, logger_1.c)("red", String(totalCritical)) : (0, logger_1.c)("green", "0")}`,
+  );
+
+  if (fixMode && totalAutoFixed > 0) {
+    console.log(
+      `  Auto-fixed:    ${(0, logger_1.c)("green", String(totalAutoFixed))}`,
+    );
+  }
+
+  console.log(`  ${(0, logger_1.c)("gray", "─".repeat(40))}`);
+
+  // Show violations
+  for (const result of allResults) {
+    console.log(
+      `\n  📄 ${(0, logger_1.c)("cyan", result.file)} — ${result.summary}`,
+    );
+    for (const v of result.violations) {
+      const icon =
+        v.severity === "critical"
+          ? (0, logger_1.c)("red", "●")
+          : v.severity === "warning"
+            ? (0, logger_1.c)("yellow", "●")
+            : (0, logger_1.c)("blue", "●");
+      console.log(
+        `     ${icon} [${(0, logger_1.c)("gray", v.rule)}] ${v.message}`,
+      );
+      if (v.suggestion) {
+        console.log(
+          `        ${(0, logger_1.c)("gray", "💡")} ${(0, logger_1.c)("gray", v.suggestion)}`,
+        );
+      }
+    }
+  }
+
+  if (totalViolations === 0) {
+    console.log(
+      `\n  ${(0, logger_1.c)("green", "✅")} All files clean. Zero phantom references. Zero count mismatches.`,
+    );
+  }
+
+  console.log();
+  process.exit(totalCritical > 0 ? 1 : 0);
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function extractFileArg(argv) {
+  const raw = argv.slice(2);
+  const fileIdx = raw.indexOf("--file");
+  if (fileIdx !== -1 && raw[fileIdx + 1]) {
+    return raw[fileIdx + 1];
+  }
+  // Also check for positional arg after 'guardrail'
+  for (const arg of raw) {
+    if (arg === "guardrail" || arg.startsWith("--")) continue;
+    if (fs.existsSync(arg)) return arg;
+  }
+  return null;
+}
+
+function walkAgentFiles(dir, fileList = []) {
+  if (!fs.existsSync(dir)) return fileList;
+
+  try {
+    const entries = fs.readdirSync(dir);
+    for (const entry of entries) {
+      if (
+        ["node_modules", ".git", "history", ".backups", ".shared"].includes(
+          entry,
+        )
+      ) {
+        continue;
+      }
+      const fullPath = path.join(dir, entry);
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+          walkAgentFiles(fullPath, fileList);
+        } else if (entry.endsWith(".md") || entry.endsWith(".json")) {
+          fileList.push(fullPath);
+        }
+      } catch {
+        // Skip
+      }
+    }
+  } catch {
+    // Skip
+  }
+
+  return fileList;
+}

package/dist/commands/init.js

@@ -267,12 +267,13 @@ 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 20 reviewers in parallel'));
+            console.log(stepRow('/tribunal-full', 'Run all 19 reviewers in parallel'));
             console.log(drawRow('', ''));
             console.log(`  ${(0, logger_1.c)(borderCol, '└' + '─'.repeat(W) + '┘')}`);
             console.log();
             (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '✦ Generating IDE bridge files...')}`);
-            await generateIDEBridges(targetDir, agentDest, dryRun);
+            await generateIDEBridges(targetDir, agentDest, dryRun, isMinimal);
+            await scaffoldDesignSystem(targetDir, agentSrc, dryRun);
         }
         console.log();
     }
@@ -286,8 +287,9 @@ async function cmdInit(flags, quiet = false) {
         process.exit(1);
     }
 }
-async function generateIDEBridges(targetDir, agentDest, dryRun = false) {
-    const rulesFile = path_1.default.join(agentDest, 'rules', 'GEMINI.md');
+async function generateIDEBridges(targetDir, agentDest, dryRun = false, isMinimal = false) {
+    const rulesFilename = isMinimal ? 'kernel.md' : 'GEMINI.md';
+    const rulesFile = path_1.default.join(agentDest, 'rules', rulesFilename);
     let rulesContent = '';
     try {
         rulesContent = await fs_1.default.promises.readFile(rulesFile, 'utf8');
@@ -317,21 +319,21 @@ async function generateIDEBridges(targetDir, agentDest, dryRun = false) {
     // ── 1. Cursor (.cursorrules) ──────────────────────────
     const cursorRules = `# Tribunal Kit — Cursor Bridge
 # Auto-generated by tribunal-kit init. Do not edit manually.
-# Source: .agent/rules/GEMINI.md
+# Source: .agent/rules/${rulesFilename}
 
 ${rulesContent}
 `;
     // ── 2. Windsurf (.windsurfrules) ─────────────────────
     const windsurfRules = `# Tribunal Kit — Windsurf Bridge
 # Auto-generated by tribunal-kit init. Do not edit manually.
-# Source: .agent/rules/GEMINI.md
+# Source: .agent/rules/${rulesFilename}
 
 ${rulesContent}
 `;
     // ── 3. Gemini / Antigravity (.gemini/settings.json) ──
     const geminiSettings = JSON.stringify({
         "rules": [
-            { "path": "../.agent/rules/GEMINI.md", "trigger": "always_on" }
+            { "path": `../.agent/rules/${rulesFilename}`, "trigger": "always_on" }
         ],
         "agents": { "directory": "../.agent/agents" },
         "skills": { "directory": "../.agent/skills" },
@@ -344,21 +346,21 @@ trigger: always_on
 
 # Tribunal Kit — Gemini Bridge
 # Auto-generated by tribunal-kit init.
-# Full rules: .agent/rules/GEMINI.md
+# Full rules: .agent/rules/${rulesFilename}
 
 ${rulesContent}
 `;
     // ── 4. GitHub Copilot (.github/copilot-instructions.md) ──
     const copilotInstructions = `# Tribunal Kit — Copilot Bridge
 # Auto-generated by tribunal-kit init. Do not edit manually.
-# Source: .agent/rules/GEMINI.md
+# Source: .agent/rules/${rulesFilename}
 
 ${rulesContent}
 `;
     // ── 5. Claude (.claude/CLAUDE.md) ─────────────────────
     const claudeRules = `# Tribunal Kit — Claude Bridge
 # Auto-generated by tribunal-kit init. Do not edit manually.
-# Source: .agent/rules/GEMINI.md
+# Source: .agent/rules/${rulesFilename}
 
 ${rulesContent}
 `;
@@ -374,4 +376,27 @@ ${rulesContent}
     await Promise.all(bridges.map(b => writeBridge(b.path, b.content, b.label)));
     console.log();
 }
+async function scaffoldDesignSystem(targetDir, agentSrc, dryRun = false) {
+    const designMdSrc = path_1.default.join(agentSrc, 'templates', 'DESIGN.md');
+    const designTokensSrc = path_1.default.join(agentSrc, 'templates', 'design-tokens.json');
+    const designMdDest = path_1.default.join(targetDir, 'DESIGN.md');
+    const designTokensDest = path_1.default.join(targetDir, 'design-tokens.json');
+
+    const copyIfMissing = async (src, dest, label) => {
+        if (!fs_1.default.existsSync(src)) return;
+        if (fs_1.default.existsSync(dest)) {
+            (0, logger_1.dbg)(`  skip (exists): ${path_1.default.basename(dest)}`);
+            return;
+        }
+        if (dryRun) {
+            (0, logger_1.dbg)(`  would create: ${dest}`);
+            return;
+        }
+        await fs_1.default.promises.copyFile(src, dest);
+        (0, logger_1.ok)(`${label} → ${(0, logger_1.c)('gray', path_1.default.relative(targetDir, dest))}`);
+    };
+
+    await copyIfMissing(designMdSrc, designMdDest, 'DESIGN.md System');
+    await copyIfMissing(designTokensSrc, designTokensDest, 'Design Tokens');
+}