agent-enderun 1.1.10 → 1.10.0

package/src/cli/commands/orchestrate.ts

@@ -3,9 +3,11 @@ import path from "path";
 import chalk from "chalk";
 import { getFrameworkDir, updateDocumentStore, readStatus } from "../utils/memory.js";
 import { UI } from "../utils/ui.js";
+import { writeTextFile, appendFile } from "../utils/fs.js";
 import { z } from "zod";
 import { logger } from "../../shared/logger.js";
 import { TaskRequestSchema } from "../../contracts/tasks.js";
+import { sleep } from "../utils/time.js";
 
 export const HermesMessageSchema = z.object({
     timestamp: z.string(),
@@ -22,174 +24,191 @@ export const HermesMessageSchema = z.object({
 
 export type HermesMessage = z.infer<typeof HermesMessageSchema>;
 
+// Global status cache for in-memory optimization
+let agentStatusCache: Record<string, { state: string; task: string; lastUpdated?: string }> = {};
+let isLooping = false;
+
 export async function orchestrateCommand() {
+    UI.intent("Hermes Message Broker", "Starting the live agent orchestration loop...");
+
     const frameworkDir = getFrameworkDir();
     const messagesDir = path.join(frameworkDir, "messages");
 
-    // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
-    const agentStatuses = readStatus();
-    let updatedStatus = false;
-    for (const [agentName, info] of Object.entries(agentStatuses)) {
-        const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
-        if (state === "EXECUTING" && lastUpdated) {
-            const lastUpdatedTime = Date.parse(lastUpdated);
-            if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
-                UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
-                agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
-                updatedStatus = true;
-            }
+    // Graceful Shutdown Handling
+    const shutdown = async () => {
+        if (!isLooping) return;
+        isLooping = false;
+        UI.warning("\n🛑 Shutdown signal received. Cleaning up Hermes loop...");
+        // Additional cleanup like releasing global locks could go here
+        process.exit(0);
+    };
+
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+
+    isLooping = true;
+
+    while (isLooping) {
+        // Initial load from disk to sync the cache
+        if (Object.keys(agentStatusCache).length === 0) {
+            const diskStatus = readStatus();
+            agentStatusCache = diskStatus || {};
         }
-    }
-    if (updatedStatus) {
-        updateDocumentStore("status", agentStatuses);
-    }
 
-    if (!fs.existsSync(messagesDir)) {
-        UI.success("No messages to process yet.");
-        return;
-    }
+        // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
+        const agentStatuses = readStatus();
+        let updatedStatus = false;
+        for (const [agentName, info] of Object.entries(agentStatuses)) {
+            const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
+            if (state === "EXECUTING" && lastUpdated) {
+                const lastUpdatedTime = Date.parse(lastUpdated);
+                if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                    UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
+                    agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
+                    updatedStatus = true;
+                }
+            }
+        }
+        if (updatedStatus) {
+            updateDocumentStore("status", agentStatuses);
+            agentStatusCache = { ...agentStatuses }; // Sync cache
+        }
 
-    const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
-    const pendingMessages: HermesMessage[] = [];
-    const fileMessagesMap: Record<string, HermesMessage[]> = {};
+        if (fs.existsSync(messagesDir)) {
+            const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
+            const pendingMessages: HermesMessage[] = [];
+            const fileMessagesMap: Record<string, HermesMessage[]> = {};
 
-    for (const file of messageFiles) {
-        const filePath = path.join(messagesDir, file);
-        try {
-            const content = fs.readFileSync(filePath, "utf8").trim();
-            if (!content) continue;
-            const lines = content.split("\n");
-            const allMsgs: HermesMessage[] = [];
-            lines.forEach((line) => {
-                if (!line.trim()) return;
+            for (const file of messageFiles) {
+                const filePath = path.join(messagesDir, file);
                 try {
-                    const parsed = JSON.parse(line);
-                    const msg = HermesMessageSchema.parse(parsed);
-
-                    // Contract Validation
-                    if (msg.category === "ACTION" || msg.category === "DELEGATION") {
+                    const content = fs.readFileSync(filePath, "utf8").trim();
+                    if (!content) continue;
+                    const lines = content.split("\n");
+                    const allMsgs: HermesMessage[] = [];
+                    lines.forEach((line) => {
+                        if (!line.trim()) return;
                         try {
-                            const payload = JSON.parse(msg.content);
-                            TaskRequestSchema.parse(payload);
+                            const parsed = JSON.parse(line);
+                            const msg = HermesMessageSchema.parse(parsed);
+
+                            // Contract Validation
+                            if (msg.category === "ACTION" || msg.category === "DELEGATION") {
+                                try {
+                                    const payload = JSON.parse(msg.content);
+                                    TaskRequestSchema.parse(payload);
+                                } catch (e) {
+                                    UI.error(`Invalid task contract payload: ${(e as Error).message}`);
+                                    return; // Skip invalid message
+                                }
+                            }
+
+                            if (msg.status === "PENDING") {
+                                pendingMessages.push(msg);
+                            }
+                            allMsgs.push(msg);
                         } catch (e) {
-                            UI.error(`Invalid task contract payload: ${(e as Error).message}`);
-                            return; // Skip invalid message
+                            UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
                         }
-                    }
-
-                    if (msg.status === "PENDING") {
-                        pendingMessages.push(msg);
-                    }
-                    allMsgs.push(msg);
-                } catch (e) {
-                    UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
+                    });
+                    fileMessagesMap[file] = allMsgs;
+                } catch (err) {
+                    UI.error(`Error occurred while reading ${file}.`);
+                    logger.debug(`Failed to read message file ${file}`, err);
                 }
-            });
-            fileMessagesMap[file] = allMsgs;
-        } catch (err) {
-            UI.error(`Error occurred while reading ${file}.`);
-            logger.debug(`Failed to read message file ${file}`, err);
-        }
-    }
-
-    if (pendingMessages.length === 0) {
-        UI.success("All messages processed, no pending tasks.");
-        return;
-    }
+            }
 
-    // Sort by priority: HIGH -> NORMAL -> LOW
-    const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
-    pendingMessages.sort((a, b) => {
-        const pA = priorityOrder[a.priority || "NORMAL"] || 2;
-        const pB = priorityOrder[b.priority || "NORMAL"] || 2;
-        if (pA !== pB) return pA - pB;
-        return Date.parse(a.timestamp) - Date.parse(b.timestamp);
-    });
+            if (pendingMessages.length > 0) {
+                // Sort by priority: HIGH -> NORMAL -> LOW
+                const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
+                pendingMessages.sort((a, b) => {
+                    const pA = priorityOrder[a.priority || "NORMAL"] || 2;
+                    const pB = priorityOrder[b.priority || "NORMAL"] || 2;
+                    if (pA !== pB) return pA - pB;
+                    return Date.parse(a.timestamp) - Date.parse(b.timestamp);
+                });
 
-    UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
+                UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
 
-    const statusChanges: Record<string, { state: string; task: string }> = {};
+                const statusChanges: Record<string, { state: string; task: string }> = {};
 
-    for (const msg of pendingMessages) {
-        const { from, to, content, traceId, category, parentId } = msg;
+                for (const msg of pendingMessages) {
+                    const { from, to, content, traceId, category, parentId } = msg;
 
-        // Visual distinction for Sub-tasks
-        const isSubtask = category === "SUBTASK" || !!parentId;
-        const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
+                    const isSubtask = category === "SUBTASK" || !!parentId;
+                    const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
 
-        UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
+                    UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
 
-        let targetState = "EXECUTING";
-        if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
+                    let targetState = "EXECUTING";
+                    if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
 
-        let taskDescription = content;
-        if (category === "DELEGATION" || category === "ACTION") {
-            try {
-                const payload = JSON.parse(content);
-                taskDescription = payload.task || content;
-            } catch {
-                // Ignore
-            }
-        }
-
-        statusChanges[to] = { state: targetState, task: taskDescription };
+                    let taskDescription = content;
+                    if (category === "DELEGATION" || category === "ACTION") {
+                        try {
+                            const payload = JSON.parse(content);
+                            taskDescription = payload.task || content;
+                        } catch {
+                            // Ignore
+                        }
+                    }
 
-        if (targetState === "BRIEFED") {
-            UI.success(`${to} informed and took over the task.`);
-            statusChanges[to] = { state: "EXECUTING", task: taskDescription };
-        }
+                    statusChanges[to] = { state: targetState, task: taskDescription };
 
-        if (isSubtask) {
-            UI.success(`Sub-task connection established (Parent: ${parentId || "Unknown"}).`);
-        }
-
-        UI.success(`Collaboration initiated: ${from} -> ${to}`);
-        console.warn(chalk.gray(`  👉 Instructions: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
+                    if (targetState === "BRIEFED") {
+                        UI.success(`${to} informed and took over the task.`);
+                        statusChanges[to] = { state: "EXECUTING", task: taskDescription };
+                    }
 
-        // Mark message as processed
-        msg.status = "PROCESSED";
-    }
+                    if (isSubtask) {
+                        UI.success(`Sub-task connection established (Parent: ${parentId || "Unknown"}).`);
+                    }
 
-    // Apply batch status updates
-    applyBatchStatusUpdates(statusChanges);
+                    UI.success(`Collaboration initiated: ${from} -> ${to}`);
+                    console.warn(chalk.gray(`  👉 Instructions: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
 
-    // Write back updated message statuses to files and archive processed messages
-    const archiveDir = path.join(messagesDir, "archive");
-    
-    for (const file of Object.keys(fileMessagesMap)) {
-        const filePath = path.join(messagesDir, file);
-        const msgs = fileMessagesMap[file];
-        
-        const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
-        const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
-        
-        try {
-            // Write remaining active messages
-            if (activeMsgs.length > 0) {
-                const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                fs.writeFileSync(filePath, updatedContent, "utf8");
-            } else {
-                // Empty the file if no active messages
-                if (fs.existsSync(filePath)) {
-                    fs.writeFileSync(filePath, "", "utf8");
+                    msg.status = "PROCESSED";
                 }
-            }
 
-            // Archive processed messages
-            if (processedMsgs.length > 0) {
-                if (!fs.existsSync(archiveDir)) {
-                    fs.mkdirSync(archiveDir, { recursive: true });
+                applyBatchStatusUpdates(statusChanges);
+
+                const archiveDir = path.join(messagesDir, "archive");
+                
+                for (const file of Object.keys(fileMessagesMap)) {
+                    const filePath = path.join(messagesDir, file);
+                    const msgs = fileMessagesMap[file];
+                    
+                    const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
+                    const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
+                    
+                    try {
+                        if (activeMsgs.length > 0) {
+                            const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                            writeTextFile(filePath, updatedContent);
+                        } else if (fs.existsSync(filePath)) {
+                            writeTextFile(filePath, "");
+                        }
+
+                        if (processedMsgs.length > 0) {
+                            if (!fs.existsSync(archiveDir)) {
+                                fs.mkdirSync(archiveDir, { recursive: true });
+                            }
+                            const agentName = file.replace(".json", "");
+                            const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
+                            const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                            appendFile(archivePath, archiveContent);
+                            UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
+                        }
+                    } catch (err) {
+                        UI.error(`Error occurred while updating and archiving the message file ${file}.`);
+                        logger.debug(`Failed to update and archive message file ${file}`, err);
+                    }
                 }
-                const agentName = file.replace(".json", "");
-                const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
-                const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                fs.appendFileSync(archivePath, archiveContent, "utf8");
-                UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
             }
-        } catch (err) {
-            UI.error(`Error occurred while updating and archiving the message file ${file}.`);
-            logger.debug(`Failed to update and archive message file ${file}`, err);
         }
+
+        // Prevent 100% CPU and provide breathing room for I/O
+        await sleep(2000);
     }
 }
 
@@ -211,14 +230,15 @@ export async function sendMessage(args: {
     const messagePath = path.join(messagesDir, `${agentName}.json`);
     const lockPath = path.join(messagesDir, `${agentName}.lock`);
 
-    let retries = 3;
+    let retries = 20; // Increased retries from 3 to 20
     let acquired = false;
     while (retries > 0) {
         try {
             if (fs.existsSync(lockPath)) {
                 try {
                     const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 5000) {
+                    // Increased stale lock timeout from 5s to 10s for heavy ops
+                    if (Date.now() - stats.mtimeMs > 10000) {
                         fs.unlinkSync(lockPath);
                     }
                 } catch (err) {
@@ -236,6 +256,8 @@ export async function sendMessage(args: {
             if (error.code === "EEXIST") {
                 retries--;
                 if (retries > 0) {
+                    // Exponential backoff or jitter could be added here, 
+                    // but fixed 500ms is usually fine for local file locks.
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
             } else {
@@ -259,7 +281,7 @@ export async function sendMessage(args: {
             status: "PENDING"
         };
         
-        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        appendFile(messagePath, JSON.stringify(message) + "\n");
         
         return message;
     } catch (err) {
@@ -278,6 +300,19 @@ export async function sendMessage(args: {
 
 
 function applyBatchStatusUpdates(changes: Record<string, { state: string; task: string }>) {
-    // Write to Document Store
-    updateDocumentStore("status", changes);
+    let hasChanges = false;
+    const now = new Date().toISOString();
+
+    for (const [agent, data] of Object.entries(changes)) {
+        const current = agentStatusCache[agent];
+        if (!current || current.state !== data.state || current.task !== data.task) {
+            agentStatusCache[agent] = { ...data, lastUpdated: now };
+            hasChanges = true;
+        }
+    }
+
+    if (hasChanges) {
+        updateDocumentStore("status", agentStatusCache);
+        logger.debug("In-memory status cache synced to disk.");
+    }
 }

package/src/cli/commands/plan.ts

@@ -7,7 +7,7 @@ import { UI } from "../utils/ui.js";
 /**
  * Parses docs/user/roadmap.md and injects tasks into the Document Store.
  */
-export function planCommand() {
+export async function planCommand() {
     const projectRoot = process.cwd();
     const roadmapPath = path.join(projectRoot, "docs/user/roadmap.md");
 

package/src/cli/commands/script.ts

@@ -4,7 +4,7 @@ import cp from "child_process";
 
 const targetDir = process.cwd(); // Assuming targetDir is process.cwd() in the CLI context
 
-export function runScriptCommand(script: string, projectPath: string) {
+export async function runScriptCommand(script: string, projectPath: string) {
     const fullPath = path.join(targetDir, projectPath);
     if (!fs.existsSync(fullPath)) {
         console.warn(`❌ Project path not found: ${projectPath}`);

package/src/cli/commands/security.ts

@@ -5,7 +5,7 @@ import { collectFiles } from "../utils/fs.js";
 
 const targetDir = process.cwd();
 
-export function securityAuditCommand(targetPath: string) {
+export async function securityAuditCommand(targetPath: string) {
     console.warn(`🔍 Running Advanced Security Audit on: ${targetPath}...`);
     const scanRules = [
         { pattern: /sql`/, message: "Potential Raw SQL usage detected", severity: "HIGH" },

package/src/cli/commands/status.ts

@@ -5,7 +5,7 @@ import { listTasks, readState, readStatus } from "../utils/memory.js";
 /**
  * Print the current framework status.
  */
-export function statusCommand() {
+export async function statusCommand() {
     const state = readState();
     const tasks = listTasks();
     const agentStatuses = readStatus();

package/src/cli/commands/trace.ts

@@ -4,7 +4,7 @@ import { sanitizeInput, normalizeAgentName, normalizePriority } from "../utils/s
 /**
  * Generate a new Trace ID and add it to project memory.
  */
-export function traceNewCommand(description: string, agent = "manager", priority = "P2"): string | void {
+export async function traceNewCommand(description: string, agent = "manager", priority = "P2"): Promise<string | void> {
     const traceId = generateULID();
     const safeDescription = sanitizeInput(description);
     const safeAgent = normalizeAgentName(agent);

package/src/cli/index.ts

@@ -71,21 +71,21 @@ async function main() {
         }
 
         case "check":
-            checkCommand();
+            await checkCommand();
             break;
 
         case "plan":
-            planCommand();
+            await planCommand();
             break;
         case "status":
-            statusCommand();
+            await statusCommand();
             break;
 
         case "trace:new": {
             const description = args[1] || "Default task";
             const agent = args[2] || "manager";
             const priority = args[3] || "P1";
-            traceNewCommand(description, agent, priority);
+            await traceNewCommand(description, agent, priority);
             break;
         }
 
@@ -96,7 +96,7 @@ async function main() {
                 console.error("❌ Error: section and content are required.");
                 process.exit(64);
             }
-            updateProjectMemoryCommand(section, content);
+            await updateProjectMemoryCommand(section, content);
             break;
         }
 
@@ -104,9 +104,15 @@ async function main() {
             await createAppCommand(args.slice(1));
             break;
 
+        case "dashboard": {
+            const { dashboardCommand } = await import("./commands/dashboard.js");
+            await dashboardCommand(args.slice(1));
+            break;
+        }
+
         case "orchestrate":
         case "loop":
-            orchestrateCommand();
+            await orchestrateCommand();
             break;
 
         case "approve": {
@@ -115,16 +121,16 @@ async function main() {
                 console.error("❌ Error: traceId is required.");
                 process.exit(64);
             }
-            approveCommand(traceId);
+            await approveCommand(traceId);
             break;
         }
 
         case "verify-contract":
-            verifyApiContractCommand();
+            await verifyApiContractCommand();
             break;
     
         case "update-contract":
-            updateApiContractCommand();
+            await updateApiContractCommand();
             break;
 
         case "validate":
@@ -144,34 +150,34 @@ async function main() {
             const memoryContent = fs.existsSync(getMemoryPath()) ? fs.readFileSync(getMemoryPath(), "utf8") : "";
             const traceId = readActiveTraceId(memoryContent) || "T-000";
             const { gitCommitCommand } = await import("./commands/git.js");
-            gitCommitCommand(traceId);
+            await gitCommitCommand(traceId);
             break;
         }
 
         case "git:sync": {
             const { gitSyncCommand } = await import("./commands/git.js");
-            gitSyncCommand();
+            await gitSyncCommand();
             break;
         }
 
         case "check:compliance": {
             const targetPath = args[1] || "src";
             const { complianceCheckCommand } = await import("./commands/compliance.js");
-            complianceCheckCommand(targetPath);
+            await complianceCheckCommand(targetPath);
             break;
         }
 
         case "explorer:graph": {
             const targetPath = args[1] || "src";
             const { explorerGraphCommand } = await import("./commands/explorer.js");
-            explorerGraphCommand(targetPath);
+            await explorerGraphCommand(targetPath);
             break;
         }
 
         case "explorer:audit": {
             const targetPath = args[1] || "src";
             const { explorerAuditCommand } = await import("./commands/explorer.js");
-            explorerAuditCommand(targetPath);
+            await explorerAuditCommand(targetPath);
             break;
         }
 
@@ -179,14 +185,14 @@ async function main() {
             const topic = args[1];
             const content = args[2];
             const { updateKnowledgeBaseCommand } = await import("./commands/knowledge.js");
-            updateKnowledgeBaseCommand(topic, content);
+            await updateKnowledgeBaseCommand(topic, content);
             break;
         }
 
         case "knowledge:search": {
             const query = args[1];
             const { searchKnowledgeBaseCommand } = await import("./commands/knowledge.js");
-            searchKnowledgeBaseCommand(query);
+            await searchKnowledgeBaseCommand(query);
             break;
         }
 
@@ -198,7 +204,7 @@ async function main() {
             const memoryContent = fs.existsSync(getMemoryPath()) ? fs.readFileSync(getMemoryPath(), "utf8") : "";
             const traceId = readActiveTraceId(memoryContent) || "T-000";
             const { logAgentActionCommand } = await import("./commands/log.js");
-            logAgentActionCommand({ agent, action, status, summary, traceId });
+            await logAgentActionCommand({ agent, action, status, summary, traceId });
             break;
         }
 
@@ -206,20 +212,20 @@ async function main() {
             const script = args[1];
             const projectPath = args[2] || ".";
             const { runScriptCommand } = await import("./commands/script.js");
-            runScriptCommand(script, projectPath);
+            await runScriptCommand(script, projectPath);
             break;
         }
 
         case "security:audit": {
             const targetPath = args[1] || "src";
             const { securityAuditCommand } = await import("./commands/security.js");
-            securityAuditCommand(targetPath);
+            await securityAuditCommand(targetPath);
             break;
         }
 
         case "check:lint": {
             const { lintCommand } = await import("./commands/lint.js");
-            lintCommand();
+            await lintCommand();
             break;
         }
 
@@ -267,7 +273,7 @@ async function main() {
 
 function showHelp() {
     console.warn(`
-🎖️  Enderun Core CLI (v${getPackageVersion()}) — The Supreme AI Orchestrator
+🎖️  Agent Enderun CLI (v${getPackageVersion()}) — The Supreme AI Orchestrator
 
 Usage:
   agent-enderun <command> [options]
@@ -309,8 +315,18 @@ Example:
 }
 
 import { logger } from "../shared/logger.js";
+import { EnderunBaseError } from "../shared/errors.js";
 
 main().catch((err) => {
+    if (err instanceof EnderunBaseError) {
+        console.error(`\n❌ [${err.code}] Error: ${err.message}`);
+        if (err.solution) {
+            console.warn(`💡 Solution Tip: ${err.solution}\n`);
+        }
+    } else {
+        console.error(`\n❌ Fatal Error: ${err.message || String(err)}`);
+    }
+
     logger.fatal("Fatal exception during CLI execution", err);
     process.exit(1);
 });