ac-framework 1.9.6 → 1.9.7

package/README.md

@@ -141,6 +141,7 @@ Each role runs in turn against a shared, accumulating context so outputs from on
 | Command | Description |
 |---|---|
 | `acfm agents setup` | Install optional dependencies (`opencode` and `tmux`) |
+| `acfm agents doctor` | Validate OpenCode/tmux/model preflight before start |
 | `acfm agents install-mcps` | Install SynapseGrid MCP server for detected assistants |
 | `acfm agents uninstall-mcps` | Remove SynapseGrid MCP server from assistants |
 | `acfm agents start --task "..." --model-coder provider/model` | Start session with optional per-role models |
@@ -164,6 +165,8 @@ Each role runs in turn against a shared, accumulating context so outputs from on
 - Inspect worker errors quickly with `acfm agents logs --role all --lines 120`.
 - MCP starts can now create tmux workers directly; if your assistant used headless steps before, start a new session and ensure worker spawning is enabled.
 - Configure role models directly at start (for example `--model-planner`, `--model-coder`) or persist defaults via `acfm agents model set`.
+- Default SynapseGrid model fallback is `opencode/minimax-m2.5-free`.
+- Run `acfm agents doctor` when panes look idle to confirm model/provider preflight health.
 
 ### Spec Workflow
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ac-framework",
-  "version": "1.9.6",
+  "version": "1.9.7",
   "description": "Agentic Coding Framework - Multi-assistant configuration system with OpenSpec workflows",
   "main": "src/index.js",
   "exports": {

package/src/agents/config-store.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { DEFAULT_SYNAPSE_MODEL } from './constants.js';
 import { sanitizeRoleModels, normalizeModelId } from './model-selection.js';
 
 const ACFM_DIR = join(homedir(), '.acfm');
@@ -11,7 +12,7 @@ function normalizeConfig(raw) {
   const agents = raw?.agents && typeof raw.agents === 'object' ? raw.agents : {};
   return {
     agents: {
-      defaultModel: normalizeModelId(agents.defaultModel) || null,
+      defaultModel: normalizeModelId(agents.defaultModel) || DEFAULT_SYNAPSE_MODEL,
       defaultRoleModels: sanitizeRoleModels(agents.defaultRoleModels),
     },
   };

package/src/agents/constants.js

@@ -4,5 +4,6 @@ import { join } from 'node:path';
 export const COLLAB_SYSTEM_NAME = 'SynapseGrid';
 export const COLLAB_ROLES = ['planner', 'critic', 'coder', 'reviewer'];
 export const DEFAULT_MAX_ROUNDS = 3;
+export const DEFAULT_SYNAPSE_MODEL = 'opencode/minimax-m2.5-free';
 export const SESSION_ROOT_DIR = join(homedir(), '.acfm', 'synapsegrid');
 export const CURRENT_SESSION_FILE = join(SESSION_ROOT_DIR, 'current-session.json');

package/src/agents/opencode-client.js

@@ -1,9 +1,29 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
+import { spawn } from 'node:child_process';
 
 function parseOpenCodeRunOutput(stdout) {
+  const ndjsonLines = stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  if (ndjsonLines.length > 0) {
+    const textChunks = [];
+    for (const line of ndjsonLines) {
+      try {
+        const event = JSON.parse(line);
+        const text = event?.part?.text;
+        if (typeof text === 'string' && text.trim()) {
+          textChunks.push(text.trim());
+        }
+      } catch {
+        // ignore malformed lines and continue
+      }
+    }
+    if (textChunks.length > 0) {
+      return textChunks.join('\n\n');
+    }
+  }
+
   try {
     const parsed = JSON.parse(stdout);
     if (Array.isArray(parsed)) {
@@ -33,10 +53,48 @@ export async function runOpenCodePrompt({ prompt, cwd, model, agent, timeoutMs =
   }
   args.push('--', prompt);
 
-  const { stdout, stderr } = await execFileAsync(binary, args, {
-    cwd,
-    timeout: timeoutMs,
-    maxBuffer: 10 * 1024 * 1024,
+  const { stdout, stderr } = await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(binary, args, {
+      cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let out = '';
+    let err = '';
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+      setTimeout(() => child.kill('SIGKILL'), 1500).unref();
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      out += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+      err += chunk.toString();
+    });
+
+    child.on('error', (error) => {
+      clearTimeout(timer);
+      rejectPromise(error);
+    });
+
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        rejectPromise(new Error(`opencode timed out after ${timeoutMs}ms`));
+        return;
+      }
+      if (code !== 0) {
+        const details = [err.trim(), out.trim()].filter(Boolean).join(' | ');
+        rejectPromise(new Error(details || `opencode exited with code ${code}${signal ? ` (${signal})` : ''}`));
+        return;
+      }
+      resolvePromise({ stdout: out, stderr: err });
+    });
   });
 
   const parsed = parseOpenCodeRunOutput(stdout);

package/src/agents/runtime.js

@@ -44,6 +44,7 @@ export function runTmux(command, args, options = {}) {
 
 export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
   const role0 = COLLAB_ROLES[0];
+  const role0Log = roleLogPath(sessionDir, role0);
   await runTmux('tmux', [
     'new-session',
     '-d',
@@ -51,17 +52,18 @@ export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
     sessionName,
     '-n',
     role0,
-    `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role0} >> "${roleLogPath(sessionDir, role0)}" 2>&1'`,
+    `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} >> "${roleLogPath(sessionDir, role)}" 2>&1'`,
+      `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role} 2>&1 | tee -a "${roleLog}"'`,
     ]);
   }
 

package/src/agents/state-store.js

@@ -109,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

@@ -9,8 +9,10 @@ import {
   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,
@@ -125,6 +127,22 @@ function printModelConfig(state) {
   }
 }
 
+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`);
@@ -276,6 +294,10 @@ export function agentsCommand() {
         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);
@@ -495,7 +517,7 @@ export function agentsCommand() {
             },
           };
           if (role === 'all') {
-            next.agents.defaultModel = null;
+            next.agents.defaultModel = DEFAULT_SYNAPSE_MODEL;
             next.agents.defaultRoleModels = {};
           } else {
             const currentRoles = { ...next.agents.defaultRoleModels };
@@ -611,7 +633,22 @@ export function agentsCommand() {
           ...defaultRoleModels,
           ...cliRoleModels,
         };
-        const globalModel = cliModel || config.agents.defaultModel || null;
+        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,
@@ -749,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.`);
@@ -759,14 +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}`);
@@ -776,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;
 }