ac-framework 1.9.7 → 1.9.9

package/src/commands/init.js

@@ -156,7 +156,8 @@ async function setupPersistentMemory() {
 async function setupCollaborativeSystem() {
   const hasOpenCode = hasCommand('opencode');
   const hasTmux = hasCommand('tmux');
-  const alreadyReady = hasOpenCode && hasTmux;
+  const hasZellij = hasCommand('zellij');
+  const alreadyReady = hasOpenCode && (hasZellij || hasTmux);
 
   console.log();
   await animatedSeparator(60);
@@ -168,10 +169,10 @@ async function setupCollaborativeSystem() {
   console.log(
     chalk.hex('#636E72')(
       `  ${COLLAB_SYSTEM_NAME} launches a real-time collaborative agent war-room with\n` +
-      '  4 coordinated roles (planner, critic, coder, reviewer) in tmux panes.\n\n' +
+      '  4 coordinated roles (planner, critic, coder, reviewer) in multiplexer panes.\n\n' +
       '  Each round is turn-based with shared incremental context, so every\n' +
       '  contribution from one agent is fed to the next, not isolated fan-out.\n\n' +
-      `  Dependencies: ${chalk.hex('#DFE6E9')('OpenCode')} + ${chalk.hex('#DFE6E9')('tmux')}`
+      `  Dependencies: ${chalk.hex('#DFE6E9')('OpenCode')} + ${chalk.hex('#DFE6E9')('zellij')} (${chalk.hex('#DFE6E9')('tmux')} fallback)`
     )
   );
   console.log();
@@ -223,7 +224,8 @@ async function setupCollaborativeSystem() {
 
   if (alreadyReady) {
     console.log();
-    console.log(chalk.hex('#00B894')('  ◆ OpenCode and tmux are already available.'));
+    const mux = hasZellij ? 'zellij' : 'tmux';
+    console.log(chalk.hex('#00B894')(`  ◆ OpenCode and ${mux} are already available.`));
     await installCollabMcpConnections();
     console.log(chalk.hex('#636E72')('  Run `acfm agents start --task "..."` to launch collaboration.'));
     console.log();
@@ -234,11 +236,13 @@ async function setupCollaborativeSystem() {
   console.log(chalk.hex('#B2BEC3')(`  Installing ${COLLAB_SYSTEM_NAME} dependencies...`));
   console.log();
 
-  const result = ensureCollabDependencies();
+  const result = ensureCollabDependencies({ installZellij: true, installTmux: true });
 
   const oColor = result.opencode.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
+  const zColor = result.zellij.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
   const tColor = result.tmux.success ? chalk.hex('#00B894') : chalk.hex('#D63031');
   console.log(oColor(`  ◆ OpenCode: ${result.opencode.message}`));
+  console.log(zColor(`  ◆ zellij: ${result.zellij.message}`));
   console.log(tColor(`  ◆ tmux: ${result.tmux.message}`));
   console.log();
 

package/src/mcp/collab-server.js

@@ -7,12 +7,23 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { COLLAB_ROLES } from '../agents/constants.js';
 import { buildEffectiveRoleModels, sanitizeRoleModels } from '../agents/model-selection.js';
 import { runWorkerIteration } from '../agents/orchestrator.js';
 import { getSessionDir } from '../agents/state-store.js';
-import { spawnTmuxSession, tmuxSessionExists } from '../agents/runtime.js';
+import {
+  spawnTmuxSession,
+  spawnZellijSession,
+  tmuxSessionExists,
+  zellijSessionExists,
+  resolveMultiplexer,
+} from '../agents/runtime.js';
 import {
   addUserMessage,
   createSession,
@@ -24,6 +35,49 @@ import {
   stopSession,
 } from '../agents/state-store.js';
 import { hasCommand, resolveCommandPath } from '../services/dependency-installer.js';
+import { loadAgentsConfig } from '../agents/config-store.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const runnerPath = resolve(__dirname, '../../bin/acfm.js');
+
+function summarizeRun(state) {
+  const run = state.run || null;
+  return {
+    status: run?.status || 'idle',
+    runId: run?.runId || null,
+    currentRole: run?.currentRole || state.activeAgent || null,
+    round: run?.round || state.round,
+    policy: run?.policy || null,
+    lastError: run?.lastError || null,
+    eventCount: Array.isArray(run?.events) ? run.events.length : 0,
+  };
+}
+
+function latestRunEvent(state) {
+  const events = state?.run?.events;
+  if (!Array.isArray(events) || events.length === 0) return null;
+  return events[events.length - 1];
+}
+
+async function readSessionArtifact(sessionId, filename) {
+  const path = resolve(getSessionDir(sessionId), filename);
+  if (!existsSync(path)) return null;
+  return readFile(path, 'utf8');
+}
+
+function launchAutopilot(sessionId) {
+  const child = spawn('node', [runnerPath, 'agents', 'autopilot', '--session', sessionId], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}
+
+async function muxExists(multiplexer, sessionName) {
+  if (multiplexer === 'zellij') return zellijSessionExists(sessionName);
+  return tmuxSessionExists(sessionName);
+}
 
 class MCPCollabServer {
   constructor() {
@@ -50,9 +104,14 @@ class MCPCollabServer {
           reviewer: z.string().optional(),
         }).partial().optional().describe('Optional per-role models (provider/model)'),
         cwd: z.string().optional().describe('Working directory for agents'),
-        spawnWorkers: z.boolean().default(true).describe('Create tmux workers and panes'),
+        spawnWorkers: z.boolean().default(true).describe('Create multiplexer workers and panes'),
+        runPolicy: z.object({
+          timeoutPerRoleMs: z.number().int().positive().optional(),
+          retryOnTimeout: z.number().int().min(0).optional(),
+          fallbackOnFailure: z.enum(['retry', 'skip', 'abort']).optional(),
+        }).partial().optional().describe('Optional run execution policy'),
       },
-      async ({ task, maxRounds, model, roleModels, cwd, spawnWorkers }) => {
+      async ({ task, maxRounds, model, roleModels, cwd, spawnWorkers, runPolicy }) => {
         try {
           const workingDirectory = cwd || process.cwd();
           const opencodeBin = resolveCommandPath('opencode');
@@ -60,8 +119,11 @@ class MCPCollabServer {
             throw new Error('OpenCode binary not found in PATH. Run: acfm agents setup');
           }
 
-          if (spawnWorkers && !hasCommand('tmux')) {
-            throw new Error('tmux is not installed. Run: acfm agents setup');
+          const config = await loadAgentsConfig();
+          const configuredMux = config.agents.multiplexer || 'auto';
+          const multiplexer = resolveMultiplexer(configuredMux, hasCommand('tmux'), hasCommand('zellij'));
+          if (spawnWorkers && !multiplexer) {
+            throw new Error('No multiplexer found (zellij/tmux). Run: acfm agents setup');
           }
 
           const state = await createSession(task, {
@@ -71,18 +133,32 @@ class MCPCollabServer {
             roleModels: sanitizeRoleModels(roleModels),
             workingDirectory,
             opencodeBin,
+            runPolicy,
+            multiplexer: multiplexer || configuredMux,
           });
           let updated = state;
           if (spawnWorkers) {
-            const tmuxSessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+            const sessionName = `acfm-synapse-${state.sessionId.slice(0, 8)}`;
             const sessionDir = getSessionDir(state.sessionId);
-            await spawnTmuxSession({ sessionName: tmuxSessionName, sessionDir, sessionId: state.sessionId });
-            updated = await saveSessionState({ ...state, tmuxSessionName });
+            if (multiplexer === 'zellij') {
+              await spawnZellijSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            } else {
+              await spawnTmuxSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            }
+            updated = await saveSessionState({
+              ...state,
+              multiplexer,
+              multiplexerSessionName: sessionName,
+              tmuxSessionName: multiplexer === 'tmux' ? sessionName : null,
+            });
           }
           await setCurrentSession(state.sessionId);
 
-          const tmuxSessionName = updated.tmuxSessionName || null;
-          const attachCommand = tmuxSessionName ? `tmux attach -t ${tmuxSessionName}` : null;
+          const mux = updated.multiplexer || null;
+          const muxSessionName = updated.multiplexerSessionName || updated.tmuxSessionName || null;
+          const attachCommand = muxSessionName
+            ? (mux === 'zellij' ? `zellij attach ${muxSessionName}` : `tmux attach -t ${muxSessionName}`)
+            : null;
           return {
             content: [{
               type: 'text',
@@ -93,7 +169,9 @@ class MCPCollabServer {
                 model: updated.model || null,
                 roleModels: updated.roleModels || {},
                 effectiveRoleModels: buildEffectiveRoleModels(updated, updated.model || null),
-                tmuxSessionName,
+                run: summarizeRun(updated),
+                multiplexer: mux,
+                multiplexerSessionName: muxSessionName,
                 attachCommand,
               }, null, 2),
             }],
@@ -104,6 +182,191 @@ class MCPCollabServer {
       }
     );
 
+    this.server.tool(
+      'collab_invoke_team',
+      'Invoke full 4-agent collaborative run and return async run handle',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        waitMs: z.number().int().min(0).max(30000).default(0).describe('Optional wait for progress before returning'),
+      },
+      async ({ sessionId, waitMs }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          let state = await loadSessionState(id);
+          if (state.status !== 'running') {
+            throw new Error(`Session is ${state.status}. Resume/start before invoking.`);
+          }
+
+          if (!state.multiplexerSessionName && !state.tmuxSessionName) {
+            launchAutopilot(state.sessionId);
+          }
+
+          if (waitMs > 0) {
+            const started = Date.now();
+            const initialEvents = state.run?.events?.length || 0;
+            while (Date.now() - started < waitMs) {
+              await new Promise((r) => setTimeout(r, 250));
+              state = await loadSessionState(id);
+              const currentEvents = state.run?.events?.length || 0;
+              if (state.status !== 'running' || currentEvents > initialEvents) break;
+            }
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                multiplexer: state.multiplexer || null,
+                multiplexerSessionName: state.multiplexerSessionName || state.tmuxSessionName || null,
+                attachCommand: state.multiplexerSessionName
+                  ? (state.multiplexer === 'zellij'
+                    ? `zellij attach ${state.multiplexerSessionName}`
+                    : `tmux attach -t ${state.multiplexerSessionName}`)
+                  : (state.tmuxSessionName ? `tmux attach -t ${state.tmuxSessionName}` : null),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_wait_run',
+      'Wait for collaborative run to complete/fail or timeout',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        waitMs: z.number().int().positive().max(60000).default(10000).describe('Max wait in milliseconds'),
+      },
+      async ({ sessionId, waitMs }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const started = Date.now();
+          let state = await loadSessionState(id);
+
+          while (Date.now() - started < waitMs) {
+            const runStatus = state.run?.status || 'idle';
+            if (state.status !== 'running' || ['completed', 'failed', 'cancelled'].includes(runStatus)) break;
+            await new Promise((r) => setTimeout(r, 300));
+            state = await loadSessionState(id);
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                timedOut: state.status === 'running' && !['completed', 'failed', 'cancelled'].includes(state.run?.status || 'idle'),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_get_result',
+      'Get final consolidated team output and run diagnostics',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+          const transcript = await loadTranscript(id);
+          const run = summarizeRun(state);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run,
+                latestEvent: latestRunEvent(state),
+                finalSummary: state.run?.finalSummary || null,
+                sharedContext: state.run?.sharedContext || null,
+                meetingSummary: await readSessionArtifact(id, 'meeting-summary.md'),
+                meetingLog: await readSessionArtifact(id, 'meeting-log.md'),
+                lastMessage: state.messages?.[state.messages.length - 1] || null,
+                transcriptCount: transcript.length,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_cancel_run',
+      'Cancel active collaborative run while keeping session state',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+          const run = state.run || {};
+          const updated = await saveSessionState({
+            ...state,
+            status: 'running',
+            activeAgent: null,
+            run: {
+              ...run,
+              status: 'cancelled',
+              currentRole: null,
+              finishedAt: new Date().toISOString(),
+              lastError: {
+                code: 'RUN_CANCELLED',
+                message: 'Cancelled by MCP caller',
+              },
+              events: [
+                ...(Array.isArray(run.events) ? run.events : []),
+                {
+                  id: `evt-${Date.now()}`,
+                  type: 'run_cancelled',
+                  timestamp: new Date().toISOString(),
+                },
+              ],
+            },
+          });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: updated.sessionId,
+                run: summarizeRun(updated),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
     this.server.tool(
       'collab_send_message',
       'Send a user message to the active collaborative session',
@@ -150,6 +413,7 @@ class MCPCollabServer {
           const state = await runWorkerIteration(id, role, {
             cwd: process.cwd(),
             opencodeBin: loaded.opencodeBin || resolveCommandPath('opencode') || undefined,
+            timeoutMs: loaded.run?.policy?.timeoutPerRoleMs || 180000,
           });
 
           return {
@@ -164,6 +428,8 @@ class MCPCollabServer {
                 model: state.model || null,
                 roleModels: state.roleModels || {},
                 effectiveRoleModels: buildEffectiveRoleModels(state, state.model || null),
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
                 messageCount: state.messages.length,
               }, null, 2),
             }],
@@ -176,10 +442,10 @@ class MCPCollabServer {
 
     this.server.tool(
       'collab_resume_session',
-      'Resume session and recreate tmux workers if needed',
+      'Resume session and recreate workers if needed',
       {
         sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
-        recreateWorkers: z.boolean().default(true).describe('Recreate tmux session when missing'),
+        recreateWorkers: z.boolean().default(true).describe('Recreate multiplexer session when missing'),
       },
       async ({ sessionId, recreateWorkers }) => {
         try {
@@ -187,24 +453,37 @@ class MCPCollabServer {
           if (!id) throw new Error('No active session found');
           let state = await loadSessionState(id);
 
-          const tmuxSessionName = state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
-          const tmuxExists = hasCommand('tmux') ? await tmuxSessionExists(tmuxSessionName) : false;
+          const multiplexer = state.multiplexer || resolveMultiplexer('auto', hasCommand('tmux'), hasCommand('zellij'));
+          if (!multiplexer) {
+            throw new Error('No multiplexer found (zellij/tmux). Run: acfm agents setup');
+          }
+          const sessionName = state.multiplexerSessionName || state.tmuxSessionName || `acfm-synapse-${state.sessionId.slice(0, 8)}`;
+          const sessionExists = await muxExists(multiplexer, sessionName);
 
-          if (!tmuxExists && recreateWorkers) {
-            if (!hasCommand('tmux')) {
-              throw new Error('tmux is not installed. Run: acfm agents setup');
-            }
+          if (!sessionExists && recreateWorkers) {
             const sessionDir = getSessionDir(state.sessionId);
-            await spawnTmuxSession({ sessionName: tmuxSessionName, sessionDir, sessionId: state.sessionId });
+            if (multiplexer === 'zellij') {
+              if (!hasCommand('zellij')) throw new Error('zellij is not installed. Run: acfm agents setup');
+              await spawnZellijSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            } else {
+              if (!hasCommand('tmux')) throw new Error('tmux is not installed. Run: acfm agents setup');
+              await spawnTmuxSession({ sessionName, sessionDir, sessionId: state.sessionId });
+            }
           }
 
           state = await saveSessionState({
             ...state,
             status: 'running',
-            tmuxSessionName,
+            multiplexer,
+            multiplexerSessionName: sessionName,
+            tmuxSessionName: multiplexer === 'tmux' ? sessionName : state.tmuxSessionName || null,
           });
           await setCurrentSession(state.sessionId);
 
+          const attachCommand = multiplexer === 'zellij'
+            ? `zellij attach ${sessionName}`
+            : `tmux attach -t ${sessionName}`;
+
           return {
             content: [{
               type: 'text',
@@ -212,8 +491,10 @@ class MCPCollabServer {
                 success: true,
                 sessionId: state.sessionId,
                 status: state.status,
-                tmuxSessionName,
-                recreatedWorkers: !tmuxExists && recreateWorkers,
+                multiplexer,
+                multiplexerSessionName: sessionName,
+                recreatedWorkers: !sessionExists && recreateWorkers,
+                attachCommand,
               }, null, 2),
             }],
           };
@@ -244,6 +525,9 @@ class MCPCollabServer {
               text: JSON.stringify({
                 state,
                 effectiveRoleModels: buildEffectiveRoleModels(state, state.model || null),
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                sharedContext: state.run?.sharedContext || null,
                 transcript,
               }, null, 2),
             }],
@@ -254,6 +538,71 @@ class MCPCollabServer {
       }
     );
 
+    this.server.tool(
+      'collab_get_transcript',
+      'Get transcript messages with optional role filtering',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        role: z.enum(['planner', 'critic', 'coder', 'reviewer', 'all']).default('all').describe('Role filter'),
+        limit: z.number().int().positive().max(500).default(100).describe('Max messages to return'),
+      },
+      async ({ sessionId, role, limit }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const transcript = await loadTranscript(id);
+          const filtered = transcript
+            .filter((msg) => role === 'all' || msg.from === role)
+            .slice(-limit);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                sessionId: id,
+                role,
+                count: filtered.length,
+                transcript: filtered,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_get_meeting_log',
+      'Get generated meeting log and summary artifacts',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                sessionId: id,
+                status: state.status,
+                finalSummary: state.run?.finalSummary || null,
+                sharedContext: state.run?.sharedContext || null,
+                meetingSummary: await readSessionArtifact(id, 'meeting-summary.md'),
+                meetingLog: await readSessionArtifact(id, 'meeting-log.md'),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
     this.server.tool(
       'collab_stop_session',
       'Stop current collaborative session',
@@ -271,7 +620,12 @@ class MCPCollabServer {
           return {
             content: [{
               type: 'text',
-              text: JSON.stringify({ success: true, sessionId: id, status: updated.status }, null, 2),
+              text: JSON.stringify({
+                success: true,
+                sessionId: id,
+                status: updated.status,
+                run: summarizeRun(updated),
+              }, null, 2),
             }],
           };
         } catch (error) {