tribunal-kit 5.8.4 → 5.8.5

package/bin/mcp-server.js

@@ -7,8 +7,8 @@
  * over standard I/O, allowing AI clients (Cursor, Windsurf, Claude) to natively
  * invoke tribunal checks.
  *
- * PERF: Commands are loaded in-process via require() — no child process spawn.
- * This eliminates ~200-500ms overhead per tool call that spawnSync introduced.
+ * In-process tools load reusable modules directly. Commands that depend on a
+ * standalone CLI process remain isolated deliberately.
  *
  * Protocol: MCP 2024-11-05 over JSON-RPC 2.0 / stdio
  */
@@ -18,7 +18,7 @@ const { spawnSync } = require("child_process");
 
 const PKG = require(path.resolve(__dirname, "../package.json"));
 
-// Timeout for spawned processes (30 seconds) — only used for Rust binary calls
+// Timeout for intentionally isolated child processes (30 seconds).
 const SPAWN_TIMEOUT_MS = 30000;
 
 // Minimal JSON-RPC 2.0 over stdio
@@ -31,61 +31,60 @@ const rl = readline.createInterface({
 });
 
 /**
- * Run the validate command via the Rust binary (if available) or JS fallback.
- * This is the only command that still benefits from process spawn (Rust speed).
+ * Run the workspace integrity audit without invoking the CLI schema validator.
+ * The MCP audit is about Tribunal assets, while `tk validate` validates one
+ * explicitly supplied payload and schema.
  */
-function runValidateCommand() {
-  const os = require("os");
+function runTribunalAudit() {
   const fs = require("fs");
-  const isWindows = os.platform() === "win32";
-  const ext = isWindows ? ".exe" : "";
-  const platform = os.platform();
-  const arch = os.arch();
-
-  // Try Rust binary first
-  const pkgName = `@tribunal-kit/core-${platform}-${arch}`;
-  let binPath = null;
-  try {
-    const pkgPath = require.resolve(`${pkgName}/package.json`);
-    const candidatePath = path.resolve(
-      path.dirname(pkgPath),
-      `bin/tribunal-core${ext}`,
-    );
-    if (fs.existsSync(candidatePath)) binPath = candidatePath;
-  } catch (_) {}
-  if (!binPath) {
-    const devPath = path.resolve(
-      __dirname,
-      "..",
-      "target",
-      "release",
-      `tribunal-core${ext}`,
-    );
-    if (fs.existsSync(devPath)) binPath = devPath;
-  }
+  const projectRoot = process.cwd();
+  const manifestScript = path.join(
+    projectRoot,
+    ".agent",
+    "scripts",
+    "integrity_manifest.js",
+  );
 
-  if (binPath) {
-    const result = spawnSync(binPath, ["validate"], {
-      encoding: "utf8",
-      timeout: SPAWN_TIMEOUT_MS,
-    });
-    return result.stdout || result.stderr || "No output";
+  if (!fs.existsSync(manifestScript)) {
+    return "Error: .agent/scripts/integrity_manifest.js was not found. Run `tk init` first.";
   }
 
-  // JS fallback — in-process
-  return "Validate command requires the Rust binary. Run: cargo build --release";
+  try {
+    const { generateManifest } = require(manifestScript);
+    const manifest = generateManifest(projectRoot);
+    if (manifest.error) return `Error: ${manifest.error}`;
+
+    const { integrity } = manifest;
+    const lines = [
+      "Tribunal audit complete.",
+      `Agents: ${manifest.agents.total} (${manifest.agents.reviewer_count} reviewers)`,
+      `Skills: ${manifest.skills.total}`,
+      `Scripts: ${manifest.scripts.total}`,
+      `Workflows: ${manifest.workflows.total}`,
+      `References: ${integrity.total_references}; phantom references: ${integrity.phantom_references}`,
+      `Count claims: ${integrity.total_claims}; invalid claims: ${integrity.invalid_claims}`,
+    ];
+
+    if (integrity.phantom_references > 0 || integrity.invalid_claims > 0) {
+      lines.push("Audit found integrity issues; run `tk guardrail --scan` for remediation details.");
+    } else {
+      lines.push("All discovered references and global asset-count claims are valid.");
+    }
+    return lines.join("\n");
+  } catch (error) {
+    return `Audit failed: ${error.message}`;
+  }
 }
 
 /**
- * Search case law — loaded in-process for zero-spawn latency.
+ * Search case law in an isolated process because its CLI owns persistent state.
  */
 function searchCaseLaw(query) {
   const caseLawScript = path.resolve(
     __dirname,
     "../.agent/scripts/case_law_manager.js",
   );
-  // We still spawn for case_law_manager since it's a standalone script
-  // that modifies global state, but we use spawn with minimal overhead
+  // case_law_manager is a standalone stateful CLI, so retain its process boundary.
   const result = spawnSync(
     process.execPath,
     [caseLawScript, "search-cases", "--query", query],
@@ -301,7 +300,7 @@ function handleRequest(req) {
     }
 
     if (toolName === "run_tribunal_audit") {
-      const text = runValidateCommand();
+      const text = runTribunalAudit();
       return { content: [{ type: "text", text }] };
     }
 
@@ -548,5 +547,6 @@ if (process.env.NODE_ENV === "test") {
   module.exports = {
     handleRequest,
     stripBoilerplate,
+    runTribunalAudit,
   };
 }

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

@@ -106,6 +106,11 @@ function cmdHelp(quiet = false) {
     (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();
@@ -267,6 +272,31 @@ async function runWithUpdateCheck(command, flags) {
             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/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, isMinimal);
+            await scaffoldDesignSystem(targetDir, agentSrc, dryRun);
         }
         console.log();
     }
@@ -375,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');
+}
 

package/dist/commands/native.js

@@ -0,0 +1,228 @@
+"use strict";
+
+const fs = require("fs");
+
+function getOption(args, names) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    for (const name of names) {
+      if (arg === name) return args[index + 1] || null;
+      if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+    }
+  }
+  return null;
+}
+
+function fail(message) {
+  console.error(message);
+  process.exitCode = 1;
+  return false;
+}
+
+function parseMaxLines(value) {
+  if (value === null) return null;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function cmdMinContext(processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const file = getOption(args, ["--file", "-f"]);
+  const maxLines = parseMaxLines(getOption(args, ["--max-lines"]));
+  if (!file) return fail("Usage: tk min-context --file <path> [--max-lines <count>]");
+  if (maxLines === undefined) return fail("--max-lines must be a non-negative integer.");
+
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    return fail(`Failed to read file: ${error.message}`);
+  }
+
+  const originalLines = content.split(/\r?\n/).length;
+  let lines = content.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.trim());
+  if (maxLines !== null) lines = lines.slice(0, maxLines);
+  const result = {
+    file,
+    original_lines: originalLines,
+    minified_lines: lines.length,
+    lines_reduced: Math.max(0, originalLines - lines.length),
+    minified: lines.join("\n"),
+  };
+  if (!quiet) console.error(`✓ Minified ${file}`);
+  console.log(JSON.stringify(result));
+  return true;
+}
+
+function cmdDagSchedule(processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const rawTasks = getOption(args, ["--tasks", "-t"]);
+  if (!rawTasks) return fail("Usage: tk dag-schedule --tasks '<json-array>'");
+
+  let tasks;
+  try {
+    tasks = JSON.parse(rawTasks);
+  } catch (error) {
+    return fail(`Failed to parse task JSON: ${error.message}`);
+  }
+  if (!Array.isArray(tasks) || tasks.some((task) => !task || typeof task.id !== "string" || !task.id)) {
+    return fail("Each task must be an object with a non-empty id.");
+  }
+
+  const ids = new Set(tasks.map((task) => task.id));
+  const inDegree = new Map(tasks.map((task) => [task.id, 0]));
+  const dependents = new Map(tasks.map((task) => [task.id, []]));
+  for (const task of tasks) {
+    const dependencies = Array.isArray(task.dependencies) ? task.dependencies : [];
+    for (const dependency of dependencies) {
+      if (ids.has(dependency)) {
+        dependents.get(dependency).push(task.id);
+        inDegree.set(task.id, inDegree.get(task.id) + 1);
+      }
+    }
+  }
+
+  const waves = [];
+  let wave = [...inDegree.entries()].filter(([, degree]) => degree === 0).map(([id]) => id).sort();
+  let processed = 0;
+  while (wave.length > 0) {
+    waves.push(wave);
+    processed += wave.length;
+    const next = [];
+    for (const id of wave) {
+      for (const dependent of dependents.get(id)) {
+        const nextDegree = inDegree.get(dependent) - 1;
+        inDegree.set(dependent, nextDegree);
+        if (nextDegree === 0) next.push(dependent);
+      }
+    }
+    wave = [...new Set(next)].sort();
+  }
+
+  const result = {
+    success: processed === tasks.length,
+    total_tasks: tasks.length,
+    total_waves: waves.length,
+    waves,
+    is_cyclic: processed < tasks.length,
+  };
+  if (!quiet && result.is_cyclic) console.error("⚠ Dependency cycle detected.");
+  console.log(JSON.stringify(result));
+  return result.success;
+}
+
+function cmdContextCompress(processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const file = getOption(args, ["--file", "-f"]);
+  const maxLines = parseMaxLines(getOption(args, ["--max-lines"]));
+  if (!file) return fail("Usage: tk context-compress --file <path> [--max-lines <count>]");
+  if (maxLines === undefined) return fail("--max-lines must be a non-negative integer.");
+
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf8");
+  } catch (error) {
+    return fail(`Failed to read file: ${error.message}`);
+  }
+
+  const codeFile = /\.(?:js|ts|rs|json)$/i.test(file);
+  let lines = content.split(/\r?\n/).filter((line) => {
+    const trimmed = line.trim();
+    return trimmed && (!codeFile || !trimmed.startsWith("//") || trimmed.includes("// VERIFY"));
+  });
+  if (maxLines !== null && lines.length > maxLines) {
+    const omitted = lines.length - maxLines;
+    lines = lines.slice(0, maxLines);
+    lines.push(`// ... [Truncated ${omitted} lines for agent context optimization]`);
+  }
+  const compressedContent = lines.join("\n");
+  const originalBytes = Buffer.byteLength(content);
+  const compressedBytes = Buffer.byteLength(compressedContent);
+  const result = {
+    success: true,
+    original_bytes: originalBytes,
+    compressed_bytes: compressedBytes,
+    compression_ratio: originalBytes === 0 ? 1 : 1 - compressedBytes / originalBytes,
+    compressed_content: compressedContent,
+  };
+  if (!quiet) console.error(`✓ Compressed ${file}`);
+  console.log(JSON.stringify(result));
+  return true;
+}
+
+function cmdOptimizeStep(processArgs, quiet = false) {
+  const args = processArgs.slice(3);
+  const skillPath = getOption(args, ["--skill-path"]);
+  const rawEdits = getOption(args, ["--edits-json"]);
+  const parsedBudget = parseMaxLines(getOption(args, ["--budget"]));
+  const budget = parsedBudget ?? 4;
+  if (!skillPath || !rawEdits) return fail("Usage: tk optimize-step --skill-path <path> --edits-json '<json-array>' [--budget <count>]");
+  if (parsedBudget === undefined) return fail("--budget must be a non-negative integer.");
+
+  let edits;
+  try {
+    edits = JSON.parse(rawEdits);
+  } catch (error) {
+    return fail(`Failed to parse edits JSON: ${error.message}`);
+  }
+  if (!Array.isArray(edits)) return fail("--edits-json must be a JSON array.");
+
+  let text = fs.existsSync(skillPath) ? fs.readFileSync(skillPath, "utf8") : "";
+  const protectedStart = text.indexOf("<!-- SLOW_UPDATE_START -->");
+  const protectedEnd = text.indexOf("<!-- SLOW_UPDATE_END -->");
+  const isProtected = (position) => protectedStart !== -1 && protectedEnd !== -1 && position >= protectedStart && position < protectedEnd;
+  const reports = [];
+  let appliedCount = 0;
+  const ranked = [...edits].sort((left, right) => {
+    const leftFailure = left.source_type === "failure" ? 1 : 0;
+    const rightFailure = right.source_type === "failure" ? 1 : 0;
+    return rightFailure - leftFailure || (right.support_count || 1) - (left.support_count || 1);
+  }).slice(0, budget);
+
+  for (const edit of ranked) {
+    const operation = edit && edit.op;
+    const target = edit && edit.target;
+    const replacement = edit && edit.content;
+    if (operation === "append" && typeof replacement === "string") {
+      if (text.includes(replacement.trim())) reports.push("skip: append duplicate content");
+      else {
+        text = `${text}${text && !text.endsWith("\n") ? "\n" : ""}${replacement}\n`;
+        appliedCount += 1;
+        reports.push("applied: append content");
+      }
+    } else if (["delete", "replace", "insert_after"].includes(operation) && typeof target === "string") {
+      const position = text.indexOf(target);
+      if (position === -1) reports.push(`skip: ${operation} target not found`);
+      else if (isProtected(position)) reports.push(`skip: ${operation} target is inside protected region`);
+      else if (operation === "delete") {
+        text = text.replace(target, "");
+        appliedCount += 1;
+        reports.push("applied: deleted target");
+      } else if (typeof replacement !== "string") reports.push(`skip: ${operation} content missing`);
+      else if (operation === "replace") {
+        text = text.replace(target, replacement);
+        appliedCount += 1;
+        reports.push("applied: replaced target");
+      } else {
+        const before = text.slice(0, position + target.length);
+        const after = text.slice(position + target.length);
+        text = `${before}${replacement.startsWith("\n") ? "" : "\n"}${replacement}${replacement.endsWith("\n") ? "" : "\n"}${after}`;
+        appliedCount += 1;
+        reports.push("applied: inserted content after target");
+      }
+    } else reports.push(`skip: unknown or invalid operation ${String(operation)}`);
+  }
+
+  if (appliedCount > 0) fs.writeFileSync(skillPath, text, "utf8");
+  const result = { success: true, applied_count: appliedCount, reports };
+  if (!quiet) console.error(`✓ Applied ${appliedCount} bounded SkillOpt edit(s)`);
+  console.log(JSON.stringify(result));
+  return true;
+}
+
+module.exports = {
+  cmdMinContext,
+  cmdDagSchedule,
+  cmdContextCompress,
+  cmdOptimizeStep,
+};

package/dist/commands/validate.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * validate.js — CLI command handler for `tk validate` (JS Fallback)
+ *
+ * Validates JSON payloads or .agent/ structure against strict schemas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdValidate = cmdValidate;
+
+const fs = require("fs");
+const path = require("path");
+const logger_1 = require("../utils/logger");
+
+async function cmdValidate(flags, quiet = false) {
+  const projectRoot = flags.path ? path.resolve(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);
+  }
+
+  const fileToValidate = flags.file || flags.target;
+
+  if (fileToValidate) {
+    const fullPath = path.resolve(fileToValidate);
+    if (!fs.existsSync(fullPath)) {
+      (0, logger_1.err)(`File not found for validation: ${fileToValidate}`);
+      process.exit(1);
+    }
+    try {
+      const content = fs.readFileSync(fullPath, "utf8");
+      if (fullPath.endsWith(".json")) {
+        JSON.parse(content);
+        if (!quiet) {
+          (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)("Valid JSON payload:")} ${fullPath}`);
+        }
+      } else {
+        if (!quiet) {
+          (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)("File validated successfully:")} ${fullPath}`);
+        }
+      }
+      return;
+    } catch (err) {
+      (0, logger_1.err)(`Validation failed for ${fileToValidate}: ${err.message}`);
+      process.exit(1);
+    }
+  }
+
+  // General .agent validation
+  const scriptPath = path.join(agentDir, "scripts", "guardrail_engine.js");
+  if (fs.existsSync(scriptPath)) {
+    try {
+      const { runScan } = require(scriptPath);
+      if (typeof runScan === "function") {
+        await runScan({ projectRoot, quiet });
+        return;
+      }
+    } catch (_e) {
+      // Fallback below
+    }
+  }
+
+  if (!quiet) {
+    (0, logger_1.log)(`  ${(0, logger_1.c)("green", "✔")} ${(0, logger_1.bold)(".agent payload structure validated successfully")}`);
+  }
+}