ac-framework 1.9.5 → 1.9.7

package/src/agents/runtime.js

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { COLLAB_ROLES } from './constants.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const runnerPath = resolve(__dirname, '../../bin/acfm.js');
+
+export function roleLogPath(sessionDir, role) {
+  return resolve(sessionDir, `${role}.log`);
+}
+
+export function runTmux(command, args, options = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || process.cwd(),
+      stdio: options.stdio || 'pipe',
+      env: process.env,
+    });
+
+    let stderr = '';
+    let stdout = '';
+    if (child.stderr) {
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
+    if (child.stdout) {
+      child.stdout.on('data', (chunk) => {
+        stdout += chunk.toString();
+      });
+    }
+
+    child.on('error', rejectPromise);
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolvePromise({ stdout, stderr });
+        return;
+      }
+      rejectPromise(new Error(stderr.trim() || `${command} exited with code ${code}`));
+    });
+  });
+}
+
+export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
+  const role0 = COLLAB_ROLES[0];
+  const role0Log = roleLogPath(sessionDir, role0);
+  await runTmux('tmux', [
+    'new-session',
+    '-d',
+    '-s',
+    sessionName,
+    '-n',
+    role0,
+    `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role0} 2>&1 | tee -a "${role0Log}"'`,
+  ]);
+
+  for (let idx = 1; idx < COLLAB_ROLES.length; idx += 1) {
+    const role = COLLAB_ROLES[idx];
+    const roleLog = roleLogPath(sessionDir, role);
+    await runTmux('tmux', [
+      'split-window',
+      '-t',
+      sessionName,
+      '-v',
+      `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role} 2>&1 | tee -a "${roleLog}"'`,
+    ]);
+  }
+
+  await runTmux('tmux', ['select-layout', '-t', sessionName, 'tiled']);
+  await runTmux('tmux', ['set-option', '-t', sessionName, 'pane-border-status', 'top']);
+  await runTmux('tmux', ['set-option', '-t', sessionName, 'pane-border-format', '#{pane_index}:#{pane_title}']);
+}
+
+export async function tmuxSessionExists(sessionName) {
+  try {
+    await runTmux('tmux', ['has-session', '-t', sessionName]);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/agents/state-store.js

@@ -8,6 +8,7 @@ import {
   SESSION_ROOT_DIR,
   CURRENT_SESSION_FILE,
 } from './constants.js';
+import { sanitizeRoleModels } from './model-selection.js';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -53,6 +54,8 @@ function initialState(task, options = {}) {
     roles: options.roles?.length ? options.roles : COLLAB_ROLES,
     workingDirectory: options.workingDirectory || process.cwd(),
     model: options.model || null,
+    roleModels: sanitizeRoleModels(options.roleModels),
+    opencodeBin: options.opencodeBin || null,
     tmuxSessionName: options.tmuxSessionName || null,
     messages: [
       {
@@ -106,7 +109,6 @@ export async function saveSessionState(state) {
     updatedAt: new Date().toISOString(),
   };
   await writeFile(getSessionStatePath(updated.sessionId), JSON.stringify(updated, null, 2) + '\n', 'utf8');
-  await writeCurrentSession(updated.sessionId, updated.updatedAt);
   return updated;
 }
 

package/src/commands/agents.js

@@ -1,18 +1,18 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import {
   COLLAB_ROLES,
   COLLAB_SYSTEM_NAME,
   CURRENT_SESSION_FILE,
   DEFAULT_MAX_ROUNDS,
+  DEFAULT_SYNAPSE_MODEL,
   SESSION_ROOT_DIR,
 } from '../agents/constants.js';
+import { runOpenCodePrompt } from '../agents/opencode-client.js';
 import { runWorkerIteration } from '../agents/orchestrator.js';
 import {
   addUserMessage,
@@ -26,7 +26,15 @@ import {
   setCurrentSession,
   stopSession,
 } from '../agents/state-store.js';
-import { ensureCollabDependencies, hasCommand } from '../services/dependency-installer.js';
+import { roleLogPath, runTmux, spawnTmuxSession, tmuxSessionExists } from '../agents/runtime.js';
+import { getAgentsConfigPath, loadAgentsConfig, updateAgentsConfig } from '../agents/config-store.js';
+import {
+  buildEffectiveRoleModels,
+  isValidModelId,
+  normalizeModelId,
+  sanitizeRoleModels,
+} from '../agents/model-selection.js';
+import { ensureCollabDependencies, hasCommand, resolveCommandPath } from '../services/dependency-installer.js';
 
 function output(data, json) {
   if (json) {
@@ -34,79 +42,12 @@ function output(data, json) {
   }
 }
 
-function roleLogPath(sessionDir, role) {
-  return resolve(sessionDir, `${role}.log`);
-}
-
 function tailLines(text, maxLines) {
   const lines = text.split('\n');
   const sliced = lines.slice(Math.max(lines.length - maxLines, 0));
   return sliced.join('\n').trimEnd();
 }
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const runnerPath = resolve(__dirname, '../../bin/acfm.js');
-
-function runTmux(command, args, options = {}) {
-  return new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd || process.cwd(),
-      stdio: options.stdio || 'pipe',
-      env: process.env,
-    });
-
-    let stderr = '';
-    let stdout = '';
-    if (child.stderr) {
-      child.stderr.on('data', (chunk) => {
-        stderr += chunk.toString();
-      });
-    }
-    if (child.stdout) {
-      child.stdout.on('data', (chunk) => {
-        stdout += chunk.toString();
-      });
-    }
-
-    child.on('error', rejectPromise);
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolvePromise({ stdout, stderr });
-        return;
-      }
-      rejectPromise(new Error(stderr.trim() || `${command} exited with code ${code}`));
-    });
-  });
-}
-
-async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
-  const role0 = COLLAB_ROLES[0];
-  await runTmux('tmux', [
-    'new-session',
-    '-d',
-    '-s',
-    sessionName,
-    '-n',
-    role0,
-    `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role0} >> "${roleLogPath(sessionDir, role0)}" 2>&1'`,
-  ]);
-
-  for (let idx = 1; idx < COLLAB_ROLES.length; idx += 1) {
-    const role = COLLAB_ROLES[idx];
-    await runTmux('tmux', [
-      'split-window',
-      '-t',
-      sessionName,
-      '-v',
-      `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role} >> "${roleLogPath(sessionDir, role)}" 2>&1'`,
-    ]);
-  }
-
-  await runTmux('tmux', ['select-layout', '-t', sessionName, 'tiled']);
-  await runTmux('tmux', ['set-option', '-t', sessionName, 'pane-border-status', 'top']);
-  await runTmux('tmux', ['set-option', '-t', sessionName, 'pane-border-format', '#{pane_index}:#{pane_title}']);
-}
-
 async function ensureSessionId(required = true) {
   const sessionId = await loadCurrentSessionId();
   if (!sessionId && required) {
@@ -124,18 +65,20 @@ function printStartSummary(state) {
   console.log();
   console.log(chalk.cyan('Attach with:'));
   console.log(chalk.white(`  tmux attach -t ${state.tmuxSessionName}`));
+  console.log(chalk.white('  acfm agents live'));
   console.log();
   console.log(chalk.cyan('Interact with:'));
   console.log(chalk.white('  acfm agents send "your message"'));
 }
 
 function toMarkdownTranscript(state, transcript) {
+  const displayedRound = Math.min(state.round, state.maxRounds);
   const lines = [
     `# SynapseGrid Session ${state.sessionId}`,
     '',
     `- Task: ${state.task}`,
     `- Status: ${state.status}`,
-    `- Rounds: ${state.round}/${state.maxRounds}`,
+    `- Rounds: ${displayedRound}/${state.maxRounds}`,
     `- Roles: ${state.roles.join(', ')}`,
     `- Created: ${state.createdAt}`,
     `- Updated: ${state.updatedAt}`,
@@ -155,6 +98,51 @@ function toMarkdownTranscript(state, transcript) {
   return lines.join('\n');
 }
 
+function parseRoleModelOptions(opts) {
+  return sanitizeRoleModels({
+    planner: opts.modelPlanner,
+    critic: opts.modelCritic,
+    coder: opts.modelCoder,
+    reviewer: opts.modelReviewer,
+  });
+}
+
+function assertValidModelIdOrNull(label, value) {
+  const normalized = normalizeModelId(value);
+  if (!normalized) return null;
+  if (!isValidModelId(normalized)) {
+    throw new Error(`${label} must be in provider/model format`);
+  }
+  return normalized;
+}
+
+function printModelConfig(state) {
+  const effectiveRoleModels = buildEffectiveRoleModels(state, state.model || null);
+  console.log(chalk.bold('\nModel configuration'));
+  console.log(chalk.dim(`  Global fallback: ${state.model || '(opencode default)'}`));
+  for (const role of COLLAB_ROLES) {
+    const configured = state.roleModels?.[role] || '-';
+    const effective = effectiveRoleModels[role] || '(opencode default)';
+    console.log(chalk.dim(`  ${role.padEnd(8)} configured=${configured} effective=${effective}`));
+  }
+}
+
+async function preflightModel({ opencodeBin, model, cwd }) {
+  const selected = normalizeModelId(model) || DEFAULT_SYNAPSE_MODEL;
+  try {
+    await runOpenCodePrompt({
+      prompt: 'Reply with exactly: OK',
+      cwd,
+      model: selected,
+      binaryPath: opencodeBin,
+      timeoutMs: 45000,
+    });
+    return { ok: true, model: selected };
+  } catch (error) {
+    return { ok: false, model: selected, error: error.message };
+  }
+}
+
 export function agentsCommand() {
   const agents = new Command('agents')
     .description(`${COLLAB_SYSTEM_NAME} — collaborative multi-agent system powered by OpenCode`);
@@ -295,6 +283,31 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('live')
+    .description('Attach to live tmux collaboration view (all agent panes)')
+    .option('--readonly', 'Attach in read-only mode', false)
+    .action(async (opts) => {
+      try {
+        const sessionId = await ensureSessionId(true);
+        const state = await loadSessionState(sessionId);
+        if (!state.tmuxSessionName) {
+          throw new Error('No tmux session registered for active collaborative session');
+        }
+        const tmuxExists = await tmuxSessionExists(state.tmuxSessionName);
+        if (!tmuxExists) {
+          throw new Error(`tmux session ${state.tmuxSessionName} no longer exists. Run: acfm agents resume`);
+        }
+        const args = ['attach'];
+        if (opts.readonly) args.push('-r');
+        args.push('-t', state.tmuxSessionName);
+        await runTmux('tmux', args, { stdio: 'inherit' });
+      } catch (error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   agents
     .command('resume')
     .description('Resume a previous session and optionally recreate tmux workers')
@@ -308,15 +321,7 @@ export function agentsCommand() {
         let state = await loadSessionState(sessionId);
 
         const tmuxSessionName = state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
-        let tmuxExists = false;
-        if (hasCommand('tmux')) {
-          try {
-            await runTmux('tmux', ['has-session', '-t', tmuxSessionName]);
-            tmuxExists = true;
-          } catch {
-            tmuxExists = false;
-          }
-        }
+        const tmuxExists = hasCommand('tmux') ? await tmuxSessionExists(tmuxSessionName) : false;
 
         if (!tmuxExists && opts.recreate) {
           if (!hasCommand('tmux')) {
@@ -410,6 +415,136 @@ export function agentsCommand() {
       }
     });
 
+  const model = agents
+    .command('model')
+    .description('Manage default SynapseGrid model configuration');
+
+  model
+    .command('get')
+    .description('Show configured default global/per-role models')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const config = await loadAgentsConfig();
+        const payload = {
+          configPath: getAgentsConfigPath(),
+          defaultModel: config.agents.defaultModel,
+          defaultRoleModels: config.agents.defaultRoleModels,
+        };
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid default models'));
+          console.log(chalk.dim(`Config: ${payload.configPath}`));
+          console.log(chalk.dim(`Global fallback: ${payload.defaultModel || '(none)'}`));
+          for (const role of COLLAB_ROLES) {
+            console.log(chalk.dim(`- ${role}: ${payload.defaultRoleModels[role] || '(none)'}`));
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  model
+    .command('set <modelId>')
+    .description('Set default model globally or for a specific role')
+    .option('--role <role>', 'planner|critic|coder|reviewer|all', 'all')
+    .option('--json', 'Output as JSON')
+    .action(async (modelId, opts) => {
+      try {
+        const role = String(opts.role || 'all');
+        const normalized = assertValidModelIdOrNull('model', modelId);
+        if (!normalized) throw new Error('model must be provided');
+        if (role !== 'all' && !COLLAB_ROLES.includes(role)) {
+          throw new Error('--role must be planner|critic|coder|reviewer|all');
+        }
+
+        const updated = await updateAgentsConfig((current) => {
+          const next = {
+            agents: {
+              defaultModel: current.agents.defaultModel,
+              defaultRoleModels: { ...current.agents.defaultRoleModels },
+            },
+          };
+          if (role === 'all') {
+            next.agents.defaultModel = normalized;
+          } else {
+            next.agents.defaultRoleModels = {
+              ...next.agents.defaultRoleModels,
+              [role]: normalized,
+            };
+          }
+          return next;
+        });
+
+        const payload = {
+          success: true,
+          configPath: getAgentsConfigPath(),
+          defaultModel: updated.agents.defaultModel,
+          defaultRoleModels: updated.agents.defaultRoleModels,
+        };
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.green('✓ SynapseGrid model configuration updated'));
+          console.log(chalk.dim(`  Config: ${payload.configPath}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  model
+    .command('clear')
+    .description('Clear default model globally or for a specific role')
+    .option('--role <role>', 'planner|critic|coder|reviewer|all', 'all')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const role = String(opts.role || 'all');
+        if (role !== 'all' && !COLLAB_ROLES.includes(role)) {
+          throw new Error('--role must be planner|critic|coder|reviewer|all');
+        }
+
+        const updated = await updateAgentsConfig((current) => {
+          const next = {
+            agents: {
+              defaultModel: current.agents.defaultModel,
+              defaultRoleModels: { ...current.agents.defaultRoleModels },
+            },
+          };
+          if (role === 'all') {
+            next.agents.defaultModel = DEFAULT_SYNAPSE_MODEL;
+            next.agents.defaultRoleModels = {};
+          } else {
+            const currentRoles = { ...next.agents.defaultRoleModels };
+            delete currentRoles[role];
+            next.agents.defaultRoleModels = currentRoles;
+          }
+          return next;
+        });
+
+        const payload = {
+          success: true,
+          configPath: getAgentsConfigPath(),
+          defaultModel: updated.agents.defaultModel,
+          defaultRoleModels: updated.agents.defaultRoleModels,
+        };
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.green('✓ SynapseGrid model configuration cleared'));
+          console.log(chalk.dim(`  Config: ${payload.configPath}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   agents
     .command('export')
     .description('Export collaborative transcript')
@@ -459,6 +594,10 @@ export function agentsCommand() {
     .requiredOption('--task <text>', 'Initial task from user')
     .option('--rounds <n>', 'Maximum collaboration rounds', String(DEFAULT_MAX_ROUNDS))
     .option('--model <id>', 'Model to use (provider/model)')
+    .option('--model-planner <id>', 'Model for planner role (provider/model)')
+    .option('--model-critic <id>', 'Model for critic role (provider/model)')
+    .option('--model-coder <id>', 'Model for coder role (provider/model)')
+    .option('--model-reviewer <id>', 'Model for reviewer role (provider/model)')
     .option('--cwd <path>', 'Working directory for agents', process.cwd())
     .option('--attach', 'Attach tmux immediately after start', false)
     .option('--json', 'Output as JSON')
@@ -470,6 +609,10 @@ export function agentsCommand() {
         if (!hasCommand('tmux')) {
           throw new Error('tmux is not installed. Run: acfm agents setup');
         }
+        const opencodeBin = resolveCommandPath('opencode');
+        if (!opencodeBin) {
+          throw new Error('OpenCode binary not found. Run: acfm agents setup');
+        }
 
         await mkdir(SESSION_ROOT_DIR, { recursive: true });
         const maxRounds = Number.parseInt(opts.rounds, 10);
@@ -477,11 +620,43 @@ export function agentsCommand() {
           throw new Error('--rounds must be a positive integer');
         }
 
+        const config = await loadAgentsConfig();
+        const cliModel = assertValidModelIdOrNull('--model', opts.model || null);
+        const cliRoleModels = parseRoleModelOptions(opts);
+        for (const [role, model] of Object.entries(cliRoleModels)) {
+          if (!isValidModelId(model)) {
+            throw new Error(`--model-${role} must be in provider/model format`);
+          }
+        }
+        const defaultRoleModels = sanitizeRoleModels(config.agents.defaultRoleModels);
+        const roleModels = {
+          ...defaultRoleModels,
+          ...cliRoleModels,
+        };
+        const globalModel = cliModel || config.agents.defaultModel || DEFAULT_SYNAPSE_MODEL;
+
+        const modelsToCheck = new Set([globalModel, ...Object.values(roleModels)]);
+        for (const modelToCheck of modelsToCheck) {
+          const preflight = await preflightModel({
+            opencodeBin,
+            model: modelToCheck,
+            cwd: resolve(opts.cwd),
+          });
+          if (!preflight.ok) {
+            throw new Error(
+              `Model preflight failed for ${preflight.model}: ${preflight.error}. ` +
+              'Check OpenCode auth/providers with: opencode auth list, opencode models'
+            );
+          }
+        }
+
         const state = await createSession(opts.task, {
           roles: COLLAB_ROLES,
           maxRounds,
-          model: opts.model || null,
+          model: globalModel,
+          roleModels,
           workingDirectory: resolve(opts.cwd),
+          opencodeBin,
         });
         const tmuxSessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
         const sessionDir = getSessionDir(state.sessionId);
@@ -499,6 +674,7 @@ export function agentsCommand() {
         output({ sessionId: updated.sessionId, tmuxSessionName, status: updated.status }, opts.json);
         if (!opts.json) {
           printStartSummary(updated);
+          printModelConfig(updated);
         }
 
         if (opts.attach) {
@@ -538,14 +714,21 @@ export function agentsCommand() {
       try {
         const sessionId = await ensureSessionId(true);
         const state = await loadSessionState(sessionId);
-        output(state, opts.json);
+        const effectiveRoleModels = buildEffectiveRoleModels(state, state.model || null);
+        output({ ...state, effectiveRoleModels }, opts.json);
         if (!opts.json) {
           console.log(chalk.bold(`${COLLAB_SYSTEM_NAME} Status`));
           console.log(chalk.dim(`Session: ${state.sessionId}`));
           console.log(chalk.dim(`Status: ${state.status}`));
-          console.log(chalk.dim(`Round: ${state.round}/${state.maxRounds}`));
+          console.log(chalk.dim(`Round: ${Math.min(state.round, state.maxRounds)}/${state.maxRounds}`));
           console.log(chalk.dim(`Active agent: ${state.activeAgent || 'none'}`));
           console.log(chalk.dim(`Messages: ${state.messages.length}`));
+          console.log(chalk.dim(`Global model: ${state.model || '(opencode default)'}`));
+          for (const role of COLLAB_ROLES) {
+            const configured = state.roleModels?.[role] || '-';
+            const effective = effectiveRoleModels[role] || '(opencode default)';
+            console.log(chalk.dim(`  ${role.padEnd(8)} configured=${configured} effective=${effective}`));
+          }
           if (state.tmuxSessionName) {
             console.log(chalk.dim(`tmux: ${state.tmuxSessionName}`));
           }
@@ -603,6 +786,7 @@ export function agentsCommand() {
 
       while (true) {
         try {
+          console.log(`[${role}] polling session ${opts.session}`);
           const state = await loadSessionState(opts.session);
           if (!state.roles.includes(role)) {
             console.log(`[${role}] role not configured in session. exiting.`);
@@ -613,13 +797,20 @@ export function agentsCommand() {
             process.exit(0);
           }
 
+          if (state.activeAgent === role) {
+            console.log(`[${role}] executing turn with model=${state.roleModels?.[role] || state.model || DEFAULT_SYNAPSE_MODEL}`);
+          }
           const nextState = await runWorkerIteration(opts.session, role, {
             cwd: state.workingDirectory || process.cwd(),
             model: state.model || null,
+            opencodeBin: state.opencodeBin || resolveCommandPath('opencode') || undefined,
+            timeoutMs: 180000,
           });
           const latest = nextState.messages[nextState.messages.length - 1];
           if (latest?.from === role) {
             console.log(`[${role}] message emitted (${latest.content.length} chars)`);
+          } else if (nextState.activeAgent && nextState.activeAgent !== role) {
+            console.log(`[${role}] waiting for active role=${nextState.activeAgent}`);
           }
         } catch (error) {
           console.error(`[${role}] loop error: ${error.message}`);
@@ -629,5 +820,50 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('doctor')
+    .description('Run diagnostics for SynapseGrid/OpenCode runtime')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        const tmuxInstalled = hasCommand('tmux');
+        const cfg = await loadAgentsConfig();
+        const defaultModel = cfg.agents.defaultModel || DEFAULT_SYNAPSE_MODEL;
+        const result = {
+          opencodeBin,
+          tmuxInstalled,
+          defaultModel,
+          defaultRoleModels: cfg.agents.defaultRoleModels,
+          preflight: null,
+        };
+
+        if (opencodeBin) {
+          result.preflight = await preflightModel({
+            opencodeBin,
+            model: defaultModel,
+            cwd: process.cwd(),
+          });
+        } else {
+          result.preflight = { ok: false, error: 'OpenCode binary not found' };
+        }
+
+        output(result, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid doctor'));
+          console.log(chalk.dim(`opencode: ${opencodeBin || 'not found'}`));
+          console.log(chalk.dim(`tmux: ${tmuxInstalled ? 'installed' : 'not installed'}`));
+          console.log(chalk.dim(`default model: ${defaultModel}`));
+          console.log(chalk.dim(`preflight: ${result.preflight?.ok ? 'ok' : `failed - ${result.preflight?.error || 'unknown error'}`}`));
+        }
+
+        if (!result.preflight?.ok) process.exit(1);
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   return agents;
 }