@tjamescouch/niki 0.5.5 → 0.5.7

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,11 +54,17 @@ 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)
+  --on-kill <command>     Run shell command when agent is killed (receives context via env vars)
+                          Env vars: NIKI_KILL_REASON, NIKI_TOKENS, NIKI_BUDGET, NIKI_DURATION,
+                          NIKI_SENDS, NIKI_TOOL_CALLS, NIKI_PID, NIKI_CMD
 
 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"`);
+  niki --restart --max-restarts 10 -- gro --model gpt-5.2 "your prompt"
+  niki --on-kill 'curl -d "$NIKI_KILL_REASON: $NIKI_TOKENS tokens" ntfy.sh/my-agents' -- claude -p "..."`);
   process.exit(1);
 }
 
@@ -65,28 +72,67 @@ 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 },
+    'on-kill':           { type: 'string' },
   },
 });
 
@@ -107,6 +153,8 @@ 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 ON_KILL       = opts['on-kill'];
 const LOG_JSON      = opts['log-json'];
 
 // --- Invocation rate limiting (prevent tight crash loops) ---
@@ -375,6 +423,35 @@ function checkRateLimits() {
   }
   return null;
 }
+// --- Kill notification hook ---
+
+function fireOnKill(reason) {
+  if (!ON_KILL) return;
+  const duration = Math.round((Date.now() - new Date(state.startedAt).getTime()) / 1000);
+  const env = {
+    ...process.env,
+    NIKI_KILL_REASON: reason,
+    NIKI_TOKENS: String(state.tokensTotal),
+    NIKI_BUDGET: String(BUDGET),
+    NIKI_DURATION: String(duration),
+    NIKI_SENDS: String(state.sendCalls),
+    NIKI_TOOL_CALLS: String(state.toolCalls),
+    NIKI_PID: String(state.pid),
+    NIKI_CMD: childCmd,
+  };
+  try {
+    const hook = spawn('sh', ['-c', ON_KILL], {
+      env,
+      stdio: 'ignore',
+      detached: true,
+    });
+    hook.unref();
+    log(`on-kill hook fired: ${ON_KILL}`, 'debug');
+  } catch (err) {
+    log(`on-kill hook failed: ${err.message}`, 'warn');
+  }
+}
+
 // --- Kill logic ---
 
 let child = null;
@@ -401,6 +478,8 @@ function killChild(reason) {
   }
   log(`KILL — reason: ${reason} | tokens: ${state.tokensTotal}/${BUDGET} | sends: ${state.sendCallsThisMinute}/min | tools: ${state.toolCallsThisMinute}/min`, 'error');
 
+  fireOnKill(reason);
+
   child.kill('SIGTERM');
 
   // Grace period, then SIGKILL
@@ -701,6 +780,15 @@ function startChild() {
     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, {
     stdio: ['pipe', 'pipe', 'pipe'],
     env: process.env,

package/package.json

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