tribunal-kit 5.8.3 → 5.8.5

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/optimize.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdOptimizeSkill = cmdOptimizeSkill;
+
+const fs = __importDefault(require("fs"));
+const path = __importDefault(require("path"));
+const os = __importDefault(require("os"));
+const https = __importDefault(require("https"));
+const { execSync } = require("child_process");
+const logger = require("../utils/logger");
+const helpers = require("../utils/helpers");
+
+// ── LLM Helpers ──────────────────────────────────────────────────────────────
+function detectLlmProvider() {
+    if (process.env.ANTHROPIC_API_KEY)
+        return { provider: "anthropic", key: process.env.ANTHROPIC_API_KEY };
+    if (process.env.OPENAI_API_KEY)
+        return { provider: "openai", key: process.env.OPENAI_API_KEY };
+    if (process.env.GEMINI_API_KEY)
+        return { provider: "gemini", key: process.env.GEMINI_API_KEY };
+    return null;
+}
+
+function httpsPost(hostname, apiPath, headers, body) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(body);
+        const req = https.request(
+            {
+                method: "POST",
+                hostname,
+                path: apiPath,
+                headers: { ...headers, "Content-Length": Buffer.byteLength(data) },
+            },
+            (res) => {
+                let raw = "";
+                res.on("data", (c) => { raw += c; });
+                res.on("end", () => resolve(raw));
+                res.on("error", reject);
+            },
+        );
+        req.on("error", reject);
+        req.setTimeout(30000, () => {
+            req.destroy(new Error("LLM API timeout"));
+        });
+        req.write(data);
+        req.end();
+    });
+}
+
+async function callLlmApi(prompt, provider, apiKey) {
+    try {
+        if (provider === "anthropic") {
+            const raw = await httpsPost(
+                "api.anthropic.com",
+                "/v1/messages",
+                {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "anthropic-version": "2023-06-01",
+                },
+                {
+                    model: "claude-3-5-sonnet-latest",
+                    max_tokens: 1024,
+                    messages: [{ role: "user", content: prompt }],
+                },
+            );
+            const json = JSON.parse(raw);
+            return json?.content?.[0]?.text ?? null;
+        }
+
+        if (provider === "openai") {
+            const raw = await httpsPost(
+                "api.openai.com",
+                "/v1/chat/completions",
+                {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                {
+                    model: "gpt-4o-mini",
+                    max_tokens: 1024,
+                    messages: [{ role: "user", content: prompt }],
+                    temperature: 0.1,
+                },
+            );
+            const json = JSON.parse(raw);
+            return json?.choices?.[0]?.message?.content ?? null;
+        }
+
+        if (provider === "gemini") {
+            const raw = await httpsPost(
+                "generativelanguage.googleapis.com",
+                `/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`,
+                { "Content-Type": "application/json" },
+                {
+                    contents: [{ parts: [{ text: prompt }] }],
+                    generationConfig: { maxOutputTokens: 1024, temperature: 0.1 },
+                },
+            );
+            const json = JSON.parse(raw);
+            return json?.candidates?.[0]?.content?.parts?.[0]?.text ?? null;
+        }
+    } catch (e) {
+        logger.err(`LLM API Call failed: ${e.message}`);
+        return null;
+    }
+    return null;
+}
+
+// ── Core Binary Resolver ─────────────────────────────────────────────────────
+function getCoreBinaryPath(targetDir) {
+    const isWindows = os.default.platform() === "win32";
+    const ext = isWindows ? ".exe" : "";
+    
+    // Dev build target checks
+    const devPath = path.default.resolve(targetDir, 'target', 'release', `tribunal-core${ext}`);
+    if (fs.default.existsSync(devPath)) return devPath;
+
+    const debugPath = path.default.resolve(targetDir, 'target', 'debug', `tribunal-core${ext}`);
+    if (fs.default.existsSync(debugPath)) return debugPath;
+
+    // Production npm package checks
+    const pkgName = `@tribunal-kit/core-${os.default.platform()}-${os.default.arch()}`;
+    try {
+        const pkgPath = require.resolve(`${pkgName}/package.json`);
+        const binPath = path.default.resolve(path.default.dirname(pkgPath), `bin/tribunal-core${ext}`);
+        if (fs.default.existsSync(binPath)) return binPath;
+    } catch {}
+
+    return null;
+}
+
+// ── Main Optimizer Command ───────────────────────────────────────────────────
+async function cmdOptimizeSkill(flags, processArgs, quiet = false) {
+    const targetDir = flags.path ? path.default.resolve(flags.path) : process.cwd();
+    const agentDest = path.default.join(targetDir, '.agent');
+
+    if (!fs.default.existsSync(agentDest)) {
+        logger.err('.agent/ not found. Run: npx tribunal-kit init');
+        process.exit(1);
+    }
+
+    helpers.banner(quiet);
+
+    // Detect LLM Credentials
+    const llm = detectLlmProvider();
+    if (!llm) {
+        logger.err("No LLM API Key detected in environment. Please set GEMINI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY.");
+        process.exit(1);
+    }
+
+    // Resolve Core Binary
+    const binPath = getCoreBinaryPath(targetDir);
+    if (!binPath) {
+        logger.err("tribunal-core binary not found. Run 'cargo build --release' or install the core package.");
+        process.exit(1);
+    }
+
+    // Parse loop parameters
+    const skillName = flags.target || 'project-idioms';
+    const skillPath = path.default.join(agentDest, 'skills', skillName, 'SKILL.md');
+    
+    if (!fs.default.existsSync(skillPath)) {
+        logger.err(`Target skill file not found: ${skillPath}`);
+        process.exit(1);
+    }
+
+    // Find the harness command
+    const positionalArgs = processArgs.slice(3).filter(arg => !arg.startsWith("--"));
+    if (positionalArgs.length === 0) {
+        logger.err("Harness command is required. Usage: tk optimize-skill --target <skill-name> \"<harness-command>\"");
+        process.exit(1);
+    }
+    const harnessCmd = positionalArgs[0];
+
+    const epochs = 4;
+    const editBudget = 4;
+
+    logger.log(`  ${logger.c('cyan', '⊘')} Starting SkillOpt loop for skill: ${logger.bold(skillName)}`);
+    logger.log(`  ${logger.c('cyan', '⊘')} Harness: "${logger.bold(harnessCmd)}"`);
+    logger.log(`  ${logger.c('cyan', '⊘')} Provider: ${logger.bold(llm.provider)}`);
+    console.log();
+
+    let bestScore = 0.0;
+    let currentSkillText = fs.default.readFileSync(skillPath, 'utf8');
+
+    for (let epoch = 1; epoch <= epochs; epoch++) {
+        logger.log(`  ${logger.c('cyan', '▶')} ${logger.bold(`Epoch ${epoch}/${epochs}`)}`);
+
+        // 1. Run Rollout Harness
+        logger.log(`    ${logger.c('gray', '●')} Running rollout batch execution...`);
+        let rolloutLogs = "";
+        let rolloutSuccess = true;
+        try {
+            rolloutLogs = execSync(harnessCmd, { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' });
+        } catch (e) {
+            rolloutLogs = e.stdout + "\n" + e.stderr;
+            rolloutSuccess = false;
+        }
+
+        const _initialScore = rolloutSuccess ? 1.0 : 0.0;
+        logger.log(`    ${logger.c('gray', '●')} Rollout score: ${rolloutSuccess ? logger.c('green', '1.0') : logger.c('red', '0.0')}`);
+
+        // 2. Call LLM for Patch Proposals
+        logger.log(`    ${logger.c('gray', '●')} Requesting optimizer reflections from LLM...`);
+        const reflectionPrompt = `
+You are a SkillOpt text-space optimizer coach.
+Analyze the following rollout run logs and current skill document, then propose bounded add/delete/replace/insert_after edits.
+The goal is to fix failure patterns and make the procedural memory rules clearer and more robust.
+
+Current Skill Content:
+"""
+${currentSkillText}
+"""
+
+Rollout Logs:
+${rolloutLogs.slice(-4000)}
+
+Output ONLY a JSON array containing proposed edits. No markdown formatting, no explanation.
+Each edit must follow this schema:
+[
+  {
+    "op": "append" | "insert_after" | "replace" | "delete",
+    "target": "<exact text match to replace/insert_after/delete, leave null for append>",
+    "content": "<exact markdown/rules to add, replace, or insert>",
+    "support_count": 1,
+    "source_type": "${rolloutSuccess ? "success" : "failure"}"
+  }
+]
+`;
+        
+        const llmResponse = await callLlmApi(reflectionPrompt, llm.provider, llm.key);
+        if (!llmResponse) {
+            logger.warn("    ⚠️ LLM returned empty response. Skipping epoch step.");
+            continue;
+        }
+
+        // Clean LLM JSON response from markdown wrappers if present
+        let cleanedJson = llmResponse.trim();
+        if (cleanedJson.startsWith("```json")) {
+            cleanedJson = cleanedJson.replace(/^```json/, "").replace(/```$/, "").trim();
+        } else if (cleanedJson.startsWith("```")) {
+            cleanedJson = cleanedJson.replace(/^```/, "").replace(/```$/, "").trim();
+        }
+
+        // 3. Invoke Rust binary for optimizing step
+        logger.log(`    ${logger.c('gray', '●')} Merging and applying bounded edits via Rust Core...`);
+        let optResultStr = "";
+        try {
+            const tempFile = path.default.join(os.default.tmpdir(), `edits-${Date.now()}.json`);
+            fs.default.writeFileSync(tempFile, cleanedJson, 'utf8');
+            
+            optResultStr = execSync(
+                `"${binPath}" optimize-step --skill-path "${skillPath}" --edits-json "${cleanedJson.replace(/"/g, '\\"')}" --budget ${editBudget}`,
+                { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' }
+            );
+            
+            try { fs.default.unlinkSync(tempFile); } catch {}
+        } catch (e) {
+            logger.err(`    ✖ Rust Core optimization failed: ${e.message}`);
+            continue;
+        }
+
+        let optReport;
+        try {
+            optReport = JSON.parse(optResultStr.trim());
+        } catch {
+            logger.err("    ✖ Failed to parse optimizer report from Rust Core.");
+            continue;
+        }
+
+        if (optReport.applied_count === 0) {
+            logger.log(`    ${logger.c('yellow', '●')} No edits applied (deduplicated or target not found).`);
+            continue;
+        }
+
+        logger.log(`    ${logger.c('green', '●')} Applied ${optReport.applied_count} edits to skill.`);
+
+        // 4. Run Validation Harness
+        logger.log(`    ${logger.c('gray', '●')} Evaluating candidate skill against validation split...`);
+        let valSuccess = true;
+        try {
+            execSync(harnessCmd, { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' });
+        } catch {
+            valSuccess = false;
+        }
+
+        const candidateScore = valSuccess ? 1.0 : 0.0;
+
+        // 5. Validation Gate
+        if (candidateScore > bestScore || (candidateScore === 1.0 && bestScore === 0.0)) {
+            logger.ok(`    ✔ Gate Accepted! Score improved/stabilized to ${logger.c('green', String(candidateScore))}.`);
+            bestScore = candidateScore;
+            currentSkillText = fs.default.readFileSync(skillPath, 'utf8');
+        } else {
+            logger.warn(`    ⚠️ Gate Rejected. Score (${candidateScore}) <= Best (${bestScore}). Reverting edits.`);
+            fs.default.writeFileSync(skillPath, currentSkillText, 'utf8');
+            
+            // Save to rejected-edit buffer history
+            const rejectedPath = path.default.join(agentDest, 'history', 'skill-optimization');
+            fs.default.mkdirSync(rejectedPath, { recursive: true });
+            const bufFile = path.default.join(rejectedPath, 'rejected-buffer.json');
+            let buffer = [];
+            if (fs.default.existsSync(bufFile)) {
+                try { buffer = JSON.parse(fs.default.readFileSync(bufFile, 'utf8')); } catch {}
+            }
+            buffer.push({ epoch, timestamp: new Date().toISOString(), edits: optReport.reports });
+            fs.default.writeFileSync(bufFile, JSON.stringify(buffer, null, 2), 'utf8');
+        }
+        console.log();
+    }
+
+    logger.ok(`🎉 SkillOpt training complete. Best validation score: ${logger.c('green', String(bestScore))}`);
+    console.log();
+}

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")}`);
+  }
+}