tribunal-kit 5.8.4 → 6.0.0

package/dist/commands/memory.js

@@ -31,6 +31,42 @@ const PROJECTION_FILE = 'MEMORY.md';
 const MAX_ENTRIES = 500;
 const EPISODIC_TTL_DAYS = 30;
 
+function acquireLock(agentDest) {
+    const lockPath = getIndexPath(agentDest) + '.lock';
+    const maxRetries = 10;
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            const fd = fs_1.default.openSync(lockPath, 'wx');
+            fs_1.default.closeSync(fd);
+            return lockPath;
+        } catch (err) {
+            if (err.code !== 'EEXIST') {
+                throw err;
+            }
+            const start = Date.now();
+            while (Date.now() - start < 50) {}
+        }
+    }
+    try {
+        const stats = fs_1.default.statSync(lockPath);
+        if (Date.now() - stats.mtimeMs > 10000) {
+            fs_1.default.unlinkSync(lockPath);
+            const fd = fs_1.default.openSync(lockPath, 'wx');
+            fs_1.default.closeSync(fd);
+            return lockPath;
+        }
+    } catch {}
+    throw new Error('Could not acquire lock for memory index');
+}
+
+function releaseLock(lockPath) {
+    try {
+        if (lockPath && fs_1.default.existsSync(lockPath)) {
+            fs_1.default.unlinkSync(lockPath);
+        }
+    } catch {}
+}
+
 function getMemoryDir(agentDest) {
     return path_1.default.join(agentDest, MEMORY_DIR);
 }
@@ -121,95 +157,110 @@ function memoryStore(agentDest, type, content, tags, sessionId) {
         throw new Error('Memory content cannot be empty');
     }
 
-    const index = loadIndex(agentDest);
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
 
-    // Enforce cap — auto-GC if needed
-    if (index.entries.length >= MAX_ENTRIES) {
-        index.entries = index.entries.filter(e => e.memory_type !== 'working');
-        if (index.entries.length >= MAX_ENTRIES) {
-            index.entries = index.entries.filter(e => {
-                if (e.memory_type === 'episodic') {
-                    return daysSince(e.created_at) < EPISODIC_TTL_DAYS;
-                }
-                return true;
-            });
-        }
+        // Enforce cap — auto-GC if needed
         if (index.entries.length >= MAX_ENTRIES) {
-            throw new Error(`Memory at capacity (${MAX_ENTRIES}). Run: tk memory gc`);
+            index.entries = index.entries.filter(e => e.memory_type !== 'working');
+            if (index.entries.length >= MAX_ENTRIES) {
+                index.entries = index.entries.filter(e => {
+                    if (e.memory_type === 'episodic') {
+                        return daysSince(e.created_at) < EPISODIC_TTL_DAYS; // Typo correction or TTL match
+                    }
+                    return true;
+                });
+            }
+            if (index.entries.length >= MAX_ENTRIES) {
+                throw new Error(`Memory at capacity (${MAX_ENTRIES}). Run: tk memory gc`);
+            }
         }
-    }
 
-    const now = nowEpochStr();
-    const id = index.next_id || (index.entries.length > 0 ? Math.max(...index.entries.map(e => e.id)) + 1 : 1);
-    const entry = {
-        id,
-        memory_type: type,
-        content: content.trim(),
-        tags: tags.filter(t => t.length > 0),
-        created_at: now,
-        last_accessed: now,
-        access_count: 0,
-        token_estimate: estimateTokens(content),
-        source: type === 'working' ? 'session' : 'manual',
-        session_id: sessionId || null,
-    };
-
-    index.entries.push(entry);
-    index.next_id = id + 1;
-    saveIndex(agentDest, index);
-    generateProjection(agentDest, index);
-
-    return { id, token_estimate: entry.token_estimate };
+        const now = nowEpochStr();
+        const id = index.next_id || (index.entries.length > 0 ? Math.max(...index.entries.map(e => e.id)) + 1 : 1);
+        const entry = {
+            id,
+            memory_type: type,
+            content: content.trim(),
+            tags: tags.filter(t => t.length > 0),
+            created_at: now,
+            last_accessed: now,
+            access_count: 0,
+            token_estimate: estimateTokens(content),
+            source: type === 'working' ? 'session' : 'manual',
+            session_id: sessionId || null,
+        };
+
+        index.entries.push(entry);
+        index.next_id = id + 1;
+        saveIndex(agentDest, index);
+        generateProjection(agentDest, index);
+
+        return { id, token_estimate: entry.token_estimate };
+    } finally {
+        releaseLock(lockPath);
+    }
 }
 
 // ── Recall ──────────────────────────────────────────────────────────────────
 
 function memoryRecall(agentDest, query, budget = 2000) {
-    const index = loadIndex(agentDest);
-
-    const scored = index.entries
-        .map(entry => ({ entry, score: computeScore(entry, query) }))
-        .filter(s => s.score > 0)
-        .sort((a, b) => b.score - a.score);
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
+
+        const scored = index.entries
+            .map(entry => ({ entry, score: computeScore(entry, query) }))
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score);
+
+        let totalTokens = 0;
+        const results = [];
+
+        for (const { entry, score } of scored) {
+            if (totalTokens + entry.token_estimate > budget) break;
+            totalTokens += entry.token_estimate;
+            entry.last_accessed = nowEpochStr();
+            entry.access_count = (entry.access_count || 0) + 1;
+            results.push({ ...entry, score });
+        }
 
-    let totalTokens = 0;
-    const results = [];
+        // Save updated access counts
+        saveIndex(agentDest, index);
 
-    for (const { entry, score } of scored) {
-        if (totalTokens + entry.token_estimate > budget) break;
-        totalTokens += entry.token_estimate;
-        entry.last_accessed = nowEpochStr();
-        entry.access_count = (entry.access_count || 0) + 1;
-        results.push({ ...entry, score });
+        return { results, tokens_used: totalTokens, budget };
+    } finally {
+        releaseLock(lockPath);
     }
-
-    // Save updated access counts
-    saveIndex(agentDest, index);
-
-    return { results, tokens_used: totalTokens, budget };
 }
 
 // ── Garbage Collect ─────────────────────────────────────────────────────────
 
 function memoryGc(agentDest) {
-    const index = loadIndex(agentDest);
-    const before = index.entries.length;
+    const lockPath = acquireLock(agentDest);
+    try {
+        const index = loadIndex(agentDest);
+        const before = index.entries.length;
 
-    let workingRemoved = 0;
-    let episodicRemoved = 0;
+        let workingRemoved = 0;
+        let episodicRemoved = 0;
 
-    index.entries = index.entries.filter(e => {
-        if (e.memory_type === 'working') { workingRemoved++; return false; }
-        if (e.memory_type === 'episodic' && daysSince(e.created_at) >= EPISODIC_TTL_DAYS) {
-            episodicRemoved++; return false;
-        }
-        return true;
-    });
+        index.entries = index.entries.filter(e => {
+            if (e.memory_type === 'working') { workingRemoved++; return false; }
+            if (e.memory_type === 'episodic' && daysSince(e.created_at) >= EPISODIC_TTL_DAYS) {
+                episodicRemoved++; return false;
+            }
+            return true;
+        });
 
-    saveIndex(agentDest, index);
-    generateProjection(agentDest, index);
+        saveIndex(agentDest, index);
+        generateProjection(agentDest, index);
 
-    return { working_removed: workingRemoved, episodic_removed: episodicRemoved, before, after: index.entries.length };
+        return { working_removed: workingRemoved, episodic_removed: episodicRemoved, before, after: index.entries.length };
+    } finally {
+        releaseLock(lockPath);
+    }
 }
 
 // ── Stats ───────────────────────────────────────────────────────────────────

package/dist/commands/minimal.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdMinimal = cmdMinimal;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+const helpers_1 = require("../utils/helpers");
+
+function cmdMinimal(flags, quiet = false) {
+    const targetDir = flags.path ? path_1.default.resolve(flags.path) : process.cwd();
+    const agentDest = path_1.default.join(targetDir, '.agent');
+    (0, helpers_1.banner)(quiet);
+
+    if (!fs_1.default.existsSync(agentDest)) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖')} ${(0, logger_1.bold)('Not installed')} in this project`);
+        return;
+    }
+
+    const enginePath = path_1.default.join(agentDest, 'scripts', 'minimal_change_engine.js');
+    if (!fs_1.default.existsSync(enginePath)) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖')} minimal_change_engine.js not found`);
+        return;
+    }
+
+    try {
+        const engine = require(enginePath);
+        const task = flags.task || flags._?.slice(1).join(' ') || 'Default task evaluation';
+        const mode = flags.mode || 'balanced';
+        const result = engine.evaluateMinimalChange(task, {
+            files_added: flags.filesAdded ? parseInt(flags.filesAdded, 10) : 0,
+            files_modified: flags.filesModified ? parseInt(flags.filesModified, 10) : 1,
+            estimated_lines_added: flags.linesAdded ? parseInt(flags.linesAdded, 10) : 20,
+        }, { mode, cwd: targetDir });
+
+        if (flags.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+
+        (0, logger_1.log)(`  ${(0, logger_1.bold)('Minimal Change Governance Audit')}`);
+        (0, logger_1.log)(`  Minimality Score:          ${result.passed ? (0, logger_1.c)('green', result.minimality_score + '/100') : (0, logger_1.c)('red', result.minimality_score + '/100')}`);
+        (0, logger_1.log)(`  Decision Classification:   ${(0, logger_1.c)('cyan', result.minimality_classification)}`);
+        (0, logger_1.log)(`  Strictness Mode:           ${(0, logger_1.c)('yellow', mode)}`);
+        console.log();
+
+        if (result.change_budget) {
+            (0, logger_1.log)(`  ${(0, logger_1.bold)('Change Budget:')}`);
+            (0, logger_1.log)(`    files_added:           ${result.change_budget.files_added}`);
+            (0, logger_1.log)(`    files_modified:        ${result.change_budget.files_modified}`);
+            (0, logger_1.log)(`    dependencies_added:    ${result.change_budget.dependencies_added}`);
+            (0, logger_1.log)(`    new_abstractions:      ${result.change_budget.new_abstractions}`);
+            console.log();
+        }
+
+        if (result.complexity_flags.length > 0) {
+            (0, logger_1.log)(`  ${(0, logger_1.c)('yellow', 'Complexity Flags Detected:')}`);
+            result.complexity_flags.forEach(f => {
+                (0, logger_1.log)(`    • [${f.severity.toUpperCase()}] ${f.type}: ${f.evidence}`);
+            });
+            console.log();
+        } else {
+            (0, logger_1.log)(`  ${(0, logger_1.c)('green', '✔ Zero Complexity Flags Detected')}`);
+            console.log();
+        }
+    } catch (err) {
+        (0, logger_1.log)(`  ${(0, logger_1.c)('red', '✖ Error executing Minimal Change Engine:')} ${err.message}`);
+    }
+}

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

@@ -9,7 +9,7 @@ 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 { execSync, spawnSync } = require("child_process");
 const logger = require("../utils/logger");
 const helpers = require("../utils/helpers");
 
@@ -253,10 +253,20 @@ Each edit must follow this schema:
             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' }
-            );
+            const result = spawnSync(binPath, [
+                "optimize-step",
+                "--skill-path",
+                skillPath,
+                "--edits-json",
+                cleanedJson,
+                "--budget",
+                String(editBudget)
+            ], { encoding: 'utf8', cwd: targetDir, stdio: 'pipe' });
+            
+            if (result.error) {
+                throw result.error;
+            }
+            optResultStr = result.stdout || "";
             
             try { fs.default.unlinkSync(tempFile); } catch {}
         } catch (e) {

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