ac-framework 1.9.7 → 1.9.9

package/src/commands/agents.js

@@ -1,7 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import {
@@ -12,7 +13,7 @@ import {
   DEFAULT_SYNAPSE_MODEL,
   SESSION_ROOT_DIR,
 } from '../agents/constants.js';
-import { runOpenCodePrompt } from '../agents/opencode-client.js';
+import { listOpenCodeModels, runOpenCodePrompt } from '../agents/opencode-client.js';
 import { runWorkerIteration } from '../agents/orchestrator.js';
 import {
   addUserMessage,
@@ -25,8 +26,18 @@ import {
   saveSessionState,
   setCurrentSession,
   stopSession,
+  writeMeetingSummary,
 } from '../agents/state-store.js';
-import { roleLogPath, runTmux, spawnTmuxSession, tmuxSessionExists } from '../agents/runtime.js';
+import {
+  roleLogPath,
+  runTmux,
+  runZellij,
+  spawnTmuxSession,
+  spawnZellijSession,
+  tmuxSessionExists,
+  zellijSessionExists,
+  resolveMultiplexer,
+} from '../agents/runtime.js';
 import { getAgentsConfigPath, loadAgentsConfig, updateAgentsConfig } from '../agents/config-store.js';
 import {
   buildEffectiveRoleModels,
@@ -59,18 +70,53 @@ async function ensureSessionId(required = true) {
 function printStartSummary(state) {
   console.log(chalk.green(`✓ ${COLLAB_SYSTEM_NAME} session started`));
   console.log(chalk.dim(`  Session: ${state.sessionId}`));
-  console.log(chalk.dim(`  tmux: ${state.tmuxSessionName}`));
+  const multiplexer = state.multiplexer || 'auto';
+  const muxSessionName = state.multiplexerSessionName || state.tmuxSessionName || '-';
+  console.log(chalk.dim(`  Multiplexer: ${multiplexer}`));
+  console.log(chalk.dim(`  Session name: ${muxSessionName}`));
   console.log(chalk.dim(`  Task: ${state.task}`));
   console.log(chalk.dim(`  Roles: ${state.roles.join(', ')}`));
   console.log();
   console.log(chalk.cyan('Attach with:'));
-  console.log(chalk.white(`  tmux attach -t ${state.tmuxSessionName}`));
+  if (multiplexer === 'zellij') {
+    console.log(chalk.white(`  zellij attach ${muxSessionName}`));
+  } else {
+    console.log(chalk.white(`  tmux attach -t ${muxSessionName}`));
+  }
   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 validateMultiplexer(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!['auto', 'zellij', 'tmux'].includes(normalized)) {
+    throw new Error('--mux must be one of: auto|zellij|tmux');
+  }
+  return normalized;
+}
+
+function sessionMuxName(state) {
+  return state.multiplexerSessionName || state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+}
+
+async function sessionExistsForMux(multiplexer, sessionName) {
+  if (multiplexer === 'zellij') return zellijSessionExists(sessionName);
+  return tmuxSessionExists(sessionName);
+}
+
+async function attachToMux(multiplexer, sessionName, readonly = false) {
+  if (multiplexer === 'zellij') {
+    await runZellij(['attach', sessionName], { stdio: 'inherit' });
+    return;
+  }
+  const args = ['attach'];
+  if (readonly) args.push('-r');
+  args.push('-t', sessionName);
+  await runTmux('tmux', args, { stdio: 'inherit' });
+}
+
 function toMarkdownTranscript(state, transcript) {
   const displayedRound = Math.min(state.round, state.maxRounds);
   const lines = [
@@ -127,6 +173,39 @@ function printModelConfig(state) {
   }
 }
 
+function groupModelsByProvider(models) {
+  const grouped = new Map();
+  for (const model of models) {
+    const [provider, ...rest] = model.split('/');
+    if (!provider || rest.length === 0) continue;
+    const modelName = rest.join('/');
+    if (!grouped.has(provider)) grouped.set(provider, []);
+    grouped.get(provider).push(modelName);
+  }
+  for (const [provider, modelNames] of grouped.entries()) {
+    grouped.set(provider, [...new Set(modelNames)].sort((a, b) => a.localeCompare(b)));
+  }
+  return grouped;
+}
+
+function runSummary(state) {
+  const run = state.run || {};
+  const events = Array.isArray(run.events) ? run.events.length : 0;
+  return {
+    status: run.status || 'idle',
+    runId: run.runId || null,
+    currentRole: run.currentRole || null,
+    lastError: run.lastError || null,
+    events,
+  };
+}
+
+async function readSessionArtifact(sessionId, filename) {
+  const path = resolve(getSessionDir(sessionId), filename);
+  if (!existsSync(path)) return null;
+  return readFile(path, 'utf8');
+}
+
 async function preflightModel({ opencodeBin, model, cwd }) {
   const selected = normalizeModelId(model) || DEFAULT_SYNAPSE_MODEL;
   try {
@@ -147,12 +226,51 @@ export function agentsCommand() {
   const agents = new Command('agents')
     .description(`${COLLAB_SYSTEM_NAME} — collaborative multi-agent system powered by OpenCode`);
 
+  agents.addHelpText('after', `
+Examples:
+  acfm agents start --task "Implement auth flow" --mux auto
+  acfm agents setup
+  acfm agents runtime get
+  acfm agents runtime set zellij
+  acfm agents model choose
+  acfm agents model list
+  acfm agents transcript --role all --limit 40
+  acfm agents summary
+  acfm agents export --format md --out ./session.md
+`);
+
   agents
     .command('setup')
-    .description('Install optional collaboration dependencies (OpenCode + tmux)')
+    .description('Install optional collaboration dependencies (OpenCode + zellij/tmux)')
+    .option('--yes', 'Install dependencies without interactive confirmation', false)
     .option('--json', 'Output as JSON')
     .action(async (opts) => {
-      const result = ensureCollabDependencies();
+      let installZellij = true;
+      let installTmux = true;
+
+      if (!opts.yes && !opts.json) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'installZellij',
+            message: 'Install zellij (recommended, multiplatform backend)?',
+            default: true,
+          },
+          {
+            type: 'confirm',
+            name: 'installTmux',
+            message: 'Install tmux as fallback backend?',
+            default: true,
+          },
+        ]);
+        installZellij = Boolean(answers.installZellij);
+        installTmux = Boolean(answers.installTmux);
+      }
+
+      const result = ensureCollabDependencies({
+        installZellij,
+        installTmux,
+      });
       let collabMcp = null;
 
       if (result.success) {
@@ -165,7 +283,9 @@ export function agentsCommand() {
       if (!opts.json) {
         const oLabel = result.opencode.success ? chalk.green('ok') : chalk.red('failed');
         const tLabel = result.tmux.success ? chalk.green('ok') : chalk.red('failed');
+        const zLabel = result.zellij.success ? chalk.green('ok') : chalk.red('failed');
         console.log(`OpenCode: ${oLabel} - ${result.opencode.message}`);
+        console.log(`zellij:   ${zLabel} - ${result.zellij.message}`);
         console.log(`tmux:     ${tLabel} - ${result.tmux.message}`);
         if (collabMcp) {
           console.log(`Collab MCP: ${chalk.green('ok')} - installed ${collabMcp.success}/${collabMcp.installed} on detected assistants`);
@@ -252,10 +372,10 @@ export function agentsCommand() {
           }
           console.log(chalk.bold('SynapseGrid Sessions'));
           for (const item of sessions) {
-            console.log(
+          console.log(
               `${chalk.cyan(item.sessionId.slice(0, 8))}  ${item.status.padEnd(10)}  ` +
               `round ${String(item.round).padStart(2)}/${String(item.maxRounds).padEnd(2)}  ` +
-              `${item.tmuxSessionName || '-'}  ${item.task}`
+              `${item.multiplexer || 'auto'}:${item.multiplexerSessionName || item.tmuxSessionName || '-'}  ${item.task}`
             );
           }
         }
@@ -268,15 +388,17 @@ export function agentsCommand() {
 
   agents
     .command('attach')
-    .description('Attach terminal to active SynapseGrid tmux session')
+    .description('Attach terminal to active SynapseGrid multiplexer session')
     .action(async () => {
       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 multiplexer = state.multiplexer || 'tmux';
+        const muxSessionName = sessionMuxName(state);
+        if (!muxSessionName) {
+          throw new Error('No multiplexer session registered for active collaborative session');
         }
-        await runTmux('tmux', ['attach', '-t', state.tmuxSessionName], { stdio: 'inherit' });
+        await attachToMux(multiplexer, muxSessionName, false);
       } catch (error) {
         console.error(chalk.red(`Error: ${error.message}`));
         process.exit(1);
@@ -285,23 +407,22 @@ export function agentsCommand() {
 
   agents
     .command('live')
-    .description('Attach to live tmux collaboration view (all agent panes)')
+    .description('Attach to live 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 multiplexer = state.multiplexer || 'tmux';
+        const muxSessionName = sessionMuxName(state);
+        if (!muxSessionName) {
+          throw new Error('No multiplexer 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 sessionExists = await sessionExistsForMux(multiplexer, muxSessionName);
+        if (!sessionExists) {
+          throw new Error(`${multiplexer} session ${muxSessionName} 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' });
+        await attachToMux(multiplexer, muxSessionName, Boolean(opts.readonly));
       } catch (error) {
         console.error(chalk.red(`Error: ${error.message}`));
         process.exit(1);
@@ -310,48 +431,60 @@ export function agentsCommand() {
 
   agents
     .command('resume')
-    .description('Resume a previous session and optionally recreate tmux workers')
+    .description('Resume a previous session and optionally recreate multiplexer workers')
     .option('--session <id>', 'Session ID to resume (defaults to current)')
-    .option('--no-recreate', 'Do not recreate tmux session/workers when missing')
-    .option('--no-attach', 'Do not attach tmux after resume')
+    .option('--no-recreate', 'Do not recreate multiplexer session/workers when missing')
+    .option('--no-attach', 'Do not attach multiplexer after resume')
     .option('--json', 'Output as JSON')
     .action(async (opts) => {
       try {
         const sessionId = opts.session || await ensureSessionId(true);
         let state = await loadSessionState(sessionId);
+        const multiplexer = state.multiplexer || 'tmux';
 
-        const tmuxSessionName = state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
-        const tmuxExists = hasCommand('tmux') ? await tmuxSessionExists(tmuxSessionName) : false;
+        if (multiplexer === 'zellij' && !hasCommand('zellij')) {
+          throw new Error('zellij is not installed. Run: acfm agents setup');
+        }
+        if (multiplexer === 'tmux' && !hasCommand('tmux')) {
+          throw new Error('tmux is not installed. Run: acfm agents setup');
+        }
 
-        if (!tmuxExists && opts.recreate) {
-          if (!hasCommand('tmux')) {
-            throw new Error('tmux is not installed. Run: acfm agents setup');
-          }
+        const muxSessionName = sessionMuxName(state);
+        const muxExists = await sessionExistsForMux(multiplexer, muxSessionName);
+
+        if (!muxExists && opts.recreate) {
           const sessionDir = getSessionDir(state.sessionId);
-          await spawnTmuxSession({ sessionName: tmuxSessionName, sessionDir, sessionId: state.sessionId });
+          if (multiplexer === 'zellij') {
+            await spawnZellijSession({ sessionName: muxSessionName, sessionDir, sessionId: state.sessionId });
+          } else {
+            await spawnTmuxSession({ sessionName: muxSessionName, sessionDir, sessionId: state.sessionId });
+          }
         }
 
         state = await saveSessionState({
           ...state,
           status: 'running',
-          tmuxSessionName,
+          multiplexer,
+          multiplexerSessionName: muxSessionName,
+          tmuxSessionName: multiplexer === 'tmux' ? muxSessionName : (state.tmuxSessionName || null),
         });
         await setCurrentSession(state.sessionId);
 
         output({
           sessionId: state.sessionId,
           status: state.status,
-          tmuxSessionName,
-          recreatedTmux: !tmuxExists && Boolean(opts.recreate),
+          multiplexer,
+          multiplexerSessionName: muxSessionName,
+          recreatedSession: !muxExists && Boolean(opts.recreate),
         }, opts.json);
 
         if (!opts.json) {
           console.log(chalk.green(`✓ Resumed session ${state.sessionId}`));
-          console.log(chalk.dim(`  tmux: ${tmuxSessionName}`));
+          console.log(chalk.dim(`  ${multiplexer}: ${muxSessionName}`));
         }
 
         if (opts.attach) {
-          await runTmux('tmux', ['attach', '-t', tmuxSessionName], { stdio: 'inherit' });
+          await attachToMux(multiplexer, muxSessionName, false);
         }
       } catch (error) {
         output({ error: error.message }, opts.json);
@@ -419,6 +552,123 @@ export function agentsCommand() {
     .command('model')
     .description('Manage default SynapseGrid model configuration');
 
+  const runtime = agents
+    .command('runtime')
+    .description('Manage SynapseGrid runtime backend settings');
+
+  runtime
+    .command('get')
+    .description('Show configured multiplexer backend')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const cfg = await loadAgentsConfig();
+        const configured = validateMultiplexer(cfg.agents.multiplexer || 'auto');
+        const resolved = resolveMultiplexer(configured, hasCommand('tmux'), hasCommand('zellij'));
+        const payload = {
+          configPath: getAgentsConfigPath(),
+          multiplexer: configured,
+          resolved,
+          available: {
+            zellij: hasCommand('zellij'),
+            tmux: hasCommand('tmux'),
+          },
+        };
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid runtime backend'));
+          console.log(chalk.dim(`Config: ${payload.configPath}`));
+          console.log(chalk.dim(`Configured: ${configured}`));
+          console.log(chalk.dim(`Resolved: ${resolved || 'none'}`));
+          console.log(chalk.dim(`zellij=${payload.available.zellij} tmux=${payload.available.tmux}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  runtime
+    .command('set <mux>')
+    .description('Set multiplexer backend: auto|zellij|tmux')
+    .option('--json', 'Output as JSON')
+    .action(async (mux, opts) => {
+      try {
+        const selected = validateMultiplexer(mux);
+        const updated = await updateAgentsConfig((current) => ({
+          agents: {
+            defaultModel: current.agents.defaultModel,
+            defaultRoleModels: { ...current.agents.defaultRoleModels },
+            multiplexer: selected,
+          },
+        }));
+        const resolved = resolveMultiplexer(updated.agents.multiplexer, hasCommand('tmux'), hasCommand('zellij'));
+        const payload = {
+          success: true,
+          configPath: getAgentsConfigPath(),
+          multiplexer: updated.agents.multiplexer,
+          resolved,
+        };
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.green('✓ SynapseGrid runtime backend updated'));
+          console.log(chalk.dim(`  Configured: ${payload.multiplexer}`));
+          console.log(chalk.dim(`  Resolved: ${payload.resolved || 'none'}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  model
+    .command('list')
+    .description('List available OpenCode models grouped by provider')
+    .option('--refresh', 'Refresh model cache from providers', false)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        if (!opencodeBin) {
+          throw new Error('OpenCode binary not found. Run: acfm agents setup');
+        }
+
+        const models = await listOpenCodeModels({
+          binaryPath: opencodeBin,
+          refresh: Boolean(opts.refresh),
+        });
+        const grouped = groupModelsByProvider(models);
+        const providers = [...grouped.keys()].sort((a, b) => a.localeCompare(b));
+
+        const payload = {
+          count: models.length,
+          providers: providers.map((provider) => ({
+            provider,
+            models: grouped.get(provider).map((name) => `${provider}/${name}`),
+          })),
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('Available OpenCode models'));
+          console.log(chalk.dim(`Total: ${models.length}`));
+          for (const provider of providers) {
+            const providerModels = grouped.get(provider) || [];
+            console.log(chalk.cyan(`\n${provider}`));
+            for (const modelName of providerModels) {
+              console.log(chalk.dim(`- ${provider}/${modelName}`));
+            }
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   model
     .command('get')
     .description('Show configured default global/per-role models')
@@ -430,6 +680,7 @@ export function agentsCommand() {
           configPath: getAgentsConfigPath(),
           defaultModel: config.agents.defaultModel,
           defaultRoleModels: config.agents.defaultRoleModels,
+          multiplexer: config.agents.multiplexer,
         };
         output(payload, opts.json);
         if (!opts.json) {
@@ -439,6 +690,116 @@ export function agentsCommand() {
           for (const role of COLLAB_ROLES) {
             console.log(chalk.dim(`- ${role}: ${payload.defaultRoleModels[role] || '(none)'}`));
           }
+          console.log(chalk.dim(`Multiplexer: ${payload.multiplexer || 'auto'}`));
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  model
+    .command('choose')
+    .description('Interactively choose a default model by provider and role')
+    .option('--refresh', 'Refresh model cache from providers', false)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const opencodeBin = resolveCommandPath('opencode');
+        if (!opencodeBin) {
+          throw new Error('OpenCode binary not found. Run: acfm agents setup');
+        }
+
+        const models = await listOpenCodeModels({
+          binaryPath: opencodeBin,
+          refresh: Boolean(opts.refresh),
+        });
+        if (models.length === 0) {
+          throw new Error('No models returned by OpenCode. Run: opencode auth list, opencode models --refresh');
+        }
+
+        const grouped = groupModelsByProvider(models);
+        const providerChoices = [...grouped.keys()]
+          .sort((a, b) => a.localeCompare(b))
+          .map((provider) => ({
+            name: `${provider} (${(grouped.get(provider) || []).length})`,
+            value: provider,
+          }));
+
+        const { provider } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'provider',
+            message: 'Select model provider',
+            choices: providerChoices,
+          },
+        ]);
+
+        const selectedProviderModels = grouped.get(provider) || [];
+        const { modelName } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'modelName',
+            message: `Select model from ${provider}`,
+            pageSize: 20,
+            choices: selectedProviderModels.map((name) => ({ name, value: name })),
+          },
+        ]);
+
+        const roleChoices = [
+          { name: 'Global fallback (all roles)', value: 'all' },
+          ...COLLAB_ROLES.map((role) => ({ name: `Role: ${role}`, value: role })),
+        ];
+        const { role } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'role',
+            message: 'Apply model to',
+            choices: roleChoices,
+          },
+        ]);
+
+        const modelId = `${provider}/${modelName}`;
+        const updated = await updateAgentsConfig((current) => {
+          const next = {
+            agents: {
+              defaultModel: current.agents.defaultModel,
+              defaultRoleModels: { ...current.agents.defaultRoleModels },
+              multiplexer: current.agents.multiplexer || 'auto',
+            },
+          };
+
+          if (role === 'all') {
+            next.agents.defaultModel = modelId;
+          } else {
+            next.agents.defaultRoleModels = {
+              ...next.agents.defaultRoleModels,
+              [role]: modelId,
+            };
+          }
+
+          return next;
+        });
+
+        const payload = {
+          success: true,
+          selected: {
+            role,
+            provider,
+            model: modelId,
+          },
+          configPath: getAgentsConfigPath(),
+          defaultModel: updated.agents.defaultModel,
+          defaultRoleModels: updated.agents.defaultRoleModels,
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.green('✓ SynapseGrid model selected and saved'));
+          console.log(chalk.dim(`  Target: ${role === 'all' ? 'global fallback' : `role ${role}`}`));
+          console.log(chalk.dim(`  Model: ${modelId}`));
+          console.log(chalk.dim(`  Config: ${payload.configPath}`));
         }
       } catch (error) {
         output({ error: error.message }, opts.json);
@@ -466,6 +827,7 @@ export function agentsCommand() {
             agents: {
               defaultModel: current.agents.defaultModel,
               defaultRoleModels: { ...current.agents.defaultRoleModels },
+              multiplexer: current.agents.multiplexer || 'auto',
             },
           };
           if (role === 'all') {
@@ -514,6 +876,7 @@ export function agentsCommand() {
             agents: {
               defaultModel: current.agents.defaultModel,
               defaultRoleModels: { ...current.agents.defaultRoleModels },
+              multiplexer: current.agents.multiplexer || 'auto',
             },
           };
           if (role === 'all') {
@@ -545,6 +908,83 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('transcript')
+    .description('Show collaborative transcript (optionally filtered by role)')
+    .option('--session <id>', 'Session ID (defaults to current)')
+    .option('--role <role>', 'Role filter (planner|critic|coder|reviewer|all)', 'all')
+    .option('--limit <n>', 'Max messages to display', '40')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const sessionId = opts.session || await ensureSessionId(true);
+        const role = String(opts.role || 'all');
+        const limit = Number.parseInt(opts.limit, 10);
+        if (!Number.isInteger(limit) || limit <= 0) {
+          throw new Error('--limit must be a positive integer');
+        }
+        if (role !== 'all' && !COLLAB_ROLES.includes(role)) {
+          throw new Error('--role must be planner|critic|coder|reviewer|all');
+        }
+
+        const transcript = await loadTranscript(sessionId);
+        const filtered = transcript
+          .filter((msg) => role === 'all' || msg.from === role)
+          .slice(-limit);
+
+        output({ sessionId, count: filtered.length, transcript: filtered }, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold(`SynapseGrid transcript (${filtered.length})`));
+          for (const msg of filtered) {
+            console.log(chalk.cyan(`\n[${msg.from}] ${msg.timestamp || ''}`));
+            console.log(String(msg.content || '').trim() || chalk.dim('(empty)'));
+          }
+        }
+      } catch (error) {
+        output({ error: error.message }, opts.json);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('summary')
+    .description('Show meeting summary generated from collaborative run')
+    .option('--session <id>', 'Session ID (defaults to current)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const sessionId = opts.session || await ensureSessionId(true);
+        const state = await loadSessionState(sessionId);
+        const summaryFile = await readSessionArtifact(sessionId, 'meeting-summary.md');
+        const meetingLogFile = await readSessionArtifact(sessionId, 'meeting-log.md');
+        const payload = {
+          sessionId,
+          status: state.status,
+          finalSummary: state.run?.finalSummary || null,
+          sharedContext: state.run?.sharedContext || null,
+          summaryFile,
+          meetingLogFile,
+        };
+
+        output(payload, opts.json);
+        if (!opts.json) {
+          console.log(chalk.bold('SynapseGrid meeting summary'));
+          if (summaryFile) {
+            process.stdout.write(summaryFile.endsWith('\n') ? summaryFile : `${summaryFile}\n`);
+          } else if (payload.finalSummary) {
+            process.stdout.write(`${payload.finalSummary}\n`);
+          } else {
+            console.log(chalk.dim('No summary generated yet.'));
+          }
+        }
+      } 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')
@@ -562,9 +1002,11 @@ export function agentsCommand() {
           throw new Error('--format must be md or json');
         }
 
+        const meetingSummary = await readSessionArtifact(sessionId, 'meeting-summary.md');
+        const meetingLog = await readSessionArtifact(sessionId, 'meeting-log.md');
         const payload = format === 'json'
-          ? JSON.stringify({ state, transcript }, null, 2) + '\n'
-          : toMarkdownTranscript(state, transcript) + '\n';
+          ? JSON.stringify({ state, transcript, meetingSummary, meetingLog }, null, 2) + '\n'
+          : `${toMarkdownTranscript(state, transcript)}\n\n## Meeting Summary\n\n${meetingSummary || state.run?.finalSummary || 'No summary generated yet.'}\n\n## Meeting Log\n\n${meetingLog || 'No meeting log generated yet.'}\n`;
 
         if (opts.out) {
           const outputPath = resolve(opts.out);
@@ -598,17 +1040,15 @@ export function agentsCommand() {
     .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('--mux <name>', 'Multiplexer backend: auto|zellij|tmux')
     .option('--cwd <path>', 'Working directory for agents', process.cwd())
-    .option('--attach', 'Attach tmux immediately after start', false)
+    .option('--attach', 'Attach multiplexer immediately after start', false)
     .option('--json', 'Output as JSON')
     .action(async (opts) => {
       try {
         if (!hasCommand('opencode')) {
           throw new Error('OpenCode is not installed. Run: acfm agents setup');
         }
-        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');
@@ -621,6 +1061,11 @@ export function agentsCommand() {
         }
 
         const config = await loadAgentsConfig();
+        const configuredMux = validateMultiplexer(opts.mux || config.agents.multiplexer || 'auto');
+        const selectedMux = resolveMultiplexer(configuredMux, hasCommand('tmux'), hasCommand('zellij'));
+        if (!selectedMux) {
+          throw new Error('No multiplexer found. Install zellij or tmux with: acfm agents setup');
+        }
         const cliModel = assertValidModelIdOrNull('--model', opts.model || null);
         const cliRoleModels = parseRoleModelOptions(opts);
         for (const [role, model] of Object.entries(cliRoleModels)) {
@@ -655,30 +1100,47 @@ export function agentsCommand() {
           maxRounds,
           model: globalModel,
           roleModels,
+          multiplexer: selectedMux,
           workingDirectory: resolve(opts.cwd),
           opencodeBin,
         });
-        const tmuxSessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+        const muxSessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
         const sessionDir = getSessionDir(state.sessionId);
+
+        if (selectedMux === 'zellij') {
+          await spawnZellijSession({
+            sessionName: muxSessionName,
+            sessionDir,
+            sessionId: state.sessionId,
+          });
+        } else {
+          await spawnTmuxSession({
+            sessionName: muxSessionName,
+            sessionDir,
+            sessionId: state.sessionId,
+          });
+        }
+
         const updated = await saveSessionState({
           ...state,
-          tmuxSessionName,
+          multiplexer: selectedMux,
+          multiplexerSessionName: muxSessionName,
+          tmuxSessionName: selectedMux === 'tmux' ? muxSessionName : null,
         });
 
-        await spawnTmuxSession({
-          sessionName: tmuxSessionName,
-          sessionDir,
-          sessionId: state.sessionId,
-        });
-
-        output({ sessionId: updated.sessionId, tmuxSessionName, status: updated.status }, opts.json);
+        output({
+          sessionId: updated.sessionId,
+          multiplexer: selectedMux,
+          multiplexerSessionName: muxSessionName,
+          status: updated.status,
+        }, opts.json);
         if (!opts.json) {
           printStartSummary(updated);
           printModelConfig(updated);
         }
 
         if (opts.attach) {
-          await runTmux('tmux', ['attach', '-t', tmuxSessionName], { stdio: 'inherit' });
+          await attachToMux(selectedMux, muxSessionName, false);
         }
       } catch (error) {
         output({ error: error.message }, opts.json);
@@ -723,15 +1185,22 @@ export function agentsCommand() {
           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}`));
+          const summary = runSummary(state);
+          console.log(chalk.dim(`Run: ${summary.status}${summary.currentRole ? ` (role=${summary.currentRole})` : ''}, events=${summary.events}`));
+          if (summary.lastError?.message) {
+            console.log(chalk.dim(`Run error: ${summary.lastError.message}`));
+          }
           console.log(chalk.dim(`Global model: ${state.model || '(opencode default)'}`));
+          console.log(chalk.dim(`Multiplexer: ${state.multiplexer || 'auto'} (${sessionMuxName(state)})`));
           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}`));
-          }
+          const meetingLogPath = resolve(getSessionDir(state.sessionId), 'meeting-log.md');
+          const meetingSummaryPath = resolve(getSessionDir(state.sessionId), 'meeting-summary.md');
+          console.log(chalk.dim(`meeting-log: ${existsSync(meetingLogPath) ? meetingLogPath : 'not generated yet'}`));
+          console.log(chalk.dim(`meeting-summary: ${existsSync(meetingSummaryPath) ? meetingSummaryPath : 'not generated yet'}`));
         }
       } catch (error) {
         output({ error: error.message }, opts.json);
@@ -748,16 +1217,68 @@ export function agentsCommand() {
       try {
         const sessionId = await ensureSessionId(true);
         let state = await loadSessionState(sessionId);
+        const meetingSummaryPath = resolve(getSessionDir(state.sessionId), 'meeting-summary.md');
         state = await stopSession(state, 'stopped');
-        if (state.tmuxSessionName && hasCommand('tmux')) {
+        if (state.run && state.run.status === 'running') {
+          state = await saveSessionState({
+            ...state,
+            run: {
+              ...state.run,
+              status: 'cancelled',
+              finishedAt: new Date().toISOString(),
+              currentRole: null,
+              lastError: {
+                code: 'RUN_CANCELLED',
+                message: 'Run cancelled by user',
+              },
+            },
+          });
+        }
+
+        if (!existsSync(meetingSummaryPath)) {
+          const fallbackSummary = [
+            '# SynapseGrid Meeting Summary',
+            '',
+            `Session: ${state.sessionId}`,
+            `Status: ${state.status}`,
+            '',
+            'This summary was auto-generated at stop time because the run did not complete normally.',
+            '',
+            '## Last message',
+            state.messages?.[state.messages.length - 1]?.content || '(none)',
+            '',
+          ].join('\n');
+          await writeMeetingSummary(state.sessionId, fallbackSummary);
+          if (state.run && !state.run.finalSummary) {
+            state = await saveSessionState({
+              ...state,
+              run: {
+                ...state.run,
+                finalSummary: fallbackSummary,
+              },
+            });
+          }
+        }
+
+        const multiplexer = state.multiplexer || 'tmux';
+        const muxSessionName = sessionMuxName(state);
+        if (multiplexer === 'zellij' && muxSessionName && hasCommand('zellij')) {
+          try {
+            await runZellij(['delete-session', muxSessionName]);
+          } catch {
+            // ignore if already closed
+          }
+        }
+        if (multiplexer === 'tmux' && muxSessionName && hasCommand('tmux')) {
           try {
-            await runTmux('tmux', ['kill-session', '-t', state.tmuxSessionName]);
+            await runTmux('tmux', ['kill-session', '-t', muxSessionName]);
           } catch {
             // ignore if already closed
           }
         }
         output({ sessionId: state.sessionId, status: state.status }, opts.json);
         if (!opts.json) console.log(chalk.green('✓ Collaborative session stopped'));
+
       } catch (error) {
         output({ error: error.message }, opts.json);
         if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
@@ -765,6 +1286,33 @@ export function agentsCommand() {
       }
     });
 
+  agents
+    .command('autopilot')
+    .description('Internal headless collaborative driver (non-tmux)')
+    .requiredOption('--session <id>', 'Session id')
+    .option('--poll-ms <n>', 'Polling interval in ms', '900')
+    .action(async (opts) => {
+      const pollMs = Number.parseInt(opts.pollMs, 10);
+      while (true) {
+        try {
+          const state = await loadSessionState(opts.session);
+          if (state.status !== 'running') process.exit(0);
+
+          for (const role of state.roles || COLLAB_ROLES) {
+            await runWorkerIteration(opts.session, role, {
+              cwd: state.workingDirectory || process.cwd(),
+              model: state.model || null,
+              opencodeBin: state.opencodeBin || resolveCommandPath('opencode') || undefined,
+              timeoutMs: state.run?.policy?.timeoutPerRoleMs || 180000,
+            });
+          }
+        } catch (error) {
+          console.error(`[autopilot] ${error.message}`);
+        }
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, Number.isInteger(pollMs) ? pollMs : 900));
+      }
+    });
+
   agents
     .command('worker')
     .description('Internal worker loop for a single collaborative role')
@@ -828,11 +1376,17 @@ export function agentsCommand() {
       try {
         const opencodeBin = resolveCommandPath('opencode');
         const tmuxInstalled = hasCommand('tmux');
+        const zellijInstalled = hasCommand('zellij');
         const cfg = await loadAgentsConfig();
         const defaultModel = cfg.agents.defaultModel || DEFAULT_SYNAPSE_MODEL;
+        const configuredMux = validateMultiplexer(cfg.agents.multiplexer || 'auto');
+        const resolvedMux = resolveMultiplexer(configuredMux, tmuxInstalled, zellijInstalled);
         const result = {
           opencodeBin,
           tmuxInstalled,
+          zellijInstalled,
+          configuredMultiplexer: configuredMux,
+          resolvedMultiplexer: resolvedMux,
           defaultModel,
           defaultRoleModels: cfg.agents.defaultRoleModels,
           preflight: null,
@@ -852,12 +1406,14 @@ export function agentsCommand() {
         if (!opts.json) {
           console.log(chalk.bold('SynapseGrid doctor'));
           console.log(chalk.dim(`opencode: ${opencodeBin || 'not found'}`));
+          console.log(chalk.dim(`zellij: ${zellijInstalled ? 'installed' : 'not installed'}`));
           console.log(chalk.dim(`tmux: ${tmuxInstalled ? 'installed' : 'not installed'}`));
+          console.log(chalk.dim(`multiplexer: configured=${configuredMux} resolved=${resolvedMux || 'none'}`));
           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);
+        if (!result.preflight?.ok || !result.resolvedMultiplexer) process.exit(1);
       } catch (error) {
         output({ error: error.message }, opts.json);
         if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));