tribunal-kit 5.7.0 → 5.8.1

package/bin/wrapper.js

@@ -1,108 +1,142 @@
 #!/usr/bin/env node
 /**
  * Tribunal-Kit Core Wrapper
- * 
+ *
  * This script routes commands to the ultra-fast Rust binary if available and supported.
  * For legacy commands (or if the binary isn't available/compiled yet), it gracefully
  * falls back to the original JavaScript implementation.
  */
 
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const os = require('os');
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const os = require("os");
 
 // Commands that have been fully ported to Rust so far
-const RUST_COMMANDS = new Set(['init', 'validate', 'status', 'sync', 'hook', 'uninstall']);
+const RUST_COMMANDS = new Set([
+  "init",
+  "validate",
+  "status",
+  "sync",
+  "hook",
+  "uninstall",
+  "memory",
+]);
 
 // 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
 function getBinaryPath() {
-    const isWindows = os.platform() === 'win32';
-    const ext = isWindows ? '.exe' : '';
-    const platform = os.platform();
-    const arch = os.arch();
-    
-    // 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}`);
-        if (fs.existsSync(binPath)) {
-            return binPath;
-        }
-    } catch (e) {
-        // Package not found, ignore and fall back to local dev targets
-    }
+  if (process.env.TRIBUNAL_FORCE_JS === "1") {
+    return null;
+  }
+  const isWindows = os.platform() === "win32";
+  const ext = isWindows ? ".exe" : "";
+  const platform = os.platform();
+  const arch = os.arch();
 
-    // 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;
+  // 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}`,
+    );
+    if (fs.existsSync(binPath)) {
+      return binPath;
     }
+  } catch {
+    // Package not found, ignore and fall back to local dev targets
+  }
 
-    // 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;
-    }
+  // 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;
+  }
 
-    return null;
+  // 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;
+  }
+
+  return null;
 }
 
 function runRustBinary(binPath, args) {
-    const stdio = ['inherit', process.stdout.isTTY ? 'ignore' : 'inherit', 'inherit'];
-    const result = spawnSync(binPath, args, {
-        stdio: stdio,
-        env: process.env
-    });
-
-    if (result.error) {
-        console.error(`\x1b[91m✖ Failed to execute Rust engine:\x1b[0m ${result.error.message}`);
-        process.exit(1);
-    }
+  const stdio = [
+    "inherit",
+    "inherit",
+    "inherit",
+  ];
+  const result = spawnSync(binPath, args, {
+    stdio: stdio,
+    env: process.env,
+  });
 
-    process.exit(result.status || 0);
+  if (result.error) {
+    console.error(
+      `\x1b[91m✖ Failed to execute Rust engine:\x1b[0m ${result.error.message}`,
+    );
+    process.exit(1);
+  }
+
+  process.exit(result.status || 0);
 }
 
 function runLegacyFallback() {
-    // Use the modular dist/ CLI with lazy-loaded commands for faster cold-start.
-    // Each command module is require()'d only when invoked (~70% fewer files loaded).
-    const { main } = require('../dist/cli.js');
-    main();
+  // Use the modular dist/ CLI with lazy-loaded commands for faster cold-start.
+  // Each command module is require()'d only when invoked (~70% fewer files loaded).
+  const { main } = require("../dist/cli.js");
+  main();
 }
 
 function main() {
-    // Skip 'node' and 'wrapper.js'
-    const args = process.argv.slice(2);
-    
-    // Extract the command (the first non-flag argument)
-    const command = args.find(a => !a.startsWith('-'));
-
-    if (command && RUST_COMMANDS.has(command)) {
-        const binPath = getBinaryPath();
-        
-        if (binPath) {
-            // For the init command, Rust needs to know where the .agent template folder is.
-            if (command === 'init') {
-                const sourceDir = path.resolve(__dirname, '..', '.agent');
-                args.push('--source-dir', sourceDir);
-            }
-
-            // Route to Rust engine
-            // console.log('\x1b[90m⚡ Executing via Rust Core Engine\x1b[0m');
-            runRustBinary(binPath, args);
-            return;
-        } else {
-            // Warn if Rust command was requested but binary is missing
-            console.warn('\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m');
-        }
+  // Skip 'node' and 'wrapper.js'
+  const args = process.argv.slice(2);
+
+  // Extract the command (the first non-flag argument)
+  const command = args.find((a) => !a.startsWith("-"));
+
+  if (command && RUST_COMMANDS.has(command)) {
+    const binPath = getBinaryPath();
+
+    if (binPath) {
+      // For the init command, Rust needs to know where the .agent template folder is.
+      if (command === "init") {
+        const sourceDir = path.resolve(__dirname, "..", ".agent");
+        args.push("--source-dir", sourceDir);
+      }
+
+      // Route to Rust engine
+      // console.log('\x1b[90m⚡ Executing via Rust Core Engine\x1b[0m');
+      runRustBinary(binPath, args);
+      return;
+    } else {
+      // Warn if Rust command was requested but binary is missing
+      console.warn(
+        "\x1b[93m⚠ Rust binary not found in target/. Falling back to JS engine.\x1b[0m",
+      );
     }
+  }
 
-    // Fall back to JS logic for un-ported commands (e.g. `learn`, `case`, `marathon`)
-    runLegacyFallback();
+  // Fall back to JS logic for un-ported commands (e.g. `learn`, `case`, `marathon`)
+  runLegacyFallback();
 }
 
 main();

package/dist/cli.js

@@ -46,6 +46,10 @@ function parseArgs(argv) {
             args.flags.skipUpdateCheck = true;
             continue;
         }
+        if (arg === '--write') {
+            args.flags.write = true;
+            continue;
+        }
         if (arg === '--head') {
             args.flags.head = true;
             continue;
@@ -62,6 +66,18 @@ function parseArgs(argv) {
             }
             args.flags.path = nextVal;
         }
+        if (arg.startsWith('--target=')) {
+            args.flags.target = arg.split('=').slice(1).join('=');
+        }
+        if (arg === '--target') {
+            const idx = raw.indexOf('--target');
+            const nextVal = raw[idx + 1];
+            if (!nextVal || nextVal.startsWith('--')) {
+                console.error(`  \x1b[91m✖ --target requires an argument\x1b[0m`);
+                process.exit(1);
+            }
+            args.flags.target = nextVal;
+        }
         if (arg.startsWith('--branch=')) {
             args.flags.branch = arg.split('=').slice(1).join('=');
         }
@@ -84,20 +100,25 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(cmd('mutate', 'Run the Mutation Engine to test test-suite reliability'));
     (0, logger_1.log)(cmd('context', 'Retrieve a highly-optimized Context Snapshot for a file'));
     (0, logger_1.log)(cmd('sync', 'Synchronize IDE bridge files with current rules'));
+    (0, logger_1.log)(cmd('align', 'Clean AI outputs (strip slop, collapse lists, validate code traps)'));
     (0, logger_1.log)(cmd('marathon', 'Long-running agent harness (init, status, next, mark)'));
     (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('uninstall', 'Remove .agent/ folder from project'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Options'));
     (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
     (0, logger_1.log)(opt('--force', 'Overwrite existing .agent/ folder'));
     (0, logger_1.log)(opt('--path <dir>', 'Install in specific directory'));
+    (0, logger_1.log)(opt('--target <name>', 'Target terminal agent for compile (e.g. aider)'));
     (0, logger_1.log)(opt('--quiet', 'Suppress all output'));
     (0, logger_1.log)(opt('--verbose', 'Show detailed debug logging'));
     (0, logger_1.log)(opt('--dry-run', 'Preview actions without executing'));
     (0, logger_1.log)(opt('--minimal', 'Install core agents/skills only (~13 agents)'));
     (0, logger_1.log)(opt('--skip-update-check', 'Skip auto-update version check'));
     (0, logger_1.log)(opt('--head', '(learn) Diff against last commit instead of staged'));
+    (0, logger_1.log)(opt('--write', '(align) Write aligned output in-place to the target file'));
     console.log();
     (0, logger_1.log)((0, logger_1.bold)('  Aliases'));
     (0, logger_1.log)(`  ${(0, logger_1.c)('gray', '─'.repeat(40))}`);
@@ -128,6 +149,14 @@ function cmdHelp(quiet = false) {
     (0, logger_1.log)(ex('tk marathon next'));
     (0, logger_1.log)(ex('tk marathon mark 5 pass'));
     (0, logger_1.log)(ex('tk hook'));
+    (0, logger_1.log)(ex('tk compile'));
+    (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 memory recall --query "database" --budget 2000'));
+    (0, logger_1.log)(ex('tk memory gc'));
+    (0, logger_1.log)(ex('tk memory stats'));
+    (0, logger_1.log)(ex('tk memory export'));
     (0, logger_1.log)(ex('tk uninstall'));
     console.log();
 }
@@ -200,16 +229,31 @@ async function runWithUpdateCheck(command, flags) {
             await cmdSync();
             break;
         }
+        case 'align': {
+            const cmdAlign = loadCmd('./commands/align', 'cmdAlign');
+            await cmdAlign(flags, process.argv, quiet);
+            break;
+        }
         case 'marathon': {
             const cmdMarathon = loadCmd('./commands/marathon', 'cmdMarathon');
             await cmdMarathon(flags, process.argv, quiet);
             break;
         }
+        case 'compile': {
+            const cmdCompile = loadCmd('./commands/compile', 'cmdCompile');
+            await cmdCompile(flags, quiet);
+            break;
+        }
         case 'uninstall': {
             const cmdUninstall = loadCmd('./commands/uninstall', 'cmdUninstall');
             cmdUninstall(flags, quiet);
             break;
         }
+        case 'memory': {
+            const cmdMemory = loadCmd('./commands/memory', 'cmdMemory');
+            await cmdMemory(flags, process.argv, quiet);
+            break;
+        }
         case 'help':
         case '--help':
         case '-h':

package/dist/commands/align.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { log, err, ok, c, bold, warn } = require("../utils/logger");
+
+function alignText(text) {
+    if (!text) return "";
+
+    let cleaned = text.trim();
+    let matches = true;
+
+    // 1. Strip Conversational Introduction Slop step-by-step
+    while (matches) {
+        matches = false;
+        const prefixes = [
+            /^(?:sure|certainly|okay|absolutely|great|of course|as requested|as you asked|happy to help|here is|here's|let's|i can help)(?:[^\n]*?)(?:[.!?;:]|\n)\s*/i,
+            /^(?:I'd be happy to help with that\.|I can certainly help you with that\.|Let me help you with that\.|Here's what you requested:)\s*/i,
+            /^(?:here is the implementation|here is the code|here are the details|here is your code|here's the implementation|here's the code|here's the solution|here are the details:)(?:[^\n]*?)(?:[.!?;:]|\n)\s*/i
+        ];
+        
+        for (const regex of prefixes) {
+            const temp = cleaned.replace(regex, "");
+            if (temp !== cleaned) {
+                cleaned = temp.trim();
+                matches = true;
+                break;
+            }
+        }
+    }
+
+    // 2. Strip Conversational Conclusion Slop
+    const outroRegexes = [
+        /[\r\n\s]*(?:i hope this helps|let me know if you need|let me know if this works|please review the code|let me know if you have any questions|feel free to ask|hope that helps|happy coding)(?:.*)$/gi,
+    ];
+
+    for (const regex of outroRegexes) {
+        cleaned = cleaned.replace(regex, "");
+    }
+
+    // 3. Bullet-point collapse logic (1-2 item list -> prose)
+    const lines = cleaned.split(/\r?\n/);
+    const resultLines = [];
+    let i = 0;
+
+    while (i < lines.length) {
+        const line = lines[i];
+        const bulletMatch = line.match(/^(\s*)([-*]|\d+\.)\s+(.*)$/);
+
+        if (bulletMatch) {
+            const listItems = [];
+            const indent = bulletMatch[1];
+            let j = i;
+
+            while (j < lines.length) {
+                const nextLine = lines[j];
+                const nextMatch = nextLine.match(/^(\s*)([-*]|\d+\.)\s+(.*)$/);
+                if (nextMatch && nextMatch[1].length === indent.length) {
+                    listItems.push({ index: j, content: nextMatch[3] });
+                    j++;
+                } else if (nextLine.trim() === "") {
+                    if (j + 1 < lines.length) {
+                        const lookahead = lines[j + 1];
+                        const lookaheadMatch = lookahead.match(/^(\s*)([-*]|\d+\.)\s+(.*)$/);
+                        if (lookaheadMatch && lookaheadMatch[1].length === indent.length) {
+                            j++;
+                            continue;
+                        }
+                    }
+                    break;
+                } else {
+                    break;
+                }
+            }
+
+            if (listItems.length > 0 && listItems.length <= 2) {
+                const collapsedProse = listItems.map(item => {
+                    let content = item.content.trim();
+                    if (content && !/[.!?]$/.test(content)) {
+                        content += ".";
+                    }
+                    if (content) {
+                        content = content.charAt(0).toUpperCase() + content.slice(1);
+                    }
+                    return content;
+                }).join(" ");
+                resultLines.push(indent + collapsedProse);
+                i = j;
+            } else {
+                for (let k = i; k < j; k++) {
+                    resultLines.push(lines[k]);
+                }
+                i = j;
+            }
+        } else {
+            resultLines.push(line);
+            i++;
+        }
+    }
+
+    cleaned = resultLines.join("\n");
+    return cleaned.trim();
+}
+
+function validateCodeContent(text) {
+    const warnings = [];
+
+    // Next.js 15 unawaited dynamic properties check
+    const unawaitedNext15Regex = /(?<!await\s+)(cookies|headers|params)\s*\(\s*\)\s*\.\s*(get|has|set|delete|toString)/g;
+    if (unawaitedNext15Regex.test(text)) {
+        warnings.push("Next.js 15: Found unawaited call to cookies(), headers(), or params(). In Next.js 15+, these are async and must be awaited.");
+    }
+
+    // React 19 useFormState check
+    if (text.includes("useFormState")) {
+        warnings.push("React 19: Found useFormState. In React 19, this is renamed to useActionState.");
+    }
+
+    // Drizzle .filter() check
+    const drizzleFilterRegex = /\.from\s*\([^)]*\)\s*\.\s*filter\s*\(/;
+    if (drizzleFilterRegex.test(text)) {
+        warnings.push("Drizzle ORM: Found .from().filter(). Drizzle does not use .filter(), use .where() instead.");
+    }
+
+    // OpenAI gpt-5 or claude-4-opus checks
+    if (text.includes("gpt-5") || text.includes("claude-4-opus")) {
+        warnings.push("LLM Models: Found references to non-existent models (gpt-5, claude-4-opus).");
+    }
+
+    return warnings;
+}
+
+async function cmdAlign(flags, argv, quiet) {
+    let inputSource = null;
+
+    // Find if a file path is specified
+    const positionalArgs = argv.slice(3).filter(arg => !arg.startsWith("--"));
+    if (positionalArgs.length > 0) {
+        inputSource = positionalArgs[0];
+    } else if (flags.path) {
+        inputSource = flags.path;
+    }
+
+    let textContent = "";
+
+    if (inputSource) {
+        // Read from file
+        const resolvedPath = path.resolve(inputSource);
+        if (!fs.existsSync(resolvedPath)) {
+            err(`File not found: ${inputSource}`);
+            process.exit(1);
+        }
+        textContent = fs.readFileSync(resolvedPath, "utf8");
+    } else {
+        // Read from stdin
+        textContent = await new Promise((resolve) => {
+            let data = "";
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: false
+            });
+            rl.on("line", (line) => {
+                data += line + "\n";
+            });
+            rl.on("close", () => {
+                resolve(data);
+            });
+        });
+    }
+
+    const aligned = alignText(textContent);
+    const warnings = validateCodeContent(aligned);
+
+    // Print warnings to stderr so they don't corrupt stdout piping
+    if (warnings.length > 0 && !quiet) {
+        process.stderr.write("\n" + bold(c("yellow", "⚠️  OCAE Alignment Validator Warnings:")) + "\n");
+        for (const warnMsg of warnings) {
+            process.stderr.write(`  ${c("yellow", "●")} ${warnMsg}\n`);
+        }
+        process.stderr.write("\n");
+    }
+
+    if (flags.write && inputSource) {
+        // Write in-place to the file
+        fs.writeFileSync(path.resolve(inputSource), aligned, "utf8");
+        if (!quiet) {
+            ok(`Aligned output written in-place to: ${c("cyan", inputSource)}`);
+        }
+    } else {
+        // Print to stdout
+        process.stdout.write(aligned + "\n");
+    }
+}
+
+module.exports = {
+    cmdAlign,
+    alignText,
+    validateCodeContent
+};

package/dist/commands/case.js

@@ -41,6 +41,29 @@ async function cmdCase(flags, processArgs, quiet = false) {
         pyArgs = pyArgs.replace(/^search/, 'search-cases');
     try {
         await (0, helpers_1.runShellAsync)(`node "${caseLawScript}" ${pyArgs}`, { stdio: 'inherit', cwd: targetDir });
+        // Memory Bridge: When a case is added, auto-store a SEMANTIC memory
+        if (args.startsWith('add')) {
+            try {
+                const { _memoryStore } = require('./memory');
+                // Extract a summary from the add-case args (best effort)
+                const contentMatch = args.match(/--violation\s+"([^"]+)"/i) || args.match(/--violation\s+(\S+)/i);
+                const domainMatch = args.match(/--domain\s+"([^"]+)"/i) || args.match(/--domain\s+(\S+)/i);
+                const violation = contentMatch ? contentMatch[1] : 'Unknown violation';
+                const domain = domainMatch ? domainMatch[1] : 'general';
+                _memoryStore(
+                    agentDest,
+                    'semantic',
+                    `CASE LAW REJECTION: ${violation} (domain: ${domain})`,
+                    ['case-law', domain, 'rejection'],
+                    null
+                );
+                if (!quiet) {
+                    (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '\u25b8')} Memory bridge: case law rejection stored to memory index`);
+                }
+            } catch {
+                // Non-critical — case law was still saved, memory bridge is a bonus
+            }
+        }
     }
     catch {
         process.exit(1); // Script already prints errors

package/dist/commands/compile.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdCompile = cmdCompile;
+
+const fs = require("fs");
+const path = require("path");
+const { log, err, ok, c, bold, dbg } = require("../utils/logger");
+
+async function cmdCompile(flags, quiet) {
+    const cwd = process.cwd();
+    const agentDir = path.join(cwd, ".agent");
+    
+    if (!fs.existsSync(agentDir)) {
+        err("Tribunal Kit is not installed in this directory (.agent folder missing). Run 'tk init' first.");
+        process.exit(1);
+    }
+
+    log(bold("Compiling Tribunal Kit rules..."));
+    
+    let compiledContext = "# Tribunal Kit Context\n\n";
+    compiledContext += "The following are rules, agents, and skills from the Tribunal Kit.\n\n";
+
+    // 1. Read GEMINI.md
+    const geminiPath = path.join(agentDir, "rules", "GEMINI.md");
+    if (fs.existsSync(geminiPath)) {
+        compiledContext += "## Global Rules (GEMINI.md)\n\n";
+        compiledContext += fs.readFileSync(geminiPath, "utf-8") + "\n\n";
+    }
+
+    // 2. Read Agents
+    const agentsDir = path.join(agentDir, "agents");
+    if (fs.existsSync(agentsDir)) {
+        compiledContext += "## Agents\n\n";
+        const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        for (const file of agents) {
+            const content = fs.readFileSync(path.join(agentsDir, file), "utf-8");
+            compiledContext += `### Agent: ${file}\n\n`;
+            compiledContext += content + "\n\n";
+        }
+    }
+
+    // 3. Read Skills
+    const skillsDir = path.join(agentDir, "skills");
+    if (fs.existsSync(skillsDir)) {
+        compiledContext += "## Skills\n\n";
+        const skills = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const dirent of skills) {
+            if (dirent.isDirectory()) {
+                const skillPath = path.join(skillsDir, dirent.name, "SKILL.md");
+                if (fs.existsSync(skillPath)) {
+                    const content = fs.readFileSync(skillPath, "utf-8");
+                    compiledContext += `### Skill: ${dirent.name}\n\n`;
+                    compiledContext += content + "\n\n";
+                }
+            }
+        }
+    }
+
+    // 4. Read Workflows
+    const workflowsDir = path.join(agentDir, "workflows");
+    if (fs.existsSync(workflowsDir)) {
+        compiledContext += "## Workflows\n\n";
+        const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md'));
+        for (const file of workflows) {
+            const content = fs.readFileSync(path.join(workflowsDir, file), "utf-8");
+            compiledContext += `### Workflow: ${file}\n\n`;
+            compiledContext += content + "\n\n";
+        }
+    }
+
+    let targetFile = ".tribunal-compiled.md";
+    if (flags.target) {
+        if (flags.target === "aider") targetFile = ".aider.conf.yml";
+        if (flags.target === "claude") targetFile = ".claude.json";
+    }
+    
+    const outputPath = path.join(cwd, targetFile);
+    fs.writeFileSync(outputPath, compiledContext, "utf-8");
+    
+    ok(`Compiled rules written to ${c('cyan', targetFile)}`);
+    if (!quiet) {
+        log(`  ${c('gray', 'Load this file into your terminal agent (e.g. Claude Code, Aider, OpenCode)')}`);
+    }
+}