tribunal-kit 5.8.5 → 6.0.0

package/dist/cli.js

@@ -247,6 +247,11 @@ async function runWithUpdateCheck(command, flags) {
             await cmdMarathon(flags, process.argv, quiet);
             break;
         }
+        case 'minimal': {
+            const cmdMinimal = loadCmd('./commands/minimal', 'cmdMinimal');
+            cmdMinimal(flags, quiet);
+            break;
+        }
         case 'compile': {
             const cmdCompile = loadCmd('./commands/compile', 'cmdCompile');
             await cmdCompile(flags, quiet);
@@ -317,5 +322,8 @@ async function main() {
     await runWithUpdateCheck(command, flags);
 }
 if (require.main === module) {
-    main();
+    main().catch(err => {
+        console.error(`\x1b[91m✖ Fatal Error:\x1b[0m ${err.message || err}`);
+        process.exit(1);
+    });
 }

package/dist/commands/compile.js

@@ -74,6 +74,13 @@ async function cmdCompile(flags, quiet) {
         if (flags.target === "claude") targetFile = ".claude.json";
     }
     
+    const byteLength = Buffer.byteLength(compiledContext, "utf-8");
+    const mbSize = byteLength / (1024 * 1024);
+    if (mbSize > 5.0 && !quiet) {
+        const { warn } = require("../utils/logger");
+        warn(`Compiled context is very large (~${mbSize.toFixed(2)} MB). This might overload some LLM context windows.`);
+    }
+
     const outputPath = path.join(cwd, targetFile);
     fs.writeFileSync(outputPath, compiledContext, "utf-8");
     

package/dist/commands/context.js

@@ -19,11 +19,16 @@ function cmdContext(flags, processArgs) {
         console.error('Usage: npx tribunal-kit context <target_file>');
         process.exit(1);
     }
-    const targetFile = args[0].replace(/\\/g, '/');
-    const snapshotName = targetFile.replace(/[\\\/]/g, '__') + '.json';
+    const resolvedTarget = path_1.default.resolve(targetDir, args[0]);
+    const relativePath = path_1.default.relative(targetDir, resolvedTarget).replace(/\\/g, '/');
+    if (relativePath.startsWith('../') || relativePath === '..' || path_1.default.isAbsolute(relativePath)) {
+        console.error('  \x1b[91m✖\x1b[0m File must be within the project directory: ' + args[0]);
+        process.exit(1);
+    }
+    const snapshotName = relativePath.replace(/[\\\/]/g, '__') + '.json';
     const snapshotPath = path_1.default.join(agentDest, 'history', 'snapshots', snapshotName);
     if (!fs_1.default.existsSync(snapshotPath)) {
-        console.error('  \x1b[91m✖\x1b[0m Context Snapshot not found for: ' + targetFile);
+        console.error('  \x1b[91m✖\x1b[0m Context Snapshot not found for: ' + args[0]);
         console.log('    Run: npx tribunal-kit graph  (to generate snapshots)');
         process.exit(1);
     }

package/dist/commands/graph.js

@@ -23,8 +23,14 @@ async function cmdGraph(flags, quiet = false) {
         await (0, helpers_1.runShellAsync)(`node "${builderScript}"`, { stdio: 'inherit', cwd: targetDir });
         await (0, helpers_1.runShellAsync)(`node "${visualizerScript}"`, { stdio: 'inherit', cwd: targetDir });
         (0, logger_1.log)(`  ${(0, logger_1.c)('cyan', '▸')} Opening visualizer in browser...`);
-        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
-        await (0, helpers_1.runShellAsync)(`${opener} "${htmlFile}"`, { stdio: 'ignore' });
+        const child_process = require('child_process');
+        if (process.platform === 'win32') {
+            child_process.spawn('cmd.exe', ['/c', 'start', '', htmlFile], { stdio: 'ignore', detached: true }).unref();
+        } else if (process.platform === 'darwin') {
+            child_process.spawn('open', [htmlFile], { stdio: 'ignore', detached: true }).unref();
+        } else {
+            child_process.spawn('xdg-open', [htmlFile], { stdio: 'ignore', detached: true }).unref();
+        }
     }
     catch (e) {
         if (e instanceof Error) {

package/dist/commands/init.js

@@ -26,13 +26,22 @@ const CORE_AGENTS = new Set([
     'explorer-agent.md',
     'project-planner.md',
     'test-engineer.md',
+    'ui-ux-auditor.md',
+    'ui-visual-auditor.md',
+    'accessibility-reviewer.md',
+    'ux-reviewer.md',
+    'visual-reviewer.md',
+    'interaction-reviewer.md',
+    'anti-pattern-reviewer.md',
+    'product-reviewer.md',
 ]);
 // Core skills to install in --minimal mode
 const CORE_SKILLS = new Set([
     'clean-code', 'architecture', 'testing-patterns', 'systematic-debugging',
     'frontend-design', 'database-design', 'api-patterns', 'nodejs-best-practices',
     'vulnerability-scanner', 'typescript-advanced', 'python-pro', 'nextjs-react-expert',
-    'react-specialist', 'performance-profiling', 'lint-and-validate',
+    'react-specialist', 'performance-profiling', 'lint-and-validate', 'ui-ux-pro-max',
+    'ui-reasoning-engine', 'product-aware-heuristics', 'web-design-guidelines',
 ]);
 async function cmdInit(flags, quiet = false) {
     const agentSrc = (0, helpers_1.getKitAgent)();
@@ -267,7 +276,7 @@ async function cmdInit(flags, quiet = false) {
             console.log(drawRow('  Next Steps:', (0, logger_1.c)('gray', '  Next Steps:')));
             console.log(stepRow('/generate', 'Generate code with reviews'));
             console.log(stepRow('/review', 'Audit existing code for issues'));
-            console.log(stepRow('/tribunal-full', 'Run all 19 reviewers in parallel'));
+            console.log(stepRow('/tribunal-full', 'Run all 21 reviewers in parallel'));
             console.log(drawRow('', ''));
             console.log(`  ${(0, logger_1.c)(borderCol, '└' + '─'.repeat(W) + '┘')}`);
             console.log();
@@ -399,4 +408,6 @@ async function scaffoldDesignSystem(targetDir, agentSrc, dryRun = false) {
     await copyIfMissing(designMdSrc, designMdDest, 'DESIGN.md System');
     await copyIfMissing(designTokensSrc, designTokensDest, 'Design Tokens');
 }
+exports.CORE_AGENTS = CORE_AGENTS;
+exports.CORE_SKILLS = CORE_SKILLS;
 

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/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/esm/index.mjs

@@ -34,83 +34,77 @@ export const runShellAsync = helpers.runShellAsync;
 export const getKitAgent = helpers.getKitAgent;
 export const banner = helpers.banner;
 
+// Helper to wrap CommonJS requires in friendly error diagnostics
+function loadCommand(modulePath, functionName, ...args) {
+  try {
+    const mod = require(modulePath);
+    return mod[functionName](...args);
+  } catch (err) {
+    throw new Error(`Tribunal ESM wrapper failed to load command '${functionName}' from '${modulePath}': ${err.message}`);
+  }
+}
+
 // ── Lazy command loaders (imported on demand) ────────────
 export async function cmdInit(flags, quiet) {
-  const mod = require('../commands/init.js');
-  return mod.cmdInit(flags, quiet);
+  return loadCommand('../commands/init.js', 'cmdInit', flags, quiet);
 }
 
 export async function cmdUpdate(flags) {
-  const mod = require('../commands/update.js');
-  return mod.cmdUpdate(flags);
+  return loadCommand('../commands/update.js', 'cmdUpdate', flags);
 }
 
 export function cmdStatus(flags, quiet) {
-  const mod = require('../commands/status.js');
-  return mod.cmdStatus(flags, quiet);
+  return loadCommand('../commands/status.js', 'cmdStatus', flags, quiet);
 }
 
 export async function cmdLearn(flags, quiet) {
-  const mod = require('../commands/learn.js');
-  return mod.cmdLearn(flags, quiet);
+  return loadCommand('../commands/learn.js', 'cmdLearn', flags, quiet);
 }
 
 export async function cmdCase(flags, argv, quiet) {
-  const mod = require('../commands/case.js');
-  return mod.cmdCase(flags, argv, quiet);
+  return loadCommand('../commands/case.js', 'cmdCase', flags, argv, quiet);
 }
 
 export function cmdHook(flags) {
-  const mod = require('../commands/hook.js');
-  return mod.cmdHook(flags);
+  return loadCommand('../commands/hook.js', 'cmdHook', flags);
 }
 
 export async function cmdGraph(flags, quiet) {
-  const mod = require('../commands/graph.js');
-  return mod.cmdGraph(flags, quiet);
+  return loadCommand('../commands/graph.js', 'cmdGraph', flags, quiet);
 }
 
 export async function cmdMutate(flags, argv) {
-  const mod = require('../commands/mutate.js');
-  return mod.cmdMutate(flags, argv);
+  return loadCommand('../commands/mutate.js', 'cmdMutate', flags, argv);
 }
 
 export function cmdContext(flags, argv) {
-  const mod = require('../commands/context.js');
-  return mod.cmdContext(flags, argv);
+  return loadCommand('../commands/context.js', 'cmdContext', flags, argv);
 }
 
 export async function cmdSync() {
-  const mod = require('../commands/sync.js');
-  return mod.cmdSync();
+  return loadCommand('../commands/sync.js', 'cmdSync');
 }
 
 export async function cmdAlign(flags, argv, quiet) {
-  const mod = require('../commands/align.js');
-  return mod.cmdAlign(flags, argv, quiet);
+  return loadCommand('../commands/align.js', 'cmdAlign', flags, argv, quiet);
 }
 
 export async function cmdMarathon(flags, argv, quiet) {
-  const mod = require('../commands/marathon.js');
-  return mod.cmdMarathon(flags, argv, quiet);
+  return loadCommand('../commands/marathon.js', 'cmdMarathon', flags, argv, quiet);
 }
 
 export async function cmdCompile(flags, quiet) {
-  const mod = require('../commands/compile.js');
-  return mod.cmdCompile(flags, quiet);
+  return loadCommand('../commands/compile.js', 'cmdCompile', flags, quiet);
 }
 
 export async function cmdMemory(flags, argv, quiet) {
-  const mod = require('../commands/memory.js');
-  return mod.cmdMemory(flags, argv, quiet);
+  return loadCommand('../commands/memory.js', 'cmdMemory', flags, argv, quiet);
 }
 
 export function cmdUninstall(flags, quiet) {
-  const mod = require('../commands/uninstall.js');
-  return mod.cmdUninstall(flags, quiet);
+  return loadCommand('../commands/uninstall.js', 'cmdUninstall', flags, quiet);
 }
 
 export async function generateIDEBridges(cwd, agentDest, quiet) {
-  const mod = require('../commands/init.js');
-  return mod.generateIDEBridges(cwd, agentDest, quiet);
+  return loadCommand('../commands/init.js', 'generateIDEBridges', cwd, agentDest, quiet);
 }

package/dist/utils/fs.js

@@ -12,7 +12,10 @@ const logger_1 = require("./logger");
 // Concurrency limit for parallel file operations to avoid fd exhaustion
 const COPY_CONCURRENCY = 32;
 
-async function copyDir(src, dest, dryRun = false, filter = null) {
+async function copyDir(src, dest, dryRun = false, filter = null, currentDepth = 0) {
+    if (currentDepth > 20) {
+        throw new Error(`Maximum directory copy depth (20) exceeded at: ${src}`);
+    }
     if (!dryRun) {
         await fs_1.default.promises.mkdir(dest, { recursive: true });
     }
@@ -51,7 +54,7 @@ async function copyDir(src, dest, dryRun = false, filter = null) {
 
     // Recurse into directories in parallel (dirs are I/O-independent)
     const dirResults = await Promise.all(
-        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter))
+        dirs.map(({ srcPath, destPath }) => copyDir(srcPath, destPath, dryRun, filter, currentDepth + 1))
     );
     for (const dirCount of dirResults) {
         count += dirCount;
@@ -59,12 +62,15 @@ async function copyDir(src, dest, dryRun = false, filter = null) {
 
     return count;
 }
-async function countDir(dir) {
+async function countDir(dir, currentDepth = 0) {
+    if (currentDepth > 20) {
+        throw new Error(`Maximum directory count depth (20) exceeded at: ${dir}`);
+    }
     let count = 0;
     const entries = await fs_1.default.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
         if (e.isDirectory())
-            count += await countDir(path_1.default.join(dir, e.name));
+            count += await countDir(path_1.default.join(dir, e.name), currentDepth + 1);
         else
             count++;
     }

package/dist/utils/helpers.js

@@ -12,14 +12,23 @@ const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
 function runShellAsync(command, options) {
     return new Promise((resolve, reject) => {
+        const timeoutMs = (options && options.timeout) || 120000;
         const child = (0, child_process_1.spawn)(command, [], { ...options, shell: true });
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+        }, timeoutMs);
         child.on('close', code => {
+            clearTimeout(timer);
             if (code !== 0)
                 reject(new Error(`Command failed with exit code ${code}`));
             else
                 resolve();
         });
-        child.on('error', reject);
+        child.on('error', err => {
+            clearTimeout(timer);
+            reject(err);
+        });
     });
 }
 function getKitAgent() {

package/dist/utils/version.js

@@ -119,18 +119,25 @@ function fetchLatestVersion(currentVersion) {
  * 
  * Returns true if a re-invoke happened (caller should exit), false otherwise.
  */
+let hasRegisteredUpdateNotifier = false;
+
 async function autoUpdateCheck(originalArgs, currentVersion) {
     // Recursion guard: if we're already a re-invoked process, skip
     if (process.env.TK_SKIP_UPDATE_CHECK === '1') {
         return false;
     }
 
+    if (hasRegisteredUpdateNotifier) {
+        return false;
+    }
+    hasRegisteredUpdateNotifier = true;
+
     // Fire the fetch but DON'T await it immediately — let the command run first
     const versionPromise = fetchLatestVersion(currentVersion);
 
-    // Register a process.on('beforeExit') hook to show the update notification
+    // Register a process.once('beforeExit') hook to show the update notification
     // AFTER the command has finished executing
-    process.on('beforeExit', async () => {
+    process.once('beforeExit', async () => {
         try {
             const latestVersion = await versionPromise;
             if (!latestVersion) return;