tribunal-kit 9.2.3 → 9.2.4

package/.agent/scripts/memory_archivist.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * memory_archivist.js
+ * Scans the durable session.jsonl log for errors and resolutions,
+ * generating evidence-backed Tribunal Instincts.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { readEvents } = require('./session_logger');
+
+const INSTINCTS_DIR = path.resolve(process.cwd(), '.agent', 'memory');
+const INSTINCTS_FILE = path.join(INSTINCTS_DIR, 'instincts.json');
+
+// Ensure directory exists
+if (!fs.existsSync(INSTINCTS_DIR)) {
+  fs.mkdirSync(INSTINCTS_DIR, { recursive: true });
+}
+
+/**
+ * Load existing instincts
+ */
+function loadInstincts() {
+  if (!fs.existsSync(INSTINCTS_FILE)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(INSTINCTS_FILE, 'utf8'));
+  } catch (_e) {
+    return [];
+  }
+}
+
+/**
+ * Save instincts back to disk
+ */
+function saveInstincts(instincts) {
+  fs.writeFileSync(INSTINCTS_FILE, JSON.stringify(instincts, null, 2), 'utf8');
+}
+
+/**
+ * Mine the JSONL log for failures and successes
+ */
+function archiveSession() {
+  const events = readEvents();
+  const instincts = loadInstincts();
+  
+  let currentError = null;
+  let newInstinctsCount = 0;
+
+  for (const evt of events) {
+    if (evt.type === 'ErrorEncountered') {
+      currentError = evt;
+    } else if (evt.type === 'ToolCompleted' && currentError && evt.sessionId === currentError.sessionId) {
+      // If we see a successful tool completion shortly after an error in the same session, 
+      // we assume it's a resolution. In a real LLM setup, we'd use an AI pass here to summarize the fix.
+      // For now, we stub the instinct generation based on the error.
+      
+      const errorMsg = currentError.payload.message || 'Unknown error';
+      
+      // Avoid duplicates
+      const exists = instincts.find(i => i.evidence.failedEventId === currentError.eventId);
+      
+      if (!exists && errorMsg !== 'Unknown error') {
+        const newInstinct = {
+          id: `instinct_${Date.now()}_${Math.floor(Math.random() * 1000)}`,
+          domain: "auto-archived",
+          rule: `Avoid pattern that caused: ${errorMsg}`,
+          evidence: {
+            failedEventId: currentError.eventId,
+            resolutionEventId: evt.eventId
+          },
+          confidence: "L3" // L3 because it's auto-generated without human verification
+        };
+        
+        instincts.push(newInstinct);
+        newInstinctsCount++;
+      }
+      
+      // Reset error tracker
+      currentError = null;
+    }
+  }
+
+  if (newInstinctsCount > 0) {
+    saveInstincts(instincts);
+    console.log(`✅ Memory Archivist mined ${newInstinctsCount} new instincts from the session log.`);
+  } else {
+    console.log(`ℹ️ Memory Archivist found no new verifiable patterns in the session log.`);
+  }
+}
+
+if (require.main === module) {
+  archiveSession();
+}
+
+module.exports = { archiveSession };

package/.agent/scripts/memory_consolidator.js

@@ -0,0 +1,37 @@
+const { MemoryEngine } = require('./memory_engine.js');
+
+async function consolidateMemory(agentDir) {
+  console.log(`Starting memory consolidation for workspace: ${agentDir}`);
+  
+  const engine = new MemoryEngine(agentDir);
+  const index = engine.loadIndex();
+
+  const episodics = index.entries.filter(e => e.memory_type === 'episodic');
+  const workings = index.entries.filter(e => e.memory_type === 'working');
+  
+  if (episodics.length === 0 && workings.length === 0) {
+    console.log("No Episodic or Working memories to consolidate.");
+    return;
+  }
+
+  console.log(`Found ${episodics.length} Episodic and ${workings.length} Working memories.`);
+  console.log("Submitting to LLM for consolidation into Semantic rules...");
+
+  // Simulation of Tribunal's Maker-Reviewer LLM invocation.
+  // In production, this would pass the contexts to the `logic-reviewer` and output a compressed fact.
+  const consolidatedContent = `Generalized rule derived from ${episodics.length} episodic events and ${workings.length} working sessions.`;
+  
+  const semanticId = engine.store({
+    type: 'semantic',
+    content: consolidatedContent,
+    tags: ['consolidated'],
+    source: 'learned',
+    confidence: 1.0, // Assumes it passed a reviewer gate
+  });
+
+  console.log(`Generated new Semantic Memory ID: ${semanticId}`);
+  console.log("Consolidation complete. Run `tk memory gc` to clear old working entries.");
+}
+
+const dir = process.cwd();
+consolidateMemory(dir).catch(console.error);

package/.agent/scripts/memory_engine.js

@@ -115,23 +115,43 @@ function releaseLock(lockPath) {
 
 // ─── Scoring Engine ───────────────────────────────────────────────────────────
 
-function computeScore(entry, query) {
+function computeScore(entry, query, corpus = []) {
   if (!query || !entry.content) return 0;
-  const queryLower = query.toLowerCase();
+  const queryWords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+  if (queryWords.length === 0) return 0;
   const contentLower = entry.content.toLowerCase();
 
   let relevance = 0;
-  if (contentLower.includes(queryLower)) {
-    relevance = 1.0;
-  } else if (entry.tags && entry.tags.some(t => t.toLowerCase().includes(queryLower))) {
-    relevance = 0.8;
-  } else if (queryLower.split(/\s+/).some(word => word.length > 2 && contentLower.includes(word))) {
-    relevance = 0.3;
+  const k1 = 1.2;
+  const b = 0.75;
+  const avgdl_raw = corpus.length > 0 ? corpus.reduce((sum, e) => sum + (e.content ? e.content.length : 0), 0) / corpus.length : 100;
+  const avgdl = avgdl_raw || 100;
+  const dl = contentLower.length;
+
+  for (const word of queryWords) {
+    const termFreq = contentLower.split(word).length - 1;
+    if (termFreq === 0 && (!entry.tags || !entry.tags.some(t => t.toLowerCase().includes(word)))) continue;
+    
+    // Effective TF including tag boost
+    const tf = termFreq + (entry.tags && entry.tags.some(t => t.toLowerCase().includes(word)) ? 2 : 0);
+    
+    const docFreq = corpus.filter(e => e.content && e.content.toLowerCase().includes(word)).length;
+    // IDF
+    const idf = Math.log((corpus.length - docFreq + 0.5) / (docFreq + 0.5) + 1.0);
+    
+    relevance += idf * (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (dl / avgdl)));
+  }
+
+  // Exact phrase match bonus
+  if (contentLower.includes(query.toLowerCase())) {
+    relevance += 2.0;
   }
 
   if (relevance === 0) return 0;
 
   const priority = entry.priority != null ? entry.priority : (TYPE_PRIORITY[entry.memory_type] || 0.5);
+  const confidence = typeof entry.confidence === 'number' ? entry.confidence : 1.0;
+  
   let recency = 0;
   if (entry.memory_type === 'episodic') {
     const age = daysSince(entry.created_at);
@@ -139,7 +159,7 @@ function computeScore(entry, query) {
   }
   const freqBoost = Math.max(0, Math.log(entry.access_count || 1)) * 0.05;
 
-  return (relevance * priority) + recency + freqBoost;
+  return (relevance * priority * confidence) + recency + freqBoost;
 }
 
 // ─── Memory Engine Class ──────────────────────────────────────────────────────
@@ -257,6 +277,8 @@ class MemoryEngine {
         source: options.source || (type === 'working' ? 'session' : 'manual'),
         session_id: options.sessionId || options.session_id || null,
         priority: typeof options.priority === 'number' ? options.priority : 1.0,
+        relations: Array.isArray(options.relations) ? options.relations : [],
+        confidence: typeof options.confidence === 'number' ? options.confidence : (options.source === 'learned' ? 0.5 : 1.0),
       };
 
       index.entries.push(entry);
@@ -287,9 +309,22 @@ class MemoryEngine {
       const index = this.loadIndex();
 
       const scored = index.entries
-        .map(entry => ({ entry, score: computeScore(entry, query) }))
-        .filter(s => s.score > 0)
-        .sort((a, b) => b.score - a.score);
+        .map(entry => ({ entry, score: computeScore(entry, query, index.entries) }))
+        .filter(s => s.score > 0);
+
+      // Apply relational boosting
+      for (const s of scored) {
+        if (s.entry.relations) {
+          for (const relId of s.entry.relations) {
+             const related = scored.find(r => String(r.entry.id) === String(relId));
+             if (related) {
+               related.score += s.score * 0.2; // 20% boost from incoming relation
+             }
+          }
+        }
+      }
+
+      scored.sort((a, b) => b.score - a.score);
 
       let totalTokens = 0;
       const results = [];
@@ -350,6 +385,8 @@ class MemoryEngine {
       token_estimate: entry.token_estimate,
       source: entry.source,
       session_id: entry.session_id,
+      relations: entry.relations || [],
+      confidence: typeof entry.confidence === 'number' ? entry.confidence : 1.0,
     };
   }
 
@@ -505,31 +542,34 @@ class MemoryEngine {
 
     if (sem.length > 0) {
       md += '## SEMANTIC (Permanent Facts)\n';
-      md += '| ID | Content | Tags | Source | Created |\n';
-      md += '|----|---------|------|--------|---------|\n';
+      md += '| ID | Content | Tags | Source | Conf | Created |\n';
+      md += '|----|---------|------|--------|------|---------|\n';
       for (const e of sem) {
-        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${e.created_at} |\n`;
+        const conf = typeof e.confidence === 'number' ? e.confidence.toFixed(1) : '1.0';
+        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${conf} | ${e.created_at} |\n`;
       }
       md += '\n';
     }
 
     if (proc.length > 0) {
       md += '## PROCEDURAL (How-To Recipes)\n';
-      md += '| ID | Content | Tags | Source | Created |\n';
-      md += '|----|---------|------|--------|---------|\n';
+      md += '| ID | Content | Tags | Source | Conf | Created |\n';
+      md += '|----|---------|------|--------|------|---------|\n';
       for (const e of proc) {
-        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${e.created_at} |\n`;
+        const conf = typeof e.confidence === 'number' ? e.confidence.toFixed(1) : '1.0';
+        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${conf} | ${e.created_at} |\n`;
       }
       md += '\n';
     }
 
     if (ep.length > 0) {
       md += '## EPISODIC (Session History — auto-decays after 30 days)\n';
-      md += '| ID | Content | Tags | Source | Created | Days Remaining |\n';
-      md += '|----|---------|------|--------|---------|----------------|\n';
+      md += '| ID | Content | Tags | Source | Conf | Created | Days Remaining |\n';
+      md += '|----|---------|------|--------|------|---------|----------------|\n';
       for (const e of ep) {
         const remaining = Math.max(0, EPISODIC_TTL_DAYS - daysSince(e.created_at));
-        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${e.created_at} | ${remaining} |\n`;
+        const conf = typeof e.confidence === 'number' ? e.confidence.toFixed(1) : '1.0';
+        md += `| ${e.id} | ${e.content.replace(/\|/g, '\\|')} | ${(e.tags || []).join(', ')} | ${e.source || 'manual'} | ${conf} | ${e.created_at} | ${remaining} |\n`;
       }
       md += '\n';
     }

package/.agent/scripts/pipeline_engine.js

@@ -47,6 +47,12 @@ const {
 } = require('./_colors');
 const { findAgentDir, parseArgs, loadJson } = require('./_utils');
 
+let sessionLogger = null;
+try {
+  sessionLogger = require('./session_logger');
+} catch (_e) {}
+
+
 // ── Lazy-load sibling scripts (avoid circular deps) ─────────────────────────
 let _contextBroker = null;
 function getContextBroker() {
@@ -528,7 +534,7 @@ function validatePhase(code, spec, opts = {}) {
         if (fs.existsSync(manifestPath)) {
           manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
         }
-      } catch (e) {}
+      } catch (_e) {}
 
       const grResult = guardrailEngine.validate(code, manifest, { context: { projectRoot: process.cwd(), filePath: spec.target_file } });
       if (grResult && grResult.violations) {
@@ -612,7 +618,7 @@ function detectLang(spec) {
 /**
  * Find the first line number matching a regex pattern.
  */
-function findLineNumber(lines, pattern) {
+function _findLineNumber(lines, pattern) {
   for (let i = 0; i < lines.length; i++) {
     if (pattern.test(lines[i])) return i + 1;
   }
@@ -649,6 +655,15 @@ function fullPipeline(task, files = [], opts = {}) {
   // The caller invokes validate(code) after the LLM generates the code
   const validate = code => validatePhase(code, spec, { lang: detectLang(spec) });
 
+  if (sessionLogger) {
+    sessionLogger.appendEvent('AgentDispatched', {
+      task,
+      files,
+      promptTokens: builderResult.tokenEstimate,
+      skills: builderResult.skillsLoaded,
+    }, 'pipeline_engine');
+  }
+
   return {
     spec,
     prompt: builderResult.prompt,

package/.agent/scripts/session_logger.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Event-Sourced Durable Session Logger
+ * Replaces static JSON session state with an append-only JSONL event stream.
+ */
+
+const SESSION_DIR = path.resolve(process.cwd(), '.agent', '.tribunal');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.jsonl');
+
+// Ensure directory exists
+if (!fs.existsSync(SESSION_DIR)) {
+  fs.mkdirSync(SESSION_DIR, { recursive: true });
+}
+
+/**
+ * Generate a unique event ID
+ */
+function generateEventId() {
+  return 'evt_' + crypto.randomBytes(8).toString('hex');
+}
+
+/**
+ * Append an event to the JSONL log
+ * @param {string} type - The event type (e.g., 'ToolRequested', 'AgentDispatched')
+ * @param {object} payload - The event payload
+ * @param {string} source - The source of the event ('harness-manager', 'worker', etc.)
+ * @param {string} [sessionId] - Optional session ID to tie events together
+ */
+function appendEvent(type, payload = {}, source = 'system', sessionId = 'default') {
+  const event = {
+    timestamp: new Date().toISOString(),
+    eventId: generateEventId(),
+    sessionId,
+    type,
+    source,
+    payload
+  };
+
+  const line = JSON.stringify(event) + '\n';
+  fs.appendFileSync(SESSION_FILE, line, 'utf8');
+  return event.eventId;
+}
+
+/**
+ * Read all events from the log
+ * @returns {Array<object>} Array of parsed events
+ */
+function readEvents() {
+  if (!fs.existsSync(SESSION_FILE)) return [];
+  const content = fs.readFileSync(SESSION_FILE, 'utf8');
+  return content
+    .split('\n')
+    .filter(line => line.trim().length > 0)
+    .map(line => {
+      try {
+        return JSON.parse(line);
+      } catch (_e) {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Rehydrate session state by folding over the event stream
+ * @returns {object} Rehydrated state
+ */
+function rehydrateState() {
+  const events = readEvents();
+  const state = {
+    currentSessionId: 'default',
+    sessions: {},
+    toolsExecuted: 0,
+    errorsEncountered: 0,
+  };
+
+  for (const evt of events) {
+    if (!state.sessions[evt.sessionId]) {
+      state.sessions[evt.sessionId] = {
+        startedAt: null,
+        endedAt: null,
+        events: [],
+        status: 'active'
+      };
+    }
+    
+    const sess = state.sessions[evt.sessionId];
+    sess.events.push(evt);
+
+    if (evt.type === 'SessionStarted') {
+      sess.startedAt = evt.timestamp;
+      state.currentSessionId = evt.sessionId;
+    } else if (evt.type === 'SessionEnded') {
+      sess.endedAt = evt.timestamp;
+      sess.status = 'completed';
+    } else if (evt.type === 'ToolCompleted') {
+      state.toolsExecuted++;
+    } else if (evt.type === 'ErrorEncountered') {
+      state.errorsEncountered++;
+      sess.status = 'error';
+    }
+  }
+
+  return state;
+}
+
+module.exports = {
+  appendEvent,
+  readEvents,
+  rehydrateState,
+  SESSION_FILE
+};

package/.agent/scripts/session_manager.js

@@ -17,6 +17,12 @@
 
 const fs = require('fs');
 const path = require('path');
+let sessionLogger = null;
+try {
+  sessionLogger = require('./session_logger');
+} catch (_e) {
+  // Graceful fallback if session_logger is not present
+}
 
 const STATE_FILE = '.agent_session.json';
 
@@ -61,6 +67,10 @@ function cmdSave(note) {
   state.current = entry;
   saveState(state);
 
+  if (sessionLogger) {
+    sessionLogger.appendEvent('SessionStarted', { note, tags: [] }, 'session_manager', entry.session);
+  }
+
   console.log(`${GREEN}✅ Session saved:${RESET} ${note}`);
   console.log(`   Time:    ${entry.timestamp}`);
   console.log(`   Session: #${entry.session}`);

package/.agent/scripts/swarm_dispatcher.js

@@ -410,6 +410,63 @@ class SwarmOrchestrator {
     return results;
   }
 
+  async executeDAG(payload) {
+    const tasks = (typeof payload === 'object' && payload.tasks) ? payload.tasks : [];
+    if (tasks.length === 0) {
+      return [];
+    }
+
+    this.workers = tasks;
+    this.results = [];
+    
+    if (this.dashboard) {
+      this.dashboard.workers = this.workers.map(w => ({
+        name: w.agent || w.id || 'Worker',
+        task: (w.goal || w.task_description || '').slice(0, 40) + '...',
+        status: '⏳ Pending',
+        color: '\x1b[33m'
+      }));
+      this.dashboard.start();
+    }
+
+    const completed = new Set();
+    const inProgress = new Set();
+
+    while (completed.size < tasks.length) {
+      const availableTasks = tasks.filter(t => 
+        !completed.has(t.id) && 
+        !inProgress.has(t.id) &&
+        (t.deps || []).every(dep => completed.has(dep))
+      );
+
+      if (availableTasks.length === 0 && inProgress.size === 0) {
+        if (this.dashboard) this.dashboard.stop();
+        throw new Error("DAG deadlock detected.");
+      }
+
+      if (availableTasks.length === 0) {
+        await new Promise(r => setTimeout(r, 100));
+        continue;
+      }
+
+      availableTasks.forEach(t => inProgress.add(t.id));
+      
+      const batchPromises = availableTasks.map(t => 
+        this.executeWorker(t, 60000).then(result => {
+          inProgress.delete(t.id);
+          completed.add(t.id);
+          this.results.push(result);
+          return result;
+        })
+      );
+      
+      await Promise.allSettled(batchPromises);
+    }
+    
+    if (this.dashboard) this.dashboard.stop();
+    return this.results;
+  }
+
   async executeWorker(worker, timeout) {
     const workerIndex = this.workers.indexOf(worker);
     if (this.dashboard && workerIndex !== -1) {
@@ -770,7 +827,7 @@ function main() {
       useTui = true;
     } else if (arg === '-h' || arg === '--help') {
       console.log(
-        'Usage: swarm_dispatcher.js [--payload <json>] [--file <path>] [--workspace <dir>] [--mode legacy|swarm] [--tui]',
+        'Usage: swarm_dispatcher.js [--payload <json>] [--file <path>] [--workspace <dir>] [--mode legacy|swarm|dag] [--tui]',
       );
       process.exit(0);
     }
@@ -857,6 +914,22 @@ function main() {
         console.error(`ERROR: Swarm orchestration failed: ${err.message}`);
         process.exit(1);
       });
+  } else if (mode === 'dag') {
+    const orchestrator = new SwarmOrchestrator(useTui ? new SwarmDashboard([]) : null);
+    orchestrator.executeDAG(payloadData)
+      .then(results => {
+        if (!useTui) {
+          console.log('INFO: DAG orchestration successful.');
+          console.log('--- EXECUTION PLAN (MOCK RESULTS) ---');
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          console.log('\n\x1b[32m✔ DAG orchestration complete.\x1b[0m\n');
+        }
+      })
+      .catch(err => {
+        console.error(`ERROR: DAG orchestration failed: ${err.message}`);
+        process.exit(1);
+      });
   } else {
     if (!validatePayload(payloadData, workspaceRoot, agentsDir, file)) {
       console.error('ERROR: Payload validation failed.');

package/.agent/scripts/syscall_registry.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * syscall_registry.js
+ * Centralized registry mapping permitted agent syscalls to their underlying script paths.
+ * Enforces execution security boundaries.
+ */
+
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Define allowed syscalls and their corresponding scripts
+const SYSCALL_MAP = {
+  'run_audit': {
+    script: 'checklist.js',
+    allowedArgs: ['--strict', '--fix', '.']
+  },
+  'security_scan': {
+    script: 'security_scan.js',
+    allowedArgs: ['.']
+  },
+  'lint_runner': {
+    script: 'lint_runner.js',
+    allowedArgs: ['--fix', '.']
+  },
+  'schema_validator': {
+    script: 'schema_validator.js',
+    allowedArgs: ['.']
+  },
+  'test_runner': {
+    script: 'test_runner.js',
+    allowedArgs: ['--coverage', '.']
+  },
+  'dependency_analyzer': {
+    script: 'dependency_analyzer.js',
+    allowedArgs: ['--audit', '.']
+  }
+};
+
+/**
+ * Validates and executes a syscall securely.
+ * @param {string} syscall - The name of the syscall to execute
+ * @param {string[]} args - The arguments passed to the syscall
+ * @returns {object} { exitCode: number, stdout: string, stderr: string }
+ */
+function executeSyscall(syscall, args = []) {
+  const config = SYSCALL_MAP[syscall];
+  
+  if (!config) {
+    return {
+      exitCode: 1,
+      stdout: '',
+      stderr: `Security Exception: Syscall '${syscall}' is not recognized or permitted.`
+    };
+  }
+
+  // Argument validation: only allow arguments pre-approved in allowedArgs
+  const invalidArgs = args.filter(arg => !config.allowedArgs.includes(arg) && !arg.startsWith('--target=') && !arg.startsWith('--file='));
+  if (invalidArgs.length > 0) {
+    return {
+      exitCode: 1,
+      stdout: '',
+      stderr: `Security Exception: Invalid arguments for syscall '${syscall}': ${invalidArgs.join(', ')}`
+    };
+  }
+
+  // Prevent shell metacharacter injection
+  const shellMetaChars = /[;&|><$`\\]/;
+  const unsafeArgs = args.filter(arg => shellMetaChars.test(arg));
+  if (unsafeArgs.length > 0) {
+    return {
+      exitCode: 1,
+      stdout: '',
+      stderr: `Security Exception: Unsafe shell metacharacters detected in arguments.`
+    };
+  }
+
+  const scriptPath = path.join(__dirname, config.script);
+  
+  try {
+    const result = spawnSync('node', [scriptPath, ...args], {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      timeout: 300000 // 5 minutes max execution time
+    });
+
+    return {
+      exitCode: result.status !== null ? result.status : 1,
+      stdout: result.stdout || '',
+      stderr: result.stderr || (result.error ? result.error.message : '')
+    };
+  } catch (err) {
+    return {
+      exitCode: 1,
+      stdout: '',
+      stderr: `Syscall execution failed: ${err.message}`
+    };
+  }
+}
+
+module.exports = {
+  SYSCALL_MAP,
+  executeSyscall
+};

package/.agent/scripts/test_runner.js

@@ -44,7 +44,7 @@ function runTests(label, cmd, cwd) {
       cwd,
       encoding: 'utf8',
       timeout: 300000, // 5m
-      shell: process.platform === 'win32',
+      shell: false,
     });
 
     const ms = elapsed();