@mndrk/agx 1.4.30 → 1.4.33

package/lib/cli/cloud/command.js

@@ -14,6 +14,8 @@ function createCloudCommandHelpers(env) {
     extractCancellationReason,
     CancellationRequestedError,
     CANCELLED_ERROR_CODE,
+    scheduleTermination,
+    getProcessManager,
   } = env || {};
 
   async function updateCloudTask(taskId, updates) {
@@ -48,12 +50,17 @@ function createCloudCommandHelpers(env) {
       let stdoutTail = '';
       let stderrTail = '';
       let settled = false;
+      let killHandle = null;
 
       const childArgs = sanitizeCliArgs([process.argv[1], ...args]);
       logExecutionFlow('runAgxCommand', 'input', `label=${label}, args=${childArgs.join(' ')}, timeout=${timeoutMs}`);
       const cancellationWatcher = handlers.cancellationWatcher || null;
-      const child = spawnCloudTaskProcess(childArgs);
+      const child = spawnCloudTaskProcess(childArgs, {
+        cwd: handlers.cwd,
+        env: handlers.env,
+      });
       logExecutionFlow('runAgxCommand', 'processing', `spawning child process (pid: ${child.pid})`);
+      const childPid = child?.pid || null;
 
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -91,16 +98,19 @@ function createCloudCommandHelpers(env) {
         }
       };
 
+      const killChild = () => {
+        if (!childPid) return;
+        if (killHandle) return;
+        try {
+          killHandle = scheduleTermination(childPid, { graceMs: 800, forceMs: 2500 });
+        } catch { }
+      };
+
       const handleCancellation = (payload) => {
         if (settled) return;
         settled = true;
         clearTimeout(timeout);
-        if (child && typeof child.kill === 'function') {
-          child.kill('SIGTERM');
-          setTimeout(() => {
-            child.kill('SIGKILL');
-          }, 500);
-        }
+        killChild();
         const reason = extractCancellationReason(payload) || 'Cancelled by operator';
         const err = new CancellationRequestedError(reason);
         err.code = CANCELLED_ERROR_CODE;
@@ -132,7 +142,7 @@ function createCloudCommandHelpers(env) {
       controller.signal.addEventListener('abort', () => {
         if (settled) return;
         settled = true;
-        child.kill('SIGKILL');
+        killChild();
         const err = new Error(`${label || 'command'} timed out`);
         err.code = 'ETIMEDOUT';
         clearTimeout(timeout);
@@ -154,16 +164,20 @@ function createCloudCommandHelpers(env) {
         reject(err);
       });
 
+      const pm = typeof getProcessManager === 'function' ? getProcessManager() : null;
+
       child.stdout.on('data', (data) => {
         const chunk = data.toString();
         stdout += chunk;
         stdoutTail = appendTail(stdoutTail, chunk);
+        if (pm && childPid) pm.recordActivity(childPid);
         if (handlers.onStdout) handlers.onStdout(data);
       });
       child.stderr.on('data', (data) => {
         const chunk = data.toString();
         stderr += chunk;
         stderrTail = appendTail(stderrTail, chunk);
+        if (pm && childPid) pm.recordActivity(childPid);
         if (handlers.onStderr) handlers.onStderr(data);
       });
 
@@ -187,6 +201,7 @@ function createCloudCommandHelpers(env) {
           error: err?.message || String(err),
         });
         cleanupCancellation();
+        try { killHandle?.cancel?.(); } catch { }
         reject(err);
       });
 
@@ -200,7 +215,7 @@ function createCloudCommandHelpers(env) {
           phase: 'exit',
           label,
           args: childArgs,
-          pid: child?.pid || null,
+          pid: childPid,
           timeout_ms: timeoutMs,
           started_at: startedAtIso,
           finished_at: new Date().toISOString(),
@@ -210,6 +225,7 @@ function createCloudCommandHelpers(env) {
           stderr_tail: truncateForTemporalTrace(stderrTail),
         });
         cleanupCancellation();
+        try { killHandle?.cancel?.(); } catch { }
         if (code === 0) {
           resolve({ stdout, stderr, code });
         } else {
@@ -227,4 +243,3 @@ function createCloudCommandHelpers(env) {
 }
 
 module.exports = { createCloudCommandHelpers };
-

package/lib/cli/cloud/executeVerifySingle.js

@@ -33,6 +33,8 @@ function createCloudExecuteVerifySingle(env) {
     buildNextPromptWithDecisionContext,
   } = env || {};
 
+  const baseProcEnv = typeof process !== 'undefined' && process.env ? process.env : {};
+
   async function runSingleAgentExecuteVerifyLoop({ taskId, task, provider, model, logger, storage, projectSlug, taskSlug, stageLocal, initialPromptContext, cancellationWatcher }) {
     logExecutionFlow('runSingleAgentExecuteVerifyLoop', 'input', `taskId=${taskId}, provider=${provider}, model=${model}`);
     const stageKey = task?.stage || 'unknown';
@@ -75,12 +77,19 @@ function createCloudExecuteVerifySingle(env) {
       const executePrompt = buildExecuteIterationPrompt(nextPrompt, iteration);
       let output = '';
       try {
+        const runEnv = {
+          ...baseProcEnv,
+          AGX_RUN_ROOT: executeRun?.paths?.root || '',
+          AGX_RUN_PLAN_DIR: executeRun?.paths?.plan || '',
+          AGX_RUN_ARTIFACTS_DIR: executeRun?.paths?.artifacts || '',
+        };
         output = await runSingleAgentIteration({
           taskId,
           task,
           provider,
           model,
           prompt: executePrompt,
+          env: runEnv,
           logger,
           onStdout: (chunk) => {
             try { execStdoutStream?.write(chunk.toString()); } catch { }
@@ -155,8 +164,15 @@ function createCloudExecuteVerifySingle(env) {
 
       let verifyRes;
       try {
+        const verifyEnv = {
+          ...baseProcEnv,
+          AGX_RUN_ROOT: verifyRun?.paths?.root || '',
+          AGX_RUN_PLAN_DIR: verifyRun?.paths?.plan || '',
+          AGX_RUN_ARTIFACTS_DIR: verifyRun?.paths?.artifacts || '',
+        };
         verifyRes = await pRetryFn(
           () => runAgxCommand(verifyArgs, VERIFY_TIMEOUT_MS, `agx ${provider} verify`, {
+            env: verifyEnv,
             onStdout: (data) => {
               try { verifyStdoutStream?.write(data.toString()); } catch { }
               logger?.log('checkpoint', data);

package/lib/cli/cloud/executeVerifySwarm.js

@@ -34,6 +34,8 @@ function createCloudExecuteVerifySwarm(env) {
     buildNextPromptWithDecisionContext,
   } = env || {};
 
+  const baseProcEnv = typeof process !== 'undefined' && process.env ? process.env : {};
+
   async function runSwarmExecuteVerifyLoop({ taskId, task, logger, storage, projectSlug, taskSlug, stageLocal, initialPromptContext, cancellationWatcher }) {
     logExecutionFlow('runSwarmExecuteVerifyLoop', 'input', `taskId=${taskId}`);
     const stageKey = task?.stage || 'unknown';
@@ -77,10 +79,17 @@ function createCloudExecuteVerifySwarm(env) {
       // EXECUTE (swarm iteration)
       let results;
       try {
+        const runEnv = {
+          ...baseProcEnv,
+          AGX_RUN_ROOT: executeRun?.paths?.root || '',
+          AGX_RUN_PLAN_DIR: executeRun?.paths?.plan || '',
+          AGX_RUN_ARTIFACTS_DIR: executeRun?.paths?.artifacts || '',
+        };
         results = await runSwarmIteration({
           taskId,
           task,
           prompt: nextPrompt ? buildExecuteIterationPrompt(nextPrompt, iteration) : buildExecuteIterationPrompt('', iteration),
+          env: runEnv,
           logger,
           artifacts: executeArtifacts,
           cancellationWatcher,
@@ -160,8 +169,15 @@ function createCloudExecuteVerifySwarm(env) {
       let verifyRes;
       try {
         await abortIfCancelled(cancellationWatcher);
+        const verifyEnv = {
+          ...baseProcEnv,
+          AGX_RUN_ROOT: verifyRun?.paths?.root || '',
+          AGX_RUN_PLAN_DIR: verifyRun?.paths?.plan || '',
+          AGX_RUN_ARTIFACTS_DIR: verifyRun?.paths?.artifacts || '',
+        };
         verifyRes = await pRetryFn(
           () => runAgxCommand(verifyArgs, VERIFY_TIMEOUT_MS, `agx ${verifierProvider} verify`, {
+            env: verifyEnv,
             onStdout: (data) => {
               try { verifyStdoutStream?.write(data.toString()); } catch { }
               logger?.log('checkpoint', data);

package/lib/cli/cloud/iterations.js

@@ -16,7 +16,7 @@ function createCloudIterationHelpers(env) {
     // Note: additional helpers (comments, artifacts) are handled by higher-level loops.
   } = env || {};
 
-  async function runSwarmIteration({ taskId, task, prompt, logger, artifacts, cancellationWatcher, onProviderStdout, onProviderStderr }) {
+  async function runSwarmIteration({ taskId, task, prompt, logger, artifacts, cancellationWatcher, onProviderStdout, onProviderStderr, env, cwd }) {
     logExecutionFlow('runSwarmIteration', 'input', `taskId=${taskId}, prompt=${Boolean(prompt)}`);
     const swarmModels = Array.isArray(task?.swarm_models)
       ? task.swarm_models
@@ -54,6 +54,8 @@ function createCloudIterationHelpers(env) {
 
       return pRetryFn(
         () => runAgxCommand(args, SWARM_TIMEOUT_MS, `agx ${provider}`, {
+          env,
+          cwd,
           onStdout: (data) => {
             if (typeof onProviderStdout === 'function') onProviderStdout(provider, data);
             logger?.log('output', data);
@@ -94,7 +96,7 @@ function createCloudIterationHelpers(env) {
     return results;
   }
 
-  async function runSingleAgentIteration({ taskId, task, provider, model, prompt, logger, onStdout, onStderr, artifacts, cancellationWatcher }) {
+  async function runSingleAgentIteration({ taskId, task, provider, model, prompt, logger, onStdout, onStderr, artifacts, cancellationWatcher, env, cwd }) {
     logExecutionFlow('runSingleAgentIteration', 'input', `taskId=${taskId}, provider=${provider}, model=${model}, prompt=${Boolean(prompt) ? 'present' : 'none'}`);
     logExecutionFlow('runSingleAgentIteration', 'processing', 'preparing runAgxCommand');
     const args = [provider, '--cloud-task', taskId];
@@ -119,6 +121,8 @@ function createCloudIterationHelpers(env) {
     await abortIfCancelled(cancellationWatcher);
     const res = await pRetryFn(
       () => runAgxCommand(args, SWARM_TIMEOUT_MS, `agx ${provider}`, {
+        env,
+        cwd,
         onStdout: (data) => {
           if (onStdout) onStdout(data);
           logger?.log('output', data);

package/lib/cli/cloud/taskLogger.js

@@ -4,6 +4,7 @@
 function createCloudTaskHelpers(env) {
   const {
     loadCloudConfigFile,
+    loadConfig,
     fetch,
     logExecutionFlow,
     postTaskLog,
@@ -12,6 +13,38 @@ function createCloudTaskHelpers(env) {
     appendTail,
   } = env || {};
 
+  function readTaskSectionSettings() {
+    // Prefer ~/.agx/config.json over env vars.
+    // Example:
+    // {
+    //   "taskSectionUpdates": { "enabled": false, "flushMs": 2000 }
+    // }
+    const cfg = typeof loadConfig === 'function' ? loadConfig() : null;
+    const sectionCfg = cfg?.taskSectionUpdates || cfg?.daemon?.taskSectionUpdates || null;
+
+    const enabledFromConfig = typeof sectionCfg?.enabled === 'boolean' ? sectionCfg.enabled : null;
+    const flushMsFromConfig = Number.isFinite(Number(sectionCfg?.flushMs)) ? Number(sectionCfg.flushMs) : null;
+
+    // Back-compat: allow env override if set.
+    const enabledFromEnv = process.env.AGX_TASK_SECTION_UPDATES ? (String(process.env.AGX_TASK_SECTION_UPDATES) === '1') : null;
+    const flushMsFromEnv = process.env.AGX_TASK_SECTION_FLUSH_MS && Number.isFinite(Number(process.env.AGX_TASK_SECTION_FLUSH_MS))
+      ? Number(process.env.AGX_TASK_SECTION_FLUSH_MS)
+      : null;
+
+    const enabled = enabledFromEnv ?? enabledFromConfig ?? false;
+    const flushMs = flushMsFromEnv ?? flushMsFromConfig ?? 2000;
+    return { enabled, flushMs };
+  }
+
+  function normalizeTailChunk(chunk) {
+    const text = Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk || '');
+    // Reduce churn from TTY control sequences and carriage returns.
+    // This is only used for the small "tail" that gets PUT into task.content.
+    return text
+      .replace(/\r/g, '')
+      .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+  }
+
   async function patchTaskState(taskId, state) {
     const cloudConfig = loadCloudConfigFile();
     if (!cloudConfig?.apiUrl) return;
@@ -36,6 +69,7 @@ function createCloudTaskHelpers(env) {
   }
 
   function createTaskLogger(taskId) {
+    const { enabled: enableSectionUpdates, flushMs: sectionFlushMs } = readTaskSectionSettings();
     const buffers = {
       output: '',
       error: '',
@@ -52,6 +86,14 @@ function createCloudTaskHelpers(env) {
       system: null,
       checkpoint: null
     };
+    const sectionTimers = {
+      output: null,
+      error: null,
+    };
+    const lastSection = {
+      output: '',
+      error: '',
+    };
     let updateChain = Promise.resolve();
 
     const scheduleFlush = (type) => {
@@ -59,6 +101,37 @@ function createCloudTaskHelpers(env) {
       timers[type] = setTimeout(() => flush(type), SWARM_LOG_FLUSH_MS);
     };
 
+    const scheduleSectionUpdate = (type) => {
+      if (!enableSectionUpdates) return;
+      if (sectionTimers[type]) return;
+      sectionTimers[type] = setTimeout(() => {
+        sectionTimers[type] = null;
+        const heading = type === 'output' ? 'Output' : 'Error';
+        const next = tails[type] || '';
+        if (!next) return;
+        if (next === lastSection[type]) return;
+        lastSection[type] = next;
+        updateChain = updateChain.then(() => updateTaskSection(heading, next, 'replace'));
+      }, sectionFlushMs);
+    };
+
+    const flushSectionUpdates = async () => {
+      if (!enableSectionUpdates) return;
+      for (const type of ['output', 'error']) {
+        if (sectionTimers[type]) {
+          clearTimeout(sectionTimers[type]);
+          sectionTimers[type] = null;
+        }
+        const heading = type === 'output' ? 'Output' : 'Error';
+        const next = tails[type] || '';
+        if (!next) continue;
+        if (next === lastSection[type]) continue;
+        lastSection[type] = next;
+        updateChain = updateChain.then(() => updateTaskSection(heading, next, 'replace'));
+      }
+      await updateChain.catch(() => { });
+    };
+
     const flush = async (type) => {
       if (timers[type]) {
         clearTimeout(timers[type]);
@@ -127,25 +200,22 @@ function createCloudTaskHelpers(env) {
       const chunk = Buffer.isBuffer(data) ? data.toString() : String(data || '');
 
       if (type === 'output' || type === 'error') {
-        tails[type] = appendTail(tails[type], chunk, SWARM_LOG_MAX_BYTES);
+        tails[type] = appendTail(tails[type], normalizeTailChunk(chunk), SWARM_LOG_MAX_BYTES);
         buffers[type] += chunk;
       } else {
         buffers[type] += chunk;
       }
 
-      // Keep the main task content updated with smaller tails (avoid huge PUT).
-      if (type === 'output') {
-        updateChain = updateChain.then(() => updateTaskSection('Output', tails.output, 'replace'));
-      }
-      if (type === 'error') {
-        updateChain = updateChain.then(() => updateTaskSection('Error', tails.error, 'replace'));
-      }
+      // Keep the main task content updated with smaller tails (avoid huge PUT),
+      // but debounce updates to avoid a PUT per output chunk.
+      if (type === 'output') scheduleSectionUpdate('output');
+      if (type === 'error') scheduleSectionUpdate('error');
 
       scheduleFlush(type);
     };
 
     const flushAll = async () => {
-      await updateChain.catch(() => { });
+      await flushSectionUpdates();
       await Promise.all(Object.keys(buffers).map((t) => flush(t)));
     };
 
@@ -156,4 +226,3 @@ function createCloudTaskHelpers(env) {
 }
 
 module.exports = { createCloudTaskHelpers };
-

package/lib/cli/cloudArtifacts.js

@@ -471,8 +471,9 @@ module.exports = {
   createDaemonArtifactsRecorder,
   buildLocalRunIndexEntry,
   saveAugmentedPrompt,
+  extractSection,
   buildFullDaemonPromptContext,
   resolveTaskTicketType,
   parseList,
+  localArtifactKey,
 };
-

package/lib/cli/daemon.js

@@ -4,10 +4,11 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { spawn, spawnSync } = require('child_process');
+const execa = require('execa');
 
 const { c } = require('../ui/colors');
 const { CONFIG_DIR, DAEMON_PID_FILE, DAEMON_LOG_FILE, DAEMON_STATE_FILE, TASK_LOGS_DIR, BOARD_PID_FILE, BOARD_LOG_FILE, BOARD_ENV_FILE } = require('../config/paths');
+const { getDescendants } = require('../proc/killProcessTree');
 const { prompt } = require('./configStore');
 const { sleep } = require('./util');
 
@@ -100,13 +101,21 @@ async function stopDaemonProcessTree(pid, timeoutMs = 5000) {
   const deadline = Date.now() + timeoutMs;
 
   const killTree = (signal) => {
+    // Kill descendants bottom-up (leaves first) via ps enumeration
+    const descendants = getDescendants(pid);
+    for (let i = descendants.length - 1; i >= 0; i--) {
+      try { process.kill(descendants[i], signal); } catch { }
+    }
+    // Then kill root — try group first, fall back to individual
     try {
       process.kill(-pid, signal);
       return true;
     } catch (err) {
       if (err.code === 'ESRCH') return false;
-      process.kill(pid, signal);
-      return true;
+      try {
+        process.kill(pid, signal);
+        return true;
+      } catch { return false; }
     }
   };
 
@@ -302,25 +311,29 @@ const DOCKER_DEFAULT_DB_URL = 'postgresql://agx:agx@localhost:55432/agx';
 
 function isDockerPostgresRunning() {
   try {
-    const result = spawnSync('docker', ['inspect', '-f', '{{.State.Running}}', DOCKER_POSTGRES_CONTAINER], { timeout: 3000 });
-    return result.stdout && result.stdout.toString().trim() === 'true';
+    const result = execa.sync('docker', ['inspect', '-f', '{{.State.Running}}', DOCKER_POSTGRES_CONTAINER], {
+      timeout: 3000,
+      encoding: 'utf8',
+      reject: false,
+    });
+    return String(result.stdout || '').trim() === 'true';
   } catch {
     return false;
   }
 }
 
 function dockerExecPsql({ sql, timeoutMs = 60000 }) {
-  return spawnSync('docker', [
+  return execa.sync('docker', [
     'exec', '-i', DOCKER_POSTGRES_CONTAINER,
     'psql', '-U', 'agx', '-d', 'agx',
-  ], { input: sql, timeout: timeoutMs });
+  ], { input: sql, timeout: timeoutMs, encoding: 'utf8', reject: false });
 }
 
 function dockerHasRelation(qualifiedName) {
   const safe = String(qualifiedName).replace(/'/g, "''");
   const res = dockerExecPsql({ sql: `select to_regclass('${safe}') as rel;\\n`, timeoutMs: 10000 });
-  if (res.status !== 0) return false;
-  const out = (res.stdout || Buffer.from('')).toString('utf8');
+  if (res.exitCode !== 0) return false;
+  const out = String(res.stdout || '');
   return out.includes(qualifiedName.split('.').pop()) && !out.includes('null');
 }
 
@@ -335,8 +348,8 @@ function ensureDockerSchemaInitialized() {
   console.log(`${c.dim}Initializing database schema...${c.reset}`);
   const initSql = fs.readFileSync(initSqlPath, 'utf8');
   const psqlResult = dockerExecPsql({ sql: initSql, timeoutMs: 60000 });
-  if (psqlResult.status !== 0) {
-    const stderr = (psqlResult.stderr || Buffer.from('')).toString('utf8').trim();
+  if (psqlResult.exitCode !== 0) {
+    const stderr = String(psqlResult.stderr || '').trim();
     console.log(`${c.yellow}Schema init returned non-zero${c.reset}${stderr ? `: ${stderr}` : ''}`);
   }
 }
@@ -351,17 +364,17 @@ function ensureSchemaInitialized(dbUrl) {
     if (!isDockerPostgresRunning()) return;
     console.log(`${c.dim}Initializing database schema...${c.reset}`);
     const psqlResult = dockerExecPsql({ sql: initSql, timeoutMs: 60000 });
-    if (psqlResult.status !== 0) {
-      const stderr = (psqlResult.stderr || Buffer.from('')).toString('utf8').trim();
+    if (psqlResult.exitCode !== 0) {
+      const stderr = String(psqlResult.stderr || '').trim();
       console.log(`${c.yellow}Schema init returned non-zero${c.reset}${stderr ? `: ${stderr}` : ''}`);
     }
     return;
   }
 
   console.log(`${c.dim}Initializing database schema...${c.reset}`);
-  const psqlResult = spawnSync('psql', [dbUrl], { input: initSql, timeout: 60000 });
-  if (psqlResult.status !== 0) {
-    const stderr = (psqlResult.stderr || Buffer.from('')).toString('utf8').trim();
+  const psqlResult = execa.sync('psql', [dbUrl], { input: initSql, timeout: 60000, encoding: 'utf8', reject: false });
+  if (psqlResult.exitCode !== 0) {
+    const stderr = String(psqlResult.stderr || '').trim();
     console.log(`${c.yellow}Schema init returned non-zero${c.reset}${stderr ? `: ${stderr}` : ''}`);
   }
 }
@@ -373,8 +386,8 @@ async function ensurePostgresReady() {
       const dbUrl = new URL(boardEnv.DATABASE_URL);
       const host = dbUrl.hostname;
       const port = dbUrl.port || '5432';
-      const result = spawnSync('pg_isready', ['-h', host, '-p', port], { timeout: 3000 });
-      if (result.status === 0) {
+      const result = execa.sync('pg_isready', ['-h', host, '-p', port], { timeout: 3000, reject: false });
+      if (result.exitCode === 0) {
         ensureSchemaInitialized(boardEnv.DATABASE_URL);
         return boardEnv.DATABASE_URL;
       }
@@ -406,7 +419,7 @@ async function ensurePostgresReady() {
   }
 
   console.log(`${c.dim}Starting postgres via Docker...${c.reset}`);
-  const dockerResult = spawnSync('docker', [
+  const dockerResult = execa.sync('docker', [
     'run', '-d',
     '--name', 'agx-postgres',
     '-e', 'POSTGRES_DB=agx',
@@ -415,12 +428,12 @@ async function ensurePostgresReady() {
     '-p', '55432:5432',
     '-v', 'agx_pg_data:/var/lib/postgresql/data',
     'postgres:16-alpine',
-  ], { stdio: 'pipe', timeout: 60000 });
+  ], { stdio: 'pipe', timeout: 60000, encoding: 'utf8', reject: false });
 
-  if (dockerResult.status !== 0) {
-    const stderr = dockerResult.stderr ? dockerResult.stderr.toString() : '';
+  if (dockerResult.exitCode !== 0) {
+    const stderr = String(dockerResult.stderr || '');
     if (stderr.includes('already in use')) {
-      spawnSync('docker', ['start', 'agx-postgres'], { timeout: 10000 });
+      execa.sync('docker', ['start', 'agx-postgres'], { timeout: 10000, reject: false });
     } else {
       console.error(`${c.red}Failed to start postgres:${c.reset} ${stderr}`);
       process.exit(1);
@@ -430,8 +443,8 @@ async function ensurePostgresReady() {
   console.log(`${c.dim}Waiting for postgres to be ready...${c.reset}`);
   const deadline = Date.now() + 30000;
   while (Date.now() < deadline) {
-    const check = spawnSync('docker', ['exec', 'agx-postgres', 'pg_isready', '-U', 'agx'], { timeout: 3000 });
-    if (check.status === 0) break;
+    const check = execa.sync('docker', ['exec', 'agx-postgres', 'pg_isready', '-U', 'agx'], { timeout: 3000, reject: false });
+    if (check.exitCode === 0) break;
     await sleep(1000);
   }
 
@@ -511,18 +524,20 @@ async function ensureBoardRunning() {
   let proc;
   try {
     if (boardInfo.mode === 'bundled') {
-      proc = spawn('node', ['server.js'], {
+      proc = execa('node', ['server.js'], {
         cwd: boardInfo.dir,
         detached: true,
         stdio: ['ignore', logFd, logFd],
         env: boardEnv,
+        reject: false,
       });
     } else {
-      proc = spawn('npm', ['run', 'dev'], {
+      proc = execa('npm', ['run', 'dev'], {
         cwd: boardInfo.dir,
         detached: true,
         stdio: ['ignore', logFd, logFd],
         env: boardEnv,
+        reject: false,
       });
     }
   } catch (err) {
@@ -533,7 +548,7 @@ async function ensureBoardRunning() {
   }
 
   fs.closeSync(logFd);
-  proc.unref();
+  proc.unref?.();
   fs.writeFileSync(BOARD_PID_FILE, String(proc.pid));
 
   console.log(`${c.dim}Waiting for board server (pid ${proc.pid})...${c.reset}`);
@@ -633,11 +648,12 @@ function startTemporalWorker() {
       fs.closeSync(logFd);
       return null;
     }
-    worker = spawn('npm', ['run', script], {
+    worker = execa('npm', ['run', script], {
       cwd: projectDir,
       detached: true,
       stdio: ['ignore', logFd, logFd],
       env: { ...process.env, ...boardEnv },
+      reject: false,
     });
   } catch (err) {
     fs.closeSync(logFd);
@@ -646,7 +662,7 @@ function startTemporalWorker() {
   }
 
   fs.closeSync(logFd);
-  worker.unref();
+  worker.unref?.();
   fs.writeFileSync(WORKER_PID_FILE, String(worker.pid));
 
   console.log(`${c.green}✓${c.reset} Orchestrator worker started (pid ${worker.pid})`);
@@ -706,7 +722,7 @@ function startDaemon(options = {}) {
     daemonArgs.push('--workers', String(options.maxWorkers));
   }
 
-  const daemon = spawn(process.execPath, daemonArgs, {
+  const daemon = execa(process.execPath, daemonArgs, {
     detached: true,
     stdio: ['ignore',
       fs.openSync(DAEMON_LOG_FILE, 'a'),
@@ -719,7 +735,7 @@ function startDaemon(options = {}) {
     }
   });
 
-  daemon.unref();
+  daemon.unref?.();
   fs.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
 
   console.log(`${c.green}✓${c.reset} Daemon started (pid ${daemon.pid})`);