@mndrk/agx 1.4.64 → 2.0.0-next.0

package/lib/cli/cloud/executeVerifySingle.js

@@ -161,6 +161,8 @@ function createCloudExecuteVerifySingle(env) {
       const verifyArtifacts = createDaemonArtifactsRecorder({ storage, run: verifyRun, taskId });
       verifyArtifacts.recordPrompt(`Verification Prompt (${provider}${model ? `/${model}` : ''}, iter ${iteration})`, verifyPrompt);
 
+      // WARNING: keep `-y` in verifier invocation for cloud loops.
+      // This command shape is lock-tested and should not be changed casually.
       const verifyArgs = [provider, '-y', '--prompt', verifyPrompt, '--print'];
       if (model) verifyArgs.push('--model', model);
 
@@ -242,7 +244,9 @@ function createCloudExecuteVerifySingle(env) {
         summary: typeof decision.summary === 'string' ? decision.summary : '',
         plan_md: typeof decision.plan_md === 'string' ? decision.plan_md : '',
         implementation_summary_md: typeof decision.implementation_summary_md === 'string' ? decision.implementation_summary_md : '',
-        verification_md: typeof decision.verification_md === 'string' ? decision.verification_md : '',
+        validation_md: typeof decision.validation_md === 'string'
+          ? decision.validation_md
+          : (typeof decision.verification_md === 'string' ? decision.verification_md : ''),
       }, { stage: stageKey, stagePrompt })));
 
       lastDecision = decision;

package/lib/cli/cloud/executeVerifySwarm.js

@@ -167,6 +167,8 @@ function createCloudExecuteVerifySwarm(env) {
       const verifyArtifacts = createDaemonArtifactsRecorder({ storage, run: verifyRun, taskId });
       verifyArtifacts.recordPrompt(`Verification Prompt (${verifierProvider}${verifierModel ? `/${verifierModel}` : ''}, iter ${iteration})`, verifyPrompt);
 
+      // WARNING: keep `-y` in verifier invocation for cloud swarm loops.
+      // This command shape is lock-tested and should not be changed casually.
       const verifyArgs = [verifierProvider, '-y', '--prompt', verifyPrompt, '--print'];
       if (verifierModel) verifyArgs.push('--model', verifierModel);
 
@@ -254,7 +256,9 @@ function createCloudExecuteVerifySwarm(env) {
         summary: typeof decision.summary === 'string' ? decision.summary : '',
         plan_md: typeof decision.plan_md === 'string' ? decision.plan_md : '',
         implementation_summary_md: typeof decision.implementation_summary_md === 'string' ? decision.implementation_summary_md : '',
-        verification_md: typeof decision.verification_md === 'string' ? decision.verification_md : '',
+        validation_md: typeof decision.validation_md === 'string'
+          ? decision.validation_md
+          : (typeof decision.verification_md === 'string' ? decision.verification_md : ''),
       }, { stage: stageKey, stagePrompt })));
 
       lastDecision = decision;

package/lib/cli/cloud/index.js

@@ -8,6 +8,7 @@ const { createCloudIterationHelpers } = require('./iterations');
 const { createCloudAggregateHelpers } = require('./aggregate');
 const { createCloudExecuteVerifySingle } = require('./executeVerifySingle');
 const { createCloudExecuteVerifySwarm } = require('./executeVerifySwarm');
+const { createCloudExecuteGraphV2 } = require('./executeGraphV2');
 const { createCloudSimpleLoops } = require('./simpleLoops');
 const { createCloudTaskHelpers } = require('./taskLogger');
 
@@ -37,6 +38,7 @@ function createCloudRunner(env) {
   const iterations = createCloudIterationHelpers(baseEnv);
   baseEnv.runSwarmIteration = iterations.runSwarmIteration;
   baseEnv.runSingleAgentIteration = iterations.runSingleAgentIteration;
+  baseEnv.runSingleAgentPlanIteration = iterations.runSingleAgentPlanIteration;
 
   const aggregate = createCloudAggregateHelpers(baseEnv);
   baseEnv.runSingleAgentAggregate = aggregate.runSingleAgentAggregate;
@@ -48,6 +50,9 @@ function createCloudRunner(env) {
   const execVerifySwarm = createCloudExecuteVerifySwarm(baseEnv);
   baseEnv.runSwarmExecuteVerifyLoop = execVerifySwarm.runSwarmExecuteVerifyLoop;
 
+  const execGraphV2 = createCloudExecuteGraphV2(baseEnv);
+  baseEnv.runV2GraphExecutionLoop = execGraphV2.runV2GraphExecutionLoop;
+
   const simpleLoops = createCloudSimpleLoops(baseEnv);
   baseEnv.runSingleAgentLoop = simpleLoops.runSingleAgentLoop;
   baseEnv.runSwarmLoop = simpleLoops.runSwarmLoop;
@@ -61,6 +66,7 @@ function createCloudRunner(env) {
     ...aggregate,
     ...execVerifySingle,
     ...execVerifySwarm,
+    ...execGraphV2,
     ...simpleLoops,
   };
 }

package/lib/cli/cloud/iterations.js

@@ -39,6 +39,8 @@ function createCloudIterationHelpers(env) {
     logger?.log('system', `[swarm] iteration start\n`);
 
     const results = await pMap(providers, (provider, index) => {
+      // WARNING: keep `-y` in this cloud-invoked command shape.
+      // This is intentionally lock-tested; change only with coordinated test updates.
       const args = [provider, '-y', '--cloud-task', taskId];
       const modelForProvider = swarmModels.length
         ? swarmModels[index]?.model || null
@@ -99,6 +101,8 @@ function createCloudIterationHelpers(env) {
   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');
+    // WARNING: keep `-y` in this cloud-invoked command shape.
+    // This is intentionally lock-tested; change only with coordinated test updates.
     const args = [provider, '-y', '--cloud-task', taskId];
     if (model) {
       args.push('--model', model);
@@ -153,7 +157,58 @@ function createCloudIterationHelpers(env) {
     return res.stdout || res.stderr || '';
   }
 
-  return { runSwarmIteration, runSingleAgentIteration };
+  async function runSingleAgentPlanIteration({ taskId, provider, model, prompt, logger, onStdout, onStderr, artifacts, cancellationWatcher, env, cwd }) {
+    logExecutionFlow('runSingleAgentPlanIteration', 'input', `taskId=${taskId}, provider=${provider}, model=${model}, prompt=${Boolean(prompt) ? 'present' : 'none'}`);
+    logExecutionFlow('runSingleAgentPlanIteration', 'processing', 'preparing runAgxCommand');
+    // Plan generation must be output-only: no --cloud-task context injection.
+    // This avoids execution-oriented instructions and keeps the planner deterministic.
+    const args = [provider, '-y'];
+    if (model) {
+      args.push('--model', model);
+    }
+    if (prompt) {
+      const planPrompt = String(prompt);
+      artifacts?.recordPrompt(`Plan Iteration Prompt (${provider}${model ? `/${model}` : ''})`, planPrompt);
+      args.push('--prompt', planPrompt);
+    }
+    args.push('--print');
+
+    await abortIfCancelled(cancellationWatcher);
+    const res = await pRetryFn(
+      () => runAgxCommand(args, SWARM_TIMEOUT_MS, `agx ${provider} [plan]`, {
+        env,
+        cwd,
+        onStdout: (data) => {
+          if (onStdout) onStdout(data);
+          logger?.log('output', data);
+        },
+        onStderr: (data) => {
+          if (onStderr) onStderr(data);
+          logger?.log('error', data);
+        },
+        onTrace: (event) => {
+          void artifacts?.recordEngineTrace?.({ provider, model: model || null, role: 'plan-iteration' }, event);
+
+          if (taskId) {
+            if (event.phase === 'start' && event.pid) {
+              void updateCloudTask(taskId, { pid: event.pid, started_at: event.started_at });
+            }
+            if (event.phase === 'exit') {
+              void updateCloudTask(taskId, { exit_code: event.exit_code, completed_at: event.finished_at });
+            }
+          }
+        },
+        cancellationWatcher,
+      }),
+      { retries: SWARM_RETRIES }
+    );
+
+    const outputSource = res.stdout || res.stderr || '';
+    logExecutionFlow('runSingleAgentPlanIteration', 'output', `response length=${outputSource.length}`);
+    return outputSource;
+  }
+
+  return { runSwarmIteration, runSingleAgentIteration, runSingleAgentPlanIteration };
 }
 
 module.exports = { createCloudIterationHelpers };

package/lib/cli/cloud/persist.js

@@ -36,7 +36,7 @@ function createCloudPersistenceHelpers(env) {
 
     const planMd = safeText(decision?.plan_md) || '# Plan\n\n- (not provided)\n';
     const implMd = safeText(decision?.implementation_summary_md) || '# Implementation Summary\n\n- (not provided)\n';
-    const verificationMd = safeText(decision?.verification_md) || '# Verification\n\nDONE: no\n\n- (not provided)\n';
+    const verificationMd = safeText(decision?.validation_md || decision?.verification_md) || '# Validation\n\nDONE: no\n\n- (not provided)\n';
 
     // Write the plan markdown into the plan folder (not under execute/verify).
     if (runContainerPath) {
@@ -120,4 +120,3 @@ function createCloudPersistenceHelpers(env) {
 }
 
 module.exports = { createCloudPersistenceHelpers };
-

package/lib/cli/cloud/prompts.js

@@ -6,6 +6,12 @@ const { interpolate, AGGREGATOR_PROMPT, EXECUTE_ITERATION, VERIFY_PROMPT } = req
 function createCloudPromptHelpers(env) {
   const { path, truncateForPrompt, VERIFY_PROMPT_MAX_CHARS } = env || {};
 
+  function resolveTaskPromptBody(task) {
+    const description = String(task?.description || '').trim();
+    if (description) return description;
+    return String(task?.content || '').trim();
+  }
+
   function resolveAggregatorModel(task) {
     const explicitAggregatorModel = typeof task?.engine_model === 'string' && task.engine_model.trim()
       ? task.engine_model.trim()
@@ -57,7 +63,7 @@ function createCloudPromptHelpers(env) {
       title: task?.title || taskId,
       stage: task?.stage || 'unknown',
       taskTitle: task?.title,
-      taskContent: task?.content,
+      taskContent: resolveTaskPromptBody(task),
       taskComments: taskComments.map(c => `${c.author}: ${c.content}`).join('\n'),
       stagePrompt,
       stageRequirement,
@@ -87,7 +93,7 @@ function createCloudPromptHelpers(env) {
 
   function buildVerifyPrompt({ taskId, task, stagePrompt, stageRequirement, gitSummary, verifyResults, iteration, lastRunPath, agentOutput }) {
     const title = String(task?.title || taskId || '').trim();
-    const contentRaw = String(task?.content || '').trim();
+    const contentRaw = resolveTaskPromptBody(task);
     const content = contentRaw.length > 2500 ? `${contentRaw.slice(0, 2500)}\n[truncated]` : contentRaw;
 
     const agentOutputRaw = agentOutput ? String(agentOutput).trim() : '';
@@ -106,7 +112,7 @@ function createCloudPromptHelpers(env) {
         const dur = typeof r.duration_ms === 'number' ? `${r.duration_ms}ms` : '';
         return `- ${label} => exit=${code} ${dur}`.trim();
       }).join('\n')
-      : '- (no verification commands detected)';
+      : '- (no validation commands detected)';
 
     const runRoot = lastRunPath ? String(lastRunPath) : '';
 

package/lib/cli/cloud/taskLogger.js

@@ -103,22 +103,12 @@ function createCloudTaskHelpers(env) {
 
   function createTaskLogger(taskId) {
     const { enabled: enableTailComments, flushMs: tailCommentFlushMs } = readTaskSectionSettings();
-    const buffers = {
-      output: '',
-      error: '',
-      system: '',
-      checkpoint: ''
-    };
+    const buffers = new Map();
     const tails = {
       output: '',
       error: ''
     };
-    const timers = {
-      output: null,
-      error: null,
-      system: null,
-      checkpoint: null
-    };
+    const timers = new Map();
     const sectionTimers = {
       output: null,
       error: null,
@@ -129,9 +119,26 @@ function createCloudTaskHelpers(env) {
     };
     let updateChain = Promise.resolve();
 
-    const scheduleFlush = (type) => {
-      if (timers[type]) return;
-      timers[type] = setTimeout(() => flush(type), SWARM_LOG_FLUSH_MS);
+    const normalizeNodeId = (nodeId) => {
+      if (typeof nodeId !== 'string') return null;
+      const trimmed = nodeId.trim();
+      return trimmed || null;
+    };
+
+    const makeBufferKey = (type, nodeId) => `${type}::${normalizeNodeId(nodeId) || ''}`;
+
+    const parseBufferKey = (key) => {
+      const [type = 'output', encodedNodeId = ''] = String(key || '').split('::');
+      return {
+        type,
+        nodeId: encodedNodeId || null,
+      };
+    };
+
+    const scheduleFlush = (type, nodeId) => {
+      const key = makeBufferKey(type, nodeId);
+      if (timers.has(key)) return;
+      timers.set(key, setTimeout(() => flushByKey(key), SWARM_LOG_FLUSH_MS));
     };
 
     const scheduleSectionUpdate = (type) => {
@@ -173,38 +180,40 @@ function createCloudTaskHelpers(env) {
       await updateChain.catch(() => { });
     };
 
-    const flush = async (type) => {
-      if (timers[type]) {
-        clearTimeout(timers[type]);
-        timers[type] = null;
+    const flushByKey = async (key) => {
+      const timer = timers.get(key);
+      if (timer) {
+        clearTimeout(timer);
+        timers.delete(key);
       }
-      const content = buffers[type];
+      const content = buffers.get(key) || '';
       if (!content) return;
-      buffers[type] = '';
-      await postTaskLog(taskId, content, type);
+      buffers.set(key, '');
+      const { type, nodeId } = parseBufferKey(key);
+      await postTaskLog(taskId, content, type, nodeId);
     };
 
-    const log = (type, data) => {
+    const log = (type, data, nodeId) => {
       const chunk = Buffer.isBuffer(data) ? data.toString() : String(data || '');
+      const key = makeBufferKey(type, nodeId);
+      const current = buffers.get(key) || '';
 
       if (type === 'output' || type === 'error') {
         tails[type] = appendTail(tails[type], normalizeTailChunk(chunk), SWARM_LOG_MAX_BYTES);
-        buffers[type] += chunk;
-      } else {
-        buffers[type] += chunk;
       }
+      buffers.set(key, current + chunk);
 
       // 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);
+      scheduleFlush(type, nodeId);
     };
 
     const flushAll = async () => {
       await flushSectionUpdates();
-      await Promise.all(Object.keys(buffers).map((t) => flush(t)));
+      await Promise.all(Array.from(buffers.keys()).map((key) => flushByKey(key)));
     };
 
     return { log, flushAll };

package/lib/cli/cloudArtifacts.js

@@ -15,7 +15,7 @@ function isLocalArtifactsEnabled() {
 function mapCloudStageToLocalStage(stage) {
   const raw = String(stage || '').toLowerCase().trim();
   if (raw === 'plan' || raw === 'execute' || raw === 'verify' || raw === 'resume') return raw;
-  if (raw === 'ideation' || raw === 'planning') return 'plan';
+  if (raw === 'intake' || raw === 'planning') return 'plan';
   if (raw === 'verification') return 'verify';
   return 'execute';
 }
@@ -146,20 +146,31 @@ function createDaemonArtifactsRecorder({ storage, run, taskId }) {
       }
     },
     async flush() {
+      if (run?.finalized) {
+        return;
+      }
       const promptText = promptParts.join('\n').trim() + '\n';
       const outputText = outputParts.join('\n').trim() + '\n';
 
-      if (promptText.trim()) {
-        const totalBytes = Buffer.byteLength(promptText, 'utf8');
-        const event = storage.promptBuiltEvent({ sections: { daemon: totalBytes }, total_bytes: totalBytes });
-        await storage.writePrompt(run, promptText, event);
-      }
+      try {
+        if (promptText.trim()) {
+          const totalBytes = Buffer.byteLength(promptText, 'utf8');
+          const event = storage.promptBuiltEvent({ sections: { daemon: totalBytes }, total_bytes: totalBytes });
+          await storage.writePrompt(run, promptText, event);
+        }
 
-      if (outputText.trim()) {
-        await storage.writeOutput(run, outputText);
-      }
+        if (outputText.trim()) {
+          await storage.writeOutput(run, outputText);
+        }
 
-      await storage.appendEvent(run.paths.events, { t: 'DAEMON_ARTIFACTS_FLUSHED', task_id: taskId });
+        await storage.appendEvent(run.paths.events, { t: 'DAEMON_ARTIFACTS_FLUSHED', task_id: taskId });
+      } catch (err) {
+        const msg = String(err?.message || err || '');
+        if (run?.finalized || msg.includes('finalized run')) {
+          return;
+        }
+        throw err;
+      }
     }
   };
 }
@@ -259,6 +270,12 @@ function extractSection(markdown, heading) {
   return section.trim();
 }
 
+function resolveTaskPromptBody(task) {
+  const description = String(task?.description || '').trim();
+  if (description) return description;
+  return String(task?.content || '').trim();
+}
+
 function buildFullDaemonPromptContext(task, options = {}) {
   const comments = Array.isArray(options.comments) ? options.comments : [];
   const provider = options.provider || task?.engine || task?.provider || 'unknown';
@@ -320,7 +337,7 @@ You are continuing a cloud task. Here is the current state:
 
 Task ID: ${task?.id || 'unknown'}
 Title: ${task?.title || 'Untitled'}
-Stage: ${task?.stage || 'ideation'}
+Stage: ${task?.stage || 'intake'}
 Stage Objective: ${stagePrompt}
 Stage Completion Requirement (guidance): ${stageRequirement}
 Provider: ${provider}${model ? `/${model}` : ''}
@@ -329,7 +346,7 @@ ${reposSection ? `\n## Project Repos\n\nYou are starting in the home directory.
 User Request: 
 """
 ${task?.title || ''}
-${task?.content || ''}
+${resolveTaskPromptBody(task)}
 ---
 Task Thread:
 ${commentsSection}

package/lib/cli/configStore.js

@@ -24,15 +24,26 @@ function saveConfig(config) {
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
-    output: process.stdout
+    output: process.stdout,
   });
+
   return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
+    let settled = false;
+    const finish = (answer = '') => {
+      if (settled) return;
+      settled = true;
+      try { rl.close(); } catch { }
       resolve(answer);
+    };
+
+    rl.question(question, (answer) => {
+      finish(answer);
     });
+
+    // In non-interactive shells stdin can close without invoking question callback.
+    rl.on('close', () => finish(''));
+    rl.on('SIGINT', () => finish(''));
   });
 }
 
 module.exports = { loadConfig, saveConfig, prompt };
-

package/lib/cli/daemon.js

@@ -377,26 +377,68 @@ function ensureSchemaInitialized(dbUrl) {
   }
 
   console.log(`${c.dim}Initializing database schema...${c.reset}`);
-  const psqlResult = execa.sync('psql', [dbUrl], { input: initSql, timeout: 60000, encoding: 'utf8', reject: false });
+  let psqlResult;
+  try {
+    psqlResult = execa.sync('psql', [dbUrl], { input: initSql, timeout: 60000, encoding: 'utf8', reject: false });
+  } catch (err) {
+    console.log(`${c.yellow}Schema init skipped${c.reset}: ${err?.message || 'psql is not available'}`);
+    return;
+  }
   if (psqlResult.exitCode !== 0) {
     const stderr = String(psqlResult.stderr || '').trim();
     console.log(`${c.yellow}Schema init returned non-zero${c.reset}${stderr ? `: ${stderr}` : ''}`);
   }
 }
 
-async function ensurePostgresReady() {
+function isInteractivePromptAvailable() {
+  return Boolean(process.stdin?.isTTY && process.stdout?.isTTY);
+}
+
+function failPostgresSetup(message) {
+  const detail = String(message || '').trim();
+  if (detail) {
+    console.error(`${c.red}${detail}${c.reset}`);
+  }
+  console.error(`${c.yellow}Unable to bootstrap local Postgres for agx board.${c.reset}`);
+  console.error(`${c.dim}Set DATABASE_URL to an existing Postgres instance, or set AGX_CLOUD_URL to a running agx-cloud backend.${c.reset}`);
+  process.exit(1);
+}
+
+function resolveConfiguredDatabaseUrl() {
   const boardEnv = loadBoardEnv();
-  if (boardEnv.DATABASE_URL) {
+  const boardDbUrl = String(boardEnv.DATABASE_URL || '').trim();
+  const envDbUrl = String(process.env.DATABASE_URL || '').trim();
+  const selected = boardDbUrl || envDbUrl;
+  if (!selected) return null;
+  if (!boardDbUrl && envDbUrl) {
+    saveBoardEnvValue('DATABASE_URL', envDbUrl);
+  }
+  return selected;
+}
+
+async function ensurePostgresReady() {
+  const configuredDbUrl = resolveConfiguredDatabaseUrl();
+  if (configuredDbUrl) {
     try {
-      const dbUrl = new URL(boardEnv.DATABASE_URL);
+      const dbUrl = new URL(configuredDbUrl);
       const host = dbUrl.hostname;
       const port = dbUrl.port || '5432';
       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;
+      if (result.exitCode !== 0) {
+        const stderr = String(result.stderr || '').trim();
+        console.log(`${c.yellow}DATABASE_URL check failed${c.reset}${stderr ? `: ${stderr}` : ''}`);
       }
-    } catch { }
+    } catch (err) {
+      if (err?.code === 'ENOENT') {
+        console.log(`${c.dim}pg_isready not found; continuing with configured DATABASE_URL.${c.reset}`);
+      } else if (err instanceof TypeError) {
+        failPostgresSetup(`Invalid DATABASE_URL: ${configuredDbUrl}`);
+      } else {
+        console.log(`${c.yellow}DATABASE_URL probe failed${c.reset}: ${err?.message || err}`);
+      }
+    }
+    ensureSchemaInitialized(configuredDbUrl);
+    return configuredDbUrl;
   }
 
   if (isDockerPostgresRunning()) {
@@ -410,10 +452,18 @@ async function ensurePostgresReady() {
   console.log(`  ${c.bold}1${c.reset}) Enter a custom DATABASE_URL`);
   console.log(`  ${c.bold}2${c.reset}) Auto-start postgres via Docker`);
 
-  const answer = await prompt(`\\n${c.cyan}Choice [2]:${c.reset} `);
-  const choice = answer.trim() || '2';
+  let choice = '2';
+  if (isInteractivePromptAvailable()) {
+    const answer = await prompt(`\\n${c.cyan}Choice [2]:${c.reset} `);
+    choice = answer.trim() || '2';
+  } else {
+    console.log(`${c.dim}Non-interactive session detected; defaulting to Docker auto-start.${c.reset}`);
+  }
 
   if (choice === '1') {
+    if (!isInteractivePromptAvailable()) {
+      failPostgresSetup('Cannot prompt for DATABASE_URL in non-interactive mode.');
+    }
     const dbUrl = await prompt(`${c.cyan}DATABASE_URL:${c.reset} `);
     if (!dbUrl) {
       console.error(`${c.red}No DATABASE_URL provided.${c.reset}`);
@@ -424,34 +474,57 @@ async function ensurePostgresReady() {
   }
 
   console.log(`${c.dim}Starting postgres via Docker...${c.reset}`);
-  const dockerResult = execa.sync('docker', [
-    'run', '-d',
-    '--name', 'agx-postgres',
-    '-e', 'POSTGRES_DB=agx',
-    '-e', 'POSTGRES_USER=agx',
-    '-e', 'POSTGRES_PASSWORD=agx',
-    '-p', '55432:5432',
-    '-v', 'agx_pg_data:/var/lib/postgresql/data',
-    'postgres:16-alpine',
-  ], { stdio: 'pipe', timeout: 60000, encoding: 'utf8', reject: false });
+  let dockerResult;
+  try {
+    dockerResult = execa.sync('docker', [
+      'run', '-d',
+      '--name', 'agx-postgres',
+      '-e', 'POSTGRES_DB=agx',
+      '-e', 'POSTGRES_USER=agx',
+      '-e', 'POSTGRES_PASSWORD=agx',
+      '-p', '55432:5432',
+      '-v', 'agx_pg_data:/var/lib/postgresql/data',
+      'postgres:16-alpine',
+    ], { stdio: 'pipe', timeout: 60000, encoding: 'utf8', reject: false });
+  } catch (err) {
+    failPostgresSetup(`Failed to start Docker postgres: ${err?.message || err}`);
+  }
 
   if (dockerResult.exitCode !== 0) {
     const stderr = String(dockerResult.stderr || '');
     if (stderr.includes('already in use')) {
-      execa.sync('docker', ['start', 'agx-postgres'], { timeout: 10000, reject: false });
+      try {
+        const startResult = execa.sync('docker', ['start', 'agx-postgres'], { timeout: 10000, reject: false, encoding: 'utf8' });
+        if (startResult.exitCode !== 0) {
+          failPostgresSetup(`Failed to start existing agx-postgres container: ${String(startResult.stderr || '').trim() || 'unknown error'}`);
+        }
+      } catch (err) {
+        failPostgresSetup(`Failed to start existing agx-postgres container: ${err?.message || err}`);
+      }
     } else {
-      console.error(`${c.red}Failed to start postgres:${c.reset} ${stderr}`);
-      process.exit(1);
+      failPostgresSetup(`Failed to start postgres: ${stderr || 'unknown docker error'}`);
     }
   }
 
   console.log(`${c.dim}Waiting for postgres to be ready...${c.reset}`);
   const deadline = Date.now() + 30000;
+  let ready = false;
   while (Date.now() < deadline) {
-    const check = execa.sync('docker', ['exec', 'agx-postgres', 'pg_isready', '-U', 'agx'], { timeout: 3000, reject: false });
-    if (check.exitCode === 0) break;
+    let check;
+    try {
+      check = execa.sync('docker', ['exec', 'agx-postgres', 'pg_isready', '-U', 'agx'], { timeout: 3000, reject: false, encoding: 'utf8' });
+    } catch (err) {
+      failPostgresSetup(`Failed while checking postgres readiness: ${err?.message || err}`);
+    }
+    if (check.exitCode === 0) {
+      ready = true;
+      break;
+    }
     await sleep(1000);
   }
+  if (!ready) {
+    failPostgresSetup('Timed out waiting for Docker postgres to become ready.');
+  }
 
   const dbUrl = DOCKER_DEFAULT_DB_URL;
   saveBoardEnvValue('DATABASE_URL', dbUrl);

package/lib/cli/interactiveMenu.js

@@ -154,23 +154,16 @@ async function runInteractiveMenu() {
       releaseTTY();
 
       if (item.id === 'chat') {
-        if (selectedProvider === 'ollama') {
-          const ollamaModel = config?.ollama?.model || 'llama3.2:3b';
-          const child = execa('claude', ['--dangerously-skip-permissions', '--model', ollamaModel], {
-            stdio: 'inherit',
-            env: {
-              ...process.env,
-              ANTHROPIC_AUTH_TOKEN: 'ollama',
-              ANTHROPIC_BASE_URL: 'http://localhost:11434',
-              ANTHROPIC_API_KEY: ''
-            },
-            reject: false,
+        const { startChat } = require('./chat');
+        try {
+          await startChat({
+            provider: selectedProvider,
+            model: selectedProvider === 'ollama' ? config?.ollama?.model || 'llama3.2:3b' : null,
           });
-          child.on('close', (code) => process.exit(code || 0));
-        } else {
-          const child = execa(selectedProvider, [], { stdio: 'inherit', reject: false });
-          child.on('close', (code) => process.exit(code || 0));
+        } catch (err) {
+          console.log(`${c.red}Chat error:${c.reset} ${err.message}`);
         }
+        process.exit(0);
       }
       return;
     }