agentxchain 0.8.6 → 0.8.8

package/src/commands/watch.js

@@ -1,11 +1,15 @@
-import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, appendFileSync, unlinkSync } from 'fs';
 import { join, dirname } from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import { loadConfig, loadLock, LOCK_FILE } from '../lib/config.js';
+import { safeWriteJson } from '../lib/safe-write.js';
 import { notifyHuman as sendNotification } from '../lib/notify.js';
 import { validateProject } from '../lib/validation.js';
+import { resolveNextAgent, resolveExpectedClaimer } from '../lib/next-owner.js';
+
+const PID_FILE = '.agentxchain-watch.pid';
 
 export async function watchCommand(opts) {
   if (opts.daemon && process.env.AGENTXCHAIN_WATCH_DAEMON !== '1') {
@@ -36,12 +40,15 @@ export async function watchCommand(opts) {
   console.log(chalk.dim(`  Poll:    ${interval}ms | TTL: ${ttlMinutes}min`));
   console.log(chalk.dim(`  Mode:    Local file watcher + trigger file`));
   console.log('');
+  writePidFile(root);
+
   console.log(chalk.cyan('  Watching lock.json... (Ctrl+C to stop)'));
   console.log(chalk.dim('  Note: In VS Code/Cursor, the Stop hook coordinates turns automatically.'));
   console.log(chalk.dim('  This watch process is a fallback for non-IDE environments.'));
   console.log('');
 
   let lastState = null;
+  let lastClaimedState = null;
 
   const tick = async () => {
     try {
@@ -50,17 +57,6 @@ export async function watchCommand(opts) {
 
       const stateKey = `${lock.holder}:${lock.turn_number}`;
 
-      if (lock.holder && lock.holder !== 'human') {
-        const expected = pickNextAgent(lock, config);
-        if (!isValidClaimer(lock, config)) {
-          log('warn', `Illegal claim detected: holder=${lock.holder}, expected=${expected}. Handing lock to HUMAN.`);
-          blockOnIllegalClaim(root, lock, config, expected);
-          sendNotification(`Illegal claim detected (${lock.holder}). Human intervention required.`);
-          lastState = null;
-          return;
-        }
-      }
-
       if (lock.holder && lock.holder !== 'human' && lock.claimed_at) {
         const elapsed = Date.now() - new Date(lock.claimed_at).getTime();
         const ttlMs = ttlMinutes * 60 * 1000;
@@ -85,11 +81,27 @@ export async function watchCommand(opts) {
       }
 
       if (lock.holder) {
+        // Validate claim ownership only once per new claimed state.
+        // With handoff-driven routing, TALK.md may change during an active turn.
+        // Re-validating every tick can produce false "illegal claim" alerts.
+        if (stateKey !== lastClaimedState && lock.holder !== 'human') {
+          const expected = pickNextAgent(root, lock, config);
+          if (!isValidClaimer(root, lock, config)) {
+            log('warn', `Illegal claim detected: holder=${lock.holder}, expected=${expected ?? 'none'}. Handing lock to HUMAN.`);
+            blockOnIllegalClaim(root, lock, config, expected);
+            sendNotification(`Illegal claim detected (${lock.holder}). Human intervention required.`);
+            lastState = null;
+            lastClaimedState = null;
+            return;
+          }
+        }
+
         if (stateKey !== lastState) {
           const name = config.agents[lock.holder]?.name || lock.holder;
           log('claimed', `${lock.holder} (${name}) working... (turn ${lock.turn_number})`);
           lastState = stateKey;
         }
+        lastClaimedState = stateKey;
         return;
       }
 
@@ -108,7 +120,15 @@ export async function watchCommand(opts) {
           }
         }
 
-        const next = pickNextAgent(lock, config);
+        const resolved = resolveNextAgent(root, config, lock);
+        const next = resolved.next;
+        if (!next) {
+          log('warn', `No next owner (${resolved.source}). strict_next_owner requires TALK.md handoff. Handing lock to HUMAN.`);
+          blockOnMissingNext(root, lock, config, resolved.source);
+          sendNotification('No next owner in TALK.md. Human action required.');
+          lastState = null;
+          return;
+        }
         log('free', `Lock free (released by ${lock.last_released_by || 'none'}). Next: ${chalk.bold(next)}.`);
         writeTrigger(root, next, lock, config);
         lastState = stateKey;
@@ -121,29 +141,26 @@ export async function watchCommand(opts) {
   await tick();
   const timer = setInterval(tick, interval);
 
-  process.on('SIGINT', () => {
+  const cleanup = () => {
     clearInterval(timer);
+    removePidFile(root);
     console.log('');
     log('stop', 'Watch stopped.');
     process.exit(0);
-  });
-}
-
-function pickNextAgent(lock, config) {
-  const agentIds = Object.keys(config.agents);
-  if (agentIds.length === 0) return null;
-  const lastAgent = lock.last_released_by;
+  };
 
-  if (!lastAgent || !agentIds.includes(lastAgent)) return agentIds[0];
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}
 
-  const lastIndex = agentIds.indexOf(lastAgent);
-  return agentIds[(lastIndex + 1) % agentIds.length];
+function pickNextAgent(root, lock, config) {
+  return resolveNextAgent(root, config, lock).next;
 }
 
-function isValidClaimer(lock, config) {
+function isValidClaimer(root, lock, config) {
   if (!lock.holder || lock.holder === 'human') return true;
   if (!config.agents?.[lock.holder]) return false;
-  const expected = pickNextAgent(lock, config);
+  const expected = resolveExpectedClaimer(root, config, lock).next;
   return lock.holder === expected;
 }
 
@@ -152,10 +169,10 @@ function forceRelease(root, lock, staleAgent, config) {
   const newLock = {
     holder: null,
     last_released_by: `system:ttl:${staleAgent}`,
-    turn_number: lock.turn_number,
+    turn_number: lock.turn_number + 1,
     claimed_at: null
   };
-  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+  safeWriteJson(lockPath, newLock);
 
   const logFile = config.log || 'log.md';
   const logPath = join(root, logFile);
@@ -167,12 +184,12 @@ function forceRelease(root, lock, staleAgent, config) {
 function writeTrigger(root, agentId, lock, config) {
   if (!agentId) return;
   const triggerPath = join(root, '.agentxchain-trigger.json');
-  writeFileSync(triggerPath, JSON.stringify({
+  safeWriteJson(triggerPath, {
     agent: agentId,
     turn_number: lock.turn_number,
     triggered_at: new Date().toISOString(),
     project: config.project
-  }, null, 2) + '\n');
+  });
 }
 
 function blockOnValidation(root, lock, config, validation) {
@@ -183,7 +200,7 @@ function blockOnValidation(root, lock, config, validation) {
     turn_number: lock.turn_number,
     claimed_at: new Date().toISOString()
   };
-  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+  safeWriteJson(lockPath, newLock);
 
   const statePath = join(root, 'state.json');
   if (existsSync(statePath)) {
@@ -195,7 +212,7 @@ function blockOnValidation(root, lock, config, validation) {
         blocked: true,
         blocked_on: `validation: ${message}`
       };
-      writeFileSync(statePath, JSON.stringify(nextState, null, 2) + '\n');
+      safeWriteJson(statePath, nextState);
     } catch {}
   }
 
@@ -210,6 +227,39 @@ function blockOnValidation(root, lock, config, validation) {
   }
 }
 
+function blockOnMissingNext(root, lock, config, source) {
+  const lockPath = join(root, LOCK_FILE);
+  const newLock = {
+    holder: 'human',
+    last_released_by: lock.last_released_by,
+    turn_number: lock.turn_number,
+    claimed_at: new Date().toISOString()
+  };
+  safeWriteJson(lockPath, newLock);
+
+  const statePath = join(root, 'state.json');
+  if (existsSync(statePath)) {
+    try {
+      const current = JSON.parse(readFileSync(statePath, 'utf8'));
+      const nextState = {
+        ...current,
+        blocked: true,
+        blocked_on: `missing-next-owner: ${source}`
+      };
+      safeWriteJson(statePath, nextState);
+    } catch {}
+  }
+
+  const logFile = config.log || 'log.md';
+  const logPath = join(root, logFile);
+  if (existsSync(logPath)) {
+    appendFileSync(
+      logPath,
+      `\n---\n\n### [system] (Watch) | Turn ${lock.turn_number}\n\n**Status:** Could not resolve next agent (${source}).\n\n**Action:** Add \`Next owner: <agent_id>\` to ${config.talk_file || 'TALK.md'}, or set \`rules.strict_next_owner\` to false for cyclic fallback.\n\n`
+    );
+  }
+}
+
 function blockOnIllegalClaim(root, lock, config, expected) {
   const lockPath = join(root, LOCK_FILE);
   const newLock = {
@@ -218,7 +268,7 @@ function blockOnIllegalClaim(root, lock, config, expected) {
     turn_number: lock.turn_number,
     claimed_at: new Date().toISOString()
   };
-  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+  safeWriteJson(lockPath, newLock);
 
   const statePath = join(root, 'state.json');
   if (existsSync(statePath)) {
@@ -229,7 +279,7 @@ function blockOnIllegalClaim(root, lock, config, expected) {
         blocked: true,
         blocked_on: `illegal-claim: expected ${expected}, got ${lock.holder}`
       };
-      writeFileSync(statePath, JSON.stringify(nextState, null, 2) + '\n');
+      safeWriteJson(statePath, nextState);
     } catch {}
   }
 
@@ -268,8 +318,39 @@ function startWatchDaemon() {
   });
   child.unref();
 
+  const result = loadConfig();
+  if (result) {
+    writeFileSync(join(result.root, PID_FILE), String(child.pid));
+  }
+
   console.log('');
   console.log(chalk.green(`  ✓ Watch started in daemon mode (PID: ${child.pid})`));
   console.log(chalk.dim('  Use `agentxchain stop` or kill the PID to stop it.'));
   console.log('');
 }
+
+function writePidFile(root) {
+  try {
+    writeFileSync(join(root, PID_FILE), String(process.pid));
+  } catch {}
+}
+
+function removePidFile(root) {
+  try {
+    const pidPath = join(root, PID_FILE);
+    if (existsSync(pidPath)) unlinkSync(pidPath);
+  } catch {}
+}
+
+export function getWatchPid(root) {
+  try {
+    const pidPath = join(root, PID_FILE);
+    if (!existsSync(pidPath)) return null;
+    const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+    if (!Number.isFinite(pid)) return null;
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    return null;
+  }
+}

package/src/lib/config.js

@@ -1,36 +1,71 @@
 import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, parse as pathParse, resolve } from 'path';
+import { safeParseJson, validateConfigSchema, validateLockSchema, validateStateSchema } from './schema.js';
 
 const CONFIG_FILE = 'agentxchain.json';
 const LOCK_FILE = 'lock.json';
 const STATE_FILE = 'state.json';
 
 export function findProjectRoot(startDir = process.cwd()) {
-  let dir = startDir;
-  while (dir !== '/') {
+  let dir = resolve(startDir);
+  const { root: fsRoot } = pathParse(dir);
+  while (true) {
     if (existsSync(join(dir, CONFIG_FILE))) return dir;
+    if (dir === fsRoot) return null;
     dir = join(dir, '..');
   }
-  return null;
 }
 
 export function loadConfig(dir = process.cwd()) {
   const root = findProjectRoot(dir);
   if (!root) return null;
-  const raw = readFileSync(join(root, CONFIG_FILE), 'utf8');
-  return { root, config: JSON.parse(raw) };
+  const filePath = join(root, CONFIG_FILE);
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  const result = safeParseJson(raw, validateConfigSchema);
+  if (!result.ok) {
+    console.error(`  Warning: agentxchain.json has issues: ${result.errors.join(', ')}`);
+    return null;
+  }
+  return { root, config: result.data };
 }
 
 export function loadLock(root) {
-  const path = join(root, LOCK_FILE);
-  if (!existsSync(path)) return null;
-  return JSON.parse(readFileSync(path, 'utf8'));
+  const filePath = join(root, LOCK_FILE);
+  if (!existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  const result = safeParseJson(raw, validateLockSchema);
+  if (!result.ok) {
+    console.error(`  Warning: lock.json has issues: ${result.errors.join(', ')}`);
+    return null;
+  }
+  return result.data;
 }
 
 export function loadState(root) {
-  const path = join(root, STATE_FILE);
-  if (!existsSync(path)) return null;
-  return JSON.parse(readFileSync(path, 'utf8'));
+  const filePath = join(root, STATE_FILE);
+  if (!existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  const result = safeParseJson(raw, validateStateSchema);
+  if (!result.ok) {
+    console.error(`  Warning: state.json has issues: ${result.errors.join(', ')}`);
+    return null;
+  }
+  return result.data;
 }
 
 export { CONFIG_FILE, LOCK_FILE, STATE_FILE };

package/src/lib/filter-agents.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+
+export function filterAgents(config, specificId) {
+  if (specificId) {
+    if (!config.agents[specificId]) {
+      console.log(chalk.red(`  Agent "${specificId}" not found in agentxchain.json`));
+      process.exit(1);
+    }
+    return { [specificId]: config.agents[specificId] };
+  }
+  return config.agents;
+}

package/src/lib/generate-vscode.js

@@ -20,11 +20,13 @@ export function generateVSCodeFiles(dir, config) {
   }
 
   writeFileSync(join(hooksDir, 'agentxchain.json'), buildHooksJson());
+  writeFileSync(join(scriptsDir, 'agentxchain-hook-runtime.cjs'), buildHookRuntimeScript());
   writeFileSync(join(scriptsDir, 'agentxchain-session-start.sh'), SESSION_START_SCRIPT);
-  writeFileSync(join(scriptsDir, 'agentxchain-stop.sh'), buildStopScript(config));
+  writeFileSync(join(scriptsDir, 'agentxchain-stop.sh'), buildStopScript());
   writeFileSync(join(scriptsDir, 'agentxchain-pre-tool.sh'), PRE_TOOL_SCRIPT);
 
   try {
+    chmodSync(join(scriptsDir, 'agentxchain-hook-runtime.cjs'), 0o755);
     chmodSync(join(scriptsDir, 'agentxchain-session-start.sh'), 0o755);
     chmodSync(join(scriptsDir, 'agentxchain-stop.sh'), 0o755);
     chmodSync(join(scriptsDir, 'agentxchain-pre-tool.sh'), 0o755);
@@ -188,23 +190,150 @@ function buildHooksJson() {
   return JSON.stringify(hooks, null, 2) + '\n';
 }
 
-function buildStopScript(config) {
-  const verifyCmd = config.rules?.verify_command || '';
-  const verifyBlock = verifyCmd
-    ? `
-# Run verify command before allowing release
-if [ -z "$HOLDER" ] || [ "$HOLDER" = "null" ]; then
-  VERIFY_CMD="${verifyCmd}"
-  if [ -n "$VERIFY_CMD" ]; then
-    if ! eval "$VERIFY_CMD" > /dev/null 2>&1; then
-      echo '{"hookSpecificOutput":{"hookEventName":"Stop","decision":"block","reason":"Verification failed: '"$VERIFY_CMD"'. Fix the issue and release the lock."}}'
-      exit 0
-    fi
-  fi
-fi
-`
-    : '';
+function buildHookRuntimeScript() {
+  return `#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(process.cwd(), file), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function splitCommand(input) {
+  const out = [];
+  let current = '';
+  let quote = null;
+  let escape = false;
+  for (const char of String(input || '')) {
+    if (escape) {
+      current += char;
+      escape = false;
+      continue;
+    }
+    if (char === '\\\\') {
+      escape = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\\s/.test(char)) {
+      if (current) {
+        out.push(current);
+        current = '';
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) out.push(current);
+  return out;
+}
+
+function normalizeVerifyCommand(config) {
+  const raw = config?.rules?.verify_command;
+  if (Array.isArray(raw) && raw.every(part => typeof part === 'string' && part.length > 0)) {
+    return raw;
+  }
+  if (typeof raw !== 'string' || !raw.trim()) return null;
+  return splitCommand(raw.trim());
+}
+
+function normalizeAgentId(raw) {
+  if (!raw) return null;
+  let value = String(raw).trim();
+  value = value.replace(/[\`*_]/g, '').trim();
+  value = value.replace(/\\(.*?\\)/g, '').trim();
+  value = value.split(/[\\s,]+/)[0];
+  value = value.toLowerCase();
+  return /^[a-z0-9_-]+$/.test(value) ? value : null;
+}
+
+function parseNextOwnerFromTalk(talkPath, validAgentIds) {
+  try {
+    const text = fs.readFileSync(path.join(process.cwd(), talkPath), 'utf8');
+    const lines = text.split(/\\r?\\n/);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i].trim();
+      const match = line.match(/^(?:-|\\*)?\\s*\\**next\\s*owner\\**\\s*:\\s*(.+)$/i);
+      if (!match) continue;
+      const candidate = normalizeAgentId(match[1]);
+      if (candidate && validAgentIds.includes(candidate)) return candidate;
+    }
+  } catch {}
+  return null;
+}
+
+function resolveNextAgent(config, lock) {
+  const agentIds = Object.keys(config?.agents || {});
+  if (agentIds.length === 0) return null;
+  const talkFile = config?.talk_file || 'TALK.md';
+  const fromTalk = parseNextOwnerFromTalk(talkFile, agentIds);
+  if (fromTalk) return fromTalk;
+  const last = lock?.last_released_by;
+  if (last && agentIds.includes(last)) {
+    const idx = agentIds.indexOf(last);
+    return agentIds[(idx + 1) % agentIds.length];
+  }
+  return agentIds[0];
+}
+
+function outputJson(value) {
+  process.stdout.write(JSON.stringify(value));
+}
+
+const command = process.argv[2];
+const config = readJson('agentxchain.json');
+const lock = readJson('lock.json');
+const state = readJson('state.json');
+
+if (command === 'verify') {
+  const verifyArgs = normalizeVerifyCommand(config);
+  if (!verifyArgs || verifyArgs.length === 0) process.exit(0);
+  const result = spawnSync(verifyArgs[0], verifyArgs.slice(1), { stdio: 'ignore', cwd: process.cwd() });
+  process.exit(result.status === 0 ? 0 : 2);
+}
+
+if (command === 'next') {
+  process.stdout.write(resolveNextAgent(config, lock) || '');
+  process.exit(0);
+}
+
+if (command === 'next-name') {
+  const next = resolveNextAgent(config, lock);
+  process.stdout.write(next ? (config?.agents?.[next]?.name || next) : '');
+  process.exit(0);
+}
+
+if (command === 'session-start') {
+  if (!lock || !state) {
+    outputJson({ continue: true });
+    process.exit(0);
+  }
+  const context = \`AgentXchain context: Project=\${state.project || 'unknown'} | Phase=\${state.phase || 'unknown'} | Turn=\${lock.turn_number ?? 0} | Lock=\${lock.holder ?? 'none'} | Last released by=\${lock.last_released_by ?? 'none'} | Blocked=\${state.blocked ?? false}\`;
+  outputJson({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: context } });
+  process.exit(0);
+}
+
+outputJson({ continue: true });
+`;
+}
 
+function buildStopScript() {
   return `#!/bin/bash
 INPUT=$(cat)
 STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
@@ -222,34 +351,28 @@ fi
 LOCK=$(cat lock.json 2>/dev/null)
 HOLDER=$(echo "$LOCK" | jq -r '.holder // empty')
 TURN=$(echo "$LOCK" | jq -r '.turn_number // 0')
-${verifyBlock}
 if [ -z "$HOLDER" ] || [ "$HOLDER" = "null" ]; then
-  LAST=$(echo "$LOCK" | jq -r '.last_released_by // empty')
+  node "./scripts/agentxchain-hook-runtime.cjs" verify >/dev/null 2>&1
+  VERIFY_STATUS=$?
+  if [ "$VERIFY_STATUS" -eq 2 ]; then
+    echo '{"hookSpecificOutput":{"hookEventName":"Stop","decision":"block","reason":"Verification failed. Fix the issue and release the lock."}}'
+    exit 0
+  fi
+fi
 
+if [ -z "$HOLDER" ] || [ "$HOLDER" = "null" ]; then
   if [ ! -f "agentxchain.json" ]; then
     echo '{"continue":true}'
     exit 0
   fi
 
-  NEXT=$(node -e "
-    const cfg = JSON.parse(require('fs').readFileSync('agentxchain.json','utf8'));
-    const ids = Object.keys(cfg.agents);
-    const last = process.argv[1] || '';
-    const idx = ids.indexOf(last);
-    const next = ids[(idx + 1) % ids.length];
-    process.stdout.write(next);
-  " -- "$LAST" 2>/dev/null)
-
+  NEXT=$(node "./scripts/agentxchain-hook-runtime.cjs" next 2>/dev/null)
   if [ -z "$NEXT" ]; then
     echo '{"continue":true}'
     exit 0
   fi
 
-  NEXT_NAME=$(node -e "
-    const cfg = JSON.parse(require('fs').readFileSync('agentxchain.json','utf8'));
-    const a = cfg.agents[process.argv[1]];
-    process.stdout.write(a ? a.name : process.argv[1]);
-  " -- "$NEXT" 2>/dev/null)
+  NEXT_NAME=$(node "./scripts/agentxchain-hook-runtime.cjs" next-name 2>/dev/null)
 
   echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"Stop\\",\\"decision\\":\\"block\\",\\"reason\\":\\"Turn $TURN complete. Next agent: $NEXT ($NEXT_NAME). Read lock.json, claim it, and do your work.\\"}}"
 elif [ "$HOLDER" = "human" ]; then
@@ -261,24 +384,8 @@ fi
 }
 
 const SESSION_START_SCRIPT = `#!/bin/bash
-if [ ! -f "lock.json" ] || [ ! -f "state.json" ]; then
-  echo '{"continue":true}'
-  exit 0
-fi
-
-LOCK=$(cat lock.json 2>/dev/null)
-STATE=$(cat state.json 2>/dev/null)
-
-HOLDER=$(echo "$LOCK" | jq -r '.holder // "none"')
-TURN=$(echo "$LOCK" | jq -r '.turn_number // 0')
-LAST=$(echo "$LOCK" | jq -r '.last_released_by // "none"')
-PHASE=$(echo "$STATE" | jq -r '.phase // "unknown"')
-BLOCKED=$(echo "$STATE" | jq -r '.blocked // false')
-PROJECT=$(echo "$STATE" | jq -r '.project // "unknown"')
-
-CONTEXT="AgentXchain context: Project=$PROJECT | Phase=$PHASE | Turn=$TURN | Lock=$HOLDER | Last released by=$LAST | Blocked=$BLOCKED"
-
-echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"SessionStart\\",\\"additionalContext\\":\\"$CONTEXT\\"}}"
+CONTEXT_JSON=$(node "./scripts/agentxchain-hook-runtime.cjs" session-start 2>/dev/null || echo '{"continue":true}')
+printf '%s\n' "$CONTEXT_JSON"
 `;
 
 const PRE_TOOL_SCRIPT = `#!/bin/bash