@tjamescouch/niki 0.5.4 → 0.5.6

package/bin/niki

@@ -34,6 +34,7 @@ if (SEPARATOR === -1 || SEPARATOR === process.argv.length - 1) {
 Usage: niki [options] -- <command> [args...]
 
 Options:
+  --profile <name>       Apply a preset profile (default: none; profiles: longrun)
   --budget <tokens>       Max total tokens (input+output) before SIGTERM (default: 1000000)
   --timeout <seconds>     Max wall-clock runtime before SIGTERM (default: 3600)
   --max-sends <n>         Max agentchat_send calls per minute (default: 10)
@@ -53,8 +54,10 @@ Options:
   --restart               Restart the child process when it exits (default: off)
   --max-restarts <n>      Max restart attempts, 0=unlimited (default: 0)
   --restart-delay <secs>  Delay between restarts with ±30% jitter (default: 5)
+  --kill-orphaned-mcp     Kill stale agentchat-mcp processes on startup (default: off)
 
 Examples:
+  niki --profile longrun -- gro --persistent --model sonnet
   niki --budget 500000 -- claude -p "your prompt" --verbose
   niki --timeout 1800 --max-sends 5 -- claude -p "..." --model sonnet --verbose
   niki --restart --max-restarts 10 -- gro --model gpt-5.2 "your prompt"`);
@@ -65,28 +68,66 @@ const nikiArgs = process.argv.slice(2, SEPARATOR);
 const childCmd = process.argv[SEPARATOR + 1];
 const childArgs = process.argv.slice(SEPARATOR + 2);
 
+function getProfileArg(args) {
+  const i = args.indexOf("--profile");
+  if (i === -1) return null;
+  const v = args[i + 1];
+  return v && !v.startsWith("-") ? v : null;
+}
+
+const DEFAULTS = {
+  budget: "1000000",
+  timeout: "3600",
+  "max-sends": "10",
+  "max-tool-calls": "30",
+  "stall-timeout": "60",
+  "startup-timeout": "180",
+  "dead-air-timeout": "5",
+  "max-nudges": "3",
+  cooldown: "5",
+  "poll-interval": "1000",
+  "max-restarts": "0",
+  "restart-delay": "5"
+};
+
+const PROFILES = {
+  longrun: {
+    timeout: "86400",
+    "stall-timeout": "0",
+    "startup-timeout": "0",
+    "dead-air-timeout": "0",
+    cooldown: "15"
+  }
+};
+
+const profileArg = getProfileArg(nikiArgs);
+const D = profileArg && PROFILES[profileArg] ? { ...DEFAULTS, ...PROFILES[profileArg] } : DEFAULTS;
+
+
 const { values: opts } = parseArgs({
   args: nikiArgs,
   options: {
-    budget:          { type: 'string', default: '1000000' },
-    timeout:         { type: 'string', default: '3600' },
-    'max-sends':     { type: 'string', default: '10' },
-    'max-tool-calls': { type: 'string', default: '30' },
-    'stall-timeout': { type: 'string', default: '60' },
-    'startup-timeout': { type: 'string', default: '180' },
-    'dead-air-timeout': { type: 'string', default: '1440' },
-    'max-nudges':    { type: 'string', default: '3' },
+    profile:        { type: 'string' },
+    budget:          { type: 'string', default: D.budget },
+    timeout:         { type: 'string', default: D.timeout },
+    'max-sends':     { type: 'string', default: D["max-sends"] },
+    'max-tool-calls': { type: 'string', default: D["max-tool-calls"] },
+    'stall-timeout': { type: 'string', default: D["stall-timeout"] },
+    'startup-timeout': { type: 'string', default: D["startup-timeout"] },
+    'dead-air-timeout': { type: 'string', default: D["dead-air-timeout"] },
+    'max-nudges':    { type: 'string', default: D["max-nudges"] },
     log:             { type: 'string' },
     'log-level':     { type: 'string', default: 'info' },
     'log-json':      { type: 'boolean', default: false },
     state:           { type: 'string' },
     metrics:         { type: 'string' },
-    cooldown:        { type: 'string', default: '5' },
+    cooldown:        { type: 'string', default: D.cooldown },
     'abort-file':    { type: 'string' },
-    'poll-interval': { type: 'string', default: '1000' },
+    'poll-interval': { type: 'string', default: D["poll-interval"] },
     restart:         { type: 'boolean', default: false },
-    'max-restarts':  { type: 'string', default: '0' },
-    'restart-delay': { type: 'string', default: '5' },
+    'max-restarts':  { type: 'string', default: D["max-restarts"] },
+    'restart-delay': { type: 'string', default: D["restart-delay"] },
+    'kill-orphaned-mcp': { type: 'boolean', default: false },
   },
 });
 
@@ -107,6 +148,7 @@ const METRICS_FILE  = opts.metrics;
 const RESTART       = opts.restart;
 const MAX_RESTARTS  = parseInt(opts['max-restarts'], 10);
 const RESTART_DELAY_S = parseFloat(opts['restart-delay']);
+const KILL_ORPHANED_MCP = opts['kill-orphaned-mcp'];
 const LOG_JSON      = opts['log-json'];
 
 // --- Invocation rate limiting (prevent tight crash loops) ---
@@ -177,6 +219,13 @@ if (LOG_FILE) {
   logStream = createWriteStream(resolve(LOG_FILE), { flags: 'a' });
 }
 
+// Format bytes/tokens in human-readable form
+function fmtSize(n) {
+  if (n >= 1000000) return `${(n/1000000).toFixed(1)}M`;
+  if (n >= 1000) return `${(n/1000).toFixed(1)}K`;
+  return String(n);
+}
+
 function log(msg, level = 'info', fields = null) {
   const numLevel = LOG_LEVELS[level] ?? LOG_LEVELS.info;
   if (numLevel < LOG_LEVEL) return;
@@ -193,10 +242,27 @@ function log(msg, level = 'info', fields = null) {
     const prefix = level === 'info' ? '' : `[${level.toUpperCase()}] `;
     const line = `[${ts}] ${prefix}${msg}`;
     if (logStream) logStream.write(line + '\n');
-    process.stderr.write(`[niki] ${line}\n`);
+
+    // For stderr: use concise format at info level, verbose at debug
+    if (level === 'debug' || LOG_LEVEL === LOG_LEVELS.debug) {
+      process.stderr.write(`[niki] ${line}\n`);
+    } else if (level === 'info') {
+      // Concise format: strip timestamp, just show the message
+      process.stderr.write(`[niki] ${msg}\n`);
+    } else {
+      // Warn/error: show full line
+      process.stderr.write(`[niki] ${line}\n`);
+    }
   }
 }
 
+// Log API traffic in human-readable format
+function logAPI(tokensIn, tokensOut) {
+  const budgetPct = ((state.tokensTotal / BUDGET) * 100).toFixed(1);
+  const msg = `[API: ${fmtSize(tokensIn)} → / ${fmtSize(tokensOut)} ←] Budget: ${fmtSize(state.tokensTotal)}/${fmtSize(BUDGET)} (${budgetPct}%)`;
+  log(msg, 'info');
+}
+
 function writeState() {
   if (!STATE_FILE) return;
   try {
@@ -263,6 +329,9 @@ const TOKEN_PATTERNS = [
 
 function parseTokens(line) {
   let changed = false;
+  const prevIn = state.tokensIn;
+  const prevOut = state.tokensOut;
+
   for (const { regex, field } of TOKEN_PATTERNS) {
     regex.lastIndex = 0;
     let match;
@@ -278,6 +347,15 @@ function parseTokens(line) {
     }
   }
   if (changed) {
+    const deltaIn = state.tokensIn - prevIn;
+    const deltaOut = state.tokensOut - prevOut;
+
+    // Human-readable API traffic log
+    if (deltaIn > 0 || deltaOut > 0) {
+      logAPI(deltaIn, deltaOut);
+    }
+
+    // Verbose log for debug mode
     log(`Tokens — in: ${state.tokensIn.toLocaleString()} out: ${state.tokensOut.toLocaleString()} total: ${state.tokensTotal.toLocaleString()}/${BUDGET.toLocaleString()} (${Math.round(state.tokensTotal / BUDGET * 100)}%)`, 'debug');
     checkBudgetThresholds();
   }
@@ -534,7 +612,7 @@ function onChildOutput() {
   }
   if (!gotFirstOutput) {
     gotFirstOutput = true;
-    log(`First output received after ${Math.round((Date.now() - new Date(state.startedAt).getTime()) / 1000)}s — switching to stall-timeout=${STALL_TIMEOUT_S}s`, 'info');
+    log(`First output received after ${Math.round((Date.now() - new Date(state.startedAt).getTime()) / 1000)}s — switching to stall-timeout=${STALL_TIMEOUT_S}s`, 'debug');
   }
   resetStallTimer();
 }
@@ -655,10 +733,23 @@ function scheduleAbortPoll() {
 let timeoutId = null;
 
 function startChild() {
-  log(`Starting: ${childCmd} ${childArgs.join(' ').substring(0, 100)}...`, 'info');
-  log(`Budget: ${BUDGET.toLocaleString()} tokens | Timeout: ${TIMEOUT_S}s | Startup: ${STARTUP_TIMEOUT_S}s | Stall: ${STALL_TIMEOUT_S}s | Dead air: ${DEAD_AIR_TIMEOUT_M}min | Max sends: ${MAX_SENDS}/min | Max tools: ${MAX_TOOL_CALLS}/min`, 'info');
+  // Concise startup message
+  const cmd = `${childCmd} ${childArgs.join(' ').substring(0, 60)}...`;
+  log(`[START] ${cmd} | Budget: ${fmtSize(BUDGET)} tokens | Timeout: ${TIMEOUT_S}s`, 'info');
+
+  // Verbose details at debug level
+  log(`Budget: ${BUDGET.toLocaleString()} tokens | Timeout: ${TIMEOUT_S}s | Startup: ${STARTUP_TIMEOUT_S}s | Stall: ${STALL_TIMEOUT_S}s | Dead air: ${DEAD_AIR_TIMEOUT_M}min | Max sends: ${MAX_SENDS}/min | Max tools: ${MAX_TOOL_CALLS}/min`, 'debug');
   if (RESTART) {
-    log(`Restart: enabled | max: ${MAX_RESTARTS || 'unlimited'} | delay: ${RESTART_DELAY_S}s ±30% | restarts so far: ${state.restarts}`, 'info');
+    log(`Restart: enabled | max: ${MAX_RESTARTS || 'unlimited'} | delay: ${RESTART_DELAY_S}s ±30% | restarts so far: ${state.restarts}`, 'debug');
+  }
+
+  // If --kill-orphaned-mcp: kill stale agentchat-mcp procs before spawning.
+  // Prevents session_displaced churn from orphaned prior-session MCP processes.
+  if (KILL_ORPHANED_MCP) {
+    try {
+      execSync('pkill -f agentchat-mcp', { stdio: 'ignore' });
+      log('Killed orphaned agentchat-mcp processes', 'debug');
+    } catch { /* pkill exits non-zero when nothing matched */ }
   }
 
   child = spawn(childCmd, childArgs, {
@@ -712,13 +803,13 @@ function startChild() {
 
   // Start stall detection
   if (STALL_TIMEOUT_S > 0 || STARTUP_TIMEOUT_S > 0) {
-    log(`Stall detection: startup-timeout=${STARTUP_TIMEOUT_S}s, stall-timeout=${STALL_TIMEOUT_S}s, max-nudges=${MAX_NUDGES}`, 'info');
+    log(`Stall detection: startup-timeout=${STARTUP_TIMEOUT_S}s, stall-timeout=${STALL_TIMEOUT_S}s, max-nudges=${MAX_NUDGES}`, 'debug');
     resetStallTimer();
   }
 
   // Start dead air detection
   if (DEAD_AIR_TIMEOUT_M > 0) {
-    log(`Dead air detection: ${DEAD_AIR_TIMEOUT_M}min threshold, ${Math.round(DEAD_AIR_POLL_MS / 1000)}s poll interval`, 'info');
+    log(`Dead air detection: ${DEAD_AIR_TIMEOUT_M}min threshold, ${Math.round(DEAD_AIR_POLL_MS / 1000)}s poll interval`, 'debug');
     scheduleDeadAirPoll();
   }
 
@@ -747,7 +838,15 @@ function startChild() {
     state.gotFirstOutput = gotFirstOutput;
 
     const level = state.killedBy ? 'error' : (code === 0 ? 'info' : 'warn');
-    log(`Exit — code: ${code} signal: ${signal} | tokens: ${state.tokensTotal.toLocaleString()} | tools: ${state.toolCalls} | sends: ${state.sendCalls} | duration: ${state.duration}s | output: ${gotFirstOutput}${state.killedBy ? ` | killed: ${state.killedBy}` : ''} | restarts: ${state.restarts}`, level);
+
+    // Concise exit message
+    const exitMsg = state.killedBy
+      ? `[EXIT] Killed: ${state.killedBy} | Tokens: ${fmtSize(state.tokensTotal)} | ${state.duration}s`
+      : `[EXIT] Code: ${code} | Tokens: ${fmtSize(state.tokensTotal)} | ${state.duration}s`;
+    log(exitMsg, level);
+
+    // Verbose details at debug level
+    log(`Exit — code: ${code} signal: ${signal} | tokens: ${state.tokensTotal.toLocaleString()} | tools: ${state.toolCalls} | sends: ${state.sendCalls} | duration: ${state.duration}s | output: ${gotFirstOutput}${state.killedBy ? ` | killed: ${state.killedBy}` : ''} | restarts: ${state.restarts}`, 'debug');
     writeState();
     writeMetrics();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/niki",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Deterministic process supervisor for AI agents — token budgets, rate limits, and abort control",
   "bin": {
     "niki": "./bin/niki"