agentxchain 2.129.0 → 2.130.1

package/src/lib/run-loop.js

@@ -396,6 +396,16 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
 
       acceptedCount++;
       history.push({ role: roleId, turn_id: turn.turn_id, accepted: true });
+      if (callbacks.afterAccept) {
+        const afterAcceptResult = await callbacks.afterAccept({ turn, acceptResult });
+        if (afterAcceptResult?.ok === false) {
+          errors.push(`afterAccept(${roleId}): ${afterAcceptResult.error}`);
+          if (afterAcceptResult.state) {
+            emit({ type: 'blocked', state: afterAcceptResult.state, reason: 'after_accept_failed' });
+          }
+          return { terminal: true, ok: false, stop_reason: 'blocked', history, acceptedCount };
+        }
+      }
       emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
     } else {
       const validationResult = {
@@ -512,6 +522,16 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
     }
 
     history.push({ role: roleId, turn_id: turn.turn_id, accepted: true });
+    if (callbacks.afterAccept) {
+      const afterAcceptResult = await callbacks.afterAccept({ turn, acceptResult });
+      if (afterAcceptResult?.ok === false) {
+        errors.push(`afterAccept(${roleId}): ${afterAcceptResult.error}`);
+        if (afterAcceptResult.state) {
+          emit({ type: 'blocked', state: afterAcceptResult.state, reason: 'after_accept_failed' });
+        }
+        return { terminal: true, ok: false, stop_reason: 'blocked', history };
+      }
+    }
     emit({ type: 'turn_accepted', turn, role: roleId, state: acceptResult.state });
     return { terminal: false, accepted: true, history };
   }

package/src/lib/runtime-spawn-context.js

@@ -0,0 +1,163 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const DEFAULT_PROBE_TIMEOUT_MS = 500;
+const PROMPT_PLACEHOLDER = 'AgentXchain spawn-context probe';
+
+function resolveLocalCliPromptTransport(runtime) {
+  const valid = new Set(['argv', 'stdin', 'dispatch_bundle_only']);
+  if (valid.has(runtime?.prompt_transport)) {
+    return runtime.prompt_transport;
+  }
+
+  const parts = Array.isArray(runtime?.command)
+    ? runtime.command
+    : [runtime?.command, ...(Array.isArray(runtime?.args) ? runtime.args : [])];
+  const hasPrompt = parts.some((part) => typeof part === 'string' && part.includes('{prompt}'));
+  return hasPrompt ? 'argv' : 'dispatch_bundle_only';
+}
+
+function resolveLocalCliInvocation(runtime) {
+  if (!runtime?.command) {
+    return { command: null, args: [] };
+  }
+
+  const transport = resolveLocalCliPromptTransport(runtime);
+
+  if (Array.isArray(runtime.command)) {
+    const first = runtime.command[0] || '';
+    const headParts = typeof first === 'string' && first.includes(' ') ? first.split(/\s+/) : [first];
+    const [command, ...headArgs] = headParts;
+    const rest = [...headArgs, ...runtime.command.slice(1)];
+    const args = transport === 'argv'
+      ? rest.map((arg) => arg === '{prompt}' ? PROMPT_PLACEHOLDER : arg)
+      : rest.filter((arg) => arg !== '{prompt}');
+    return { command, args };
+  }
+
+  const args = transport === 'argv'
+    ? (runtime.args || []).map((arg) => arg === '{prompt}' ? PROMPT_PLACEHOLDER : arg)
+    : (runtime.args || []).filter((arg) => arg !== '{prompt}');
+  return { command: runtime.command, args };
+}
+
+function resolveMcpInvocation(runtime) {
+  if (!runtime?.command) {
+    return { command: null, args: [] };
+  }
+
+  if (Array.isArray(runtime.command)) {
+    const [command, ...args] = runtime.command;
+    return { command, args };
+  }
+
+  return {
+    command: runtime.command,
+    args: Array.isArray(runtime.args) ? runtime.args : [],
+  };
+}
+
+function resolveInvocation(runtime) {
+  if (runtime?.type === 'local_cli') {
+    return resolveLocalCliInvocation(runtime);
+  }
+  return resolveMcpInvocation(runtime);
+}
+
+function buildResolutionFix(command) {
+  const commandValue = String(command || '');
+  const commandBase = basename(commandValue);
+
+  if (commandBase === 'codex' || commandBase === 'codex.exe') {
+    return 'Set "command" to the absolute path, e.g. "/Applications/Codex.app/Contents/Resources/codex", or add Codex to PATH in the dispatch spawn context.';
+  }
+  if (commandValue.includes('~')) {
+    return 'Expand "~" to an absolute path in "command". Shell expansion does not apply to governed dispatch.';
+  }
+  return 'Set "command" to an absolute path or add it to PATH in the dispatch spawn context.';
+}
+
+export function probeRuntimeSpawnContext(root, runtime, options = {}) {
+  const runtimeId = options.runtimeId || null;
+  const cwd = runtime?.cwd ? join(root, runtime.cwd) : root;
+  const { command, args } = resolveInvocation(runtime);
+
+  if (!command) {
+    return {
+      ok: false,
+      runtime_id: runtimeId,
+      command: null,
+      cwd,
+      detail: 'No command configured for the dispatch spawn context.',
+    };
+  }
+
+  if (!existsSync(cwd)) {
+    return {
+      ok: false,
+      runtime_id: runtimeId,
+      command,
+      cwd,
+      detail: `Runtime cwd "${runtime.cwd}" does not exist in the dispatch spawn context.`,
+    };
+  }
+
+  const probe = spawnSync(command, args, {
+    cwd,
+    env: { ...process.env, AGENTXCHAIN_SPAWN_PROBE: '1' },
+    stdio: 'ignore',
+    timeout: options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS,
+    windowsHide: true,
+  });
+
+  if (probe.error) {
+    const errorCode = probe.error.code || 'spawn_error';
+    if (errorCode === 'ETIMEDOUT') {
+      return {
+        ok: true,
+        runtime_id: runtimeId,
+        command,
+        cwd,
+        timed_out: true,
+        detail: `"${command}" launched in the dispatch spawn context but exceeded the short probe timeout. Treating this as resolvable.`,
+      };
+    }
+    if (errorCode === 'ENOENT') {
+      return {
+        ok: false,
+        runtime_id: runtimeId,
+        command,
+        cwd,
+        error_code: errorCode,
+        detail: `"${command}" is not resolvable in the dispatch spawn context. ${buildResolutionFix(command)}`,
+      };
+    }
+    if (errorCode === 'EACCES') {
+      return {
+        ok: false,
+        runtime_id: runtimeId,
+        command,
+        cwd,
+        error_code: errorCode,
+        detail: `"${command}" exists but is not executable in the dispatch spawn context. Mark it executable or point "command" at the real executable path.`,
+      };
+    }
+    return {
+      ok: false,
+      runtime_id: runtimeId,
+      command,
+      cwd,
+      error_code: errorCode,
+      detail: `Dispatch spawn probe failed for "${command}": ${probe.error.message}`,
+    };
+  }
+
+  return {
+    ok: true,
+    runtime_id: runtimeId,
+    command,
+    cwd,
+    detail: `"${command}" is resolvable in the dispatch spawn context.`,
+  };
+}

package/src/lib/turn-checkpoint.js

@@ -0,0 +1,221 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveAcceptedTurnHistoryReference } from './accepted-turn-history.js';
+import { emitRunEvent } from './run-events.js';
+import { safeWriteJson } from './safe-write.js';
+
+const STATE_PATH = '.agentxchain/state.json';
+const HISTORY_PATH = '.agentxchain/history.jsonl';
+
+function readState(root) {
+  const filePath = join(root, STATE_PATH);
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeState(root, state) {
+  safeWriteJson(join(root, STATE_PATH), state);
+}
+
+function readHistoryEntries(root) {
+  const filePath = join(root, HISTORY_PATH);
+  if (!existsSync(filePath)) return [];
+  const raw = readFileSync(filePath, 'utf8').trim();
+  if (!raw) return [];
+  return raw.split('\n').filter(Boolean).map((line) => JSON.parse(line));
+}
+
+function writeHistoryEntries(root, entries) {
+  const filePath = join(root, HISTORY_PATH);
+  const content = entries.map((entry) => JSON.stringify(entry)).join('\n');
+  writeFileSync(filePath, content ? `${content}\n` : '');
+}
+
+function git(root, args) {
+  return execFileSync('git', args, {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function isGitRepo(root) {
+  try {
+    return git(root, ['rev-parse', '--is-inside-work-tree']) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function normalizeFilesChanged(filesChanged) {
+  return [...new Set(
+    (Array.isArray(filesChanged) ? filesChanged : [])
+      .filter((value) => typeof value === 'string')
+      .map((value) => value.trim())
+      .filter(Boolean),
+  )];
+}
+
+function extractGitError(err) {
+  const stderr = typeof err?.stderr === 'string' ? err.stderr.trim() : '';
+  const stdout = typeof err?.stdout === 'string' ? err.stdout.trim() : '';
+  return stderr || stdout || err?.message || 'git command failed';
+}
+
+function buildCheckpointCommit(entry) {
+  const subject = `checkpoint: ${entry.turn_id} (role=${entry.role}, phase=${entry.phase})`;
+  const bodyLines = [
+    `Summary: ${entry.summary || '(none)'}`,
+    `Turn-ID: ${entry.turn_id}`,
+    `Role: ${entry.role || '(unknown)'}`,
+    `Phase: ${entry.phase || '(unknown)'}`,
+    `Runtime: ${entry.runtime_id || '(unknown)'}`,
+  ];
+  if (entry.intent_id) bodyLines.push(`Intent-ID: ${entry.intent_id}`);
+  if (entry.accepted_at) bodyLines.push(`Accepted-At: ${entry.accepted_at}`);
+  return { subject, body: bodyLines.join('\n') };
+}
+
+export function detectPendingCheckpoint(root, dirtyFiles = []) {
+  const actorDirtyFiles = normalizeFilesChanged(dirtyFiles);
+  if (actorDirtyFiles.length === 0) return { required: false };
+
+  const resolved = resolveAcceptedTurnHistoryReference(root, null);
+  if (!resolved.ok || !resolved.entry) return { required: false };
+
+  const entry = resolved.entry;
+  if (entry.checkpoint_sha) return { required: false };
+
+  const turnFiles = normalizeFilesChanged(entry.files_changed);
+  if (turnFiles.length === 0) return { required: false };
+
+  const dirtyOutsideTurn = actorDirtyFiles.filter((file) => !turnFiles.includes(file));
+  if (dirtyOutsideTurn.length > 0) return { required: false };
+
+  return {
+    required: true,
+    turn_id: entry.turn_id,
+    message: `Accepted turn ${entry.turn_id} is not checkpointed yet. Run agentxchain checkpoint-turn --turn ${entry.turn_id} before assigning the next code-writing turn.`,
+  };
+}
+
+export function checkpointAcceptedTurn(root, opts = {}) {
+  if (!isGitRepo(root)) {
+    return { ok: false, error: 'checkpoint-turn requires a git repository.' };
+  }
+
+  const resolved = resolveAcceptedTurnHistoryReference(root, opts.turnId || opts.turn || null);
+  if (!resolved.ok || !resolved.entry) {
+    return { ok: false, error: resolved.error || 'Accepted turn not found.' };
+  }
+
+  const entry = resolved.entry;
+  if (entry.checkpoint_sha) {
+    return {
+      ok: true,
+      already_checkpointed: true,
+      turn: entry,
+      checkpoint_sha: entry.checkpoint_sha,
+    };
+  }
+
+  const filesChanged = normalizeFilesChanged(entry.files_changed);
+  if (filesChanged.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      turn: entry,
+      reason: 'Accepted turn has no writable files_changed paths to checkpoint.',
+    };
+  }
+
+  try {
+    git(root, ['add', '-A', '--', ...filesChanged]);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Failed to stage accepted files for checkpoint: ${extractGitError(err)}`,
+    };
+  }
+
+  let staged = [];
+  try {
+    staged = git(root, ['diff', '--cached', '--name-only', '--', ...filesChanged])
+      .split('\n')
+      .map((value) => value.trim())
+      .filter(Boolean);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Failed to inspect staged checkpoint diff: ${extractGitError(err)}`,
+    };
+  }
+
+  if (staged.length === 0) {
+    return {
+      ok: true,
+      skipped: true,
+      turn: entry,
+      reason: `Accepted turn ${entry.turn_id} has no staged repo changes to checkpoint.`,
+    };
+  }
+
+  const commit = buildCheckpointCommit(entry);
+  try {
+    git(root, ['commit', '-m', commit.subject, '-m', commit.body]);
+  } catch (err) {
+    return {
+      ok: false,
+      turn: entry,
+      error: `Checkpoint commit failed: ${extractGitError(err)}`,
+    };
+  }
+
+  const checkpointSha = git(root, ['rev-parse', 'HEAD']);
+  const checkpointedAt = new Date().toISOString();
+
+  const historyEntries = readHistoryEntries(root).map((historyEntry) => (
+    historyEntry.turn_id === entry.turn_id
+      ? { ...historyEntry, checkpoint_sha: checkpointSha, checkpointed_at: checkpointedAt }
+      : historyEntry
+  ));
+  writeHistoryEntries(root, historyEntries);
+
+  const state = readState(root);
+  if (state) {
+    writeState(root, {
+      ...state,
+      last_completed_turn: {
+        turn_id: entry.turn_id,
+        role: entry.role || null,
+        phase: entry.phase || null,
+        checkpoint_sha: checkpointSha,
+        checkpointed_at: checkpointedAt,
+        intent_id: entry.intent_id || null,
+      },
+    });
+
+    emitRunEvent(root, 'turn_checkpointed', {
+      run_id: state.run_id || null,
+      phase: state.phase || null,
+      status: state.status || null,
+      turn: { turn_id: entry.turn_id, role_id: entry.role || null },
+      intent_id: entry.intent_id || null,
+      payload: { checkpoint_sha: checkpointSha, checkpointed_at: checkpointedAt },
+    });
+  }
+
+  return {
+    ok: true,
+    turn: entry,
+    checkpoint_sha: checkpointSha,
+    checkpointed_at: checkpointedAt,
+  };
+}