ac-framework 1.9.7 → 1.9.9

package/src/agents/orchestrator.js

@@ -1,15 +1,38 @@
 import { buildAgentPrompt, ROLE_SYSTEM_PROMPTS } from './role-prompts.js';
-import { runOpenCodePrompt } from './opencode-client.js';
+import { runOpenCodePromptDetailed } from './opencode-client.js';
 import { nextRole, shouldStop } from './scheduler.js';
 import { resolveRoleModel } from './model-selection.js';
+import { buildMeetingSummary, createTurnRecord, updateSharedContext } from './collab-summary.js';
+import {
+  appendRunEvent,
+  extractFinalSummary,
+  incrementRoleRetry,
+  roleRetryCount,
+} from './run-state.js';
 import {
   addAgentMessage,
+  appendMeetingTurn,
   loadSessionState,
   saveSessionState,
   stopSession,
+  writeMeetingSummary,
   withSessionLock,
 } from './state-store.js';
 
+async function finalizeSessionArtifacts(state) {
+  const runState = ensureRunState(state);
+  const summaryMd = buildMeetingSummary(state.messages, runState, runState.sharedContext);
+  await writeMeetingSummary(state.sessionId, summaryMd);
+  const completedRun = {
+    ...runState,
+    finalSummary: extractFinalSummary(state.messages, runState),
+  };
+  return saveSessionState({
+    ...state,
+    run: completedRun,
+  });
+}
+
 function buildRuntimePrompt({ state, role }) {
   const roleContext = ROLE_SYSTEM_PROMPTS[role] || '';
   const collaborativePrompt = buildAgentPrompt({
@@ -17,17 +40,129 @@ function buildRuntimePrompt({ state, role }) {
     task: state.task,
     round: state.round,
     messages: state.messages,
+    sharedContext: state.run?.sharedContext || null,
   });
 
   return [roleContext, '', collaborativePrompt].join('\n');
 }
 
+function ensureRunState(state) {
+  if (state.run && typeof state.run === 'object') {
+    return {
+      ...state.run,
+      sharedContext: state.run.sharedContext && typeof state.run.sharedContext === 'object'
+        ? {
+            decisions: Array.isArray(state.run.sharedContext.decisions) ? state.run.sharedContext.decisions : [],
+            openIssues: Array.isArray(state.run.sharedContext.openIssues) ? state.run.sharedContext.openIssues : [],
+            risks: Array.isArray(state.run.sharedContext.risks) ? state.run.sharedContext.risks : [],
+            actionItems: Array.isArray(state.run.sharedContext.actionItems) ? state.run.sharedContext.actionItems : [],
+            notes: Array.isArray(state.run.sharedContext.notes) ? state.run.sharedContext.notes : [],
+          }
+        : {
+            decisions: [],
+            openIssues: [],
+            risks: [],
+            actionItems: [],
+            notes: [],
+          },
+    };
+  }
+  return {
+    runId: null,
+    status: 'idle',
+    startedAt: null,
+    finishedAt: null,
+    currentRole: null,
+    retriesUsed: {},
+    round: state.round || 1,
+    events: [],
+    finalSummary: null,
+    sharedContext: {
+      decisions: [],
+      openIssues: [],
+      risks: [],
+      actionItems: [],
+      notes: [],
+    },
+    lastError: null,
+    policy: {
+      timeoutPerRoleMs: 180000,
+      retryOnTimeout: 1,
+      fallbackOnFailure: 'abort',
+      maxRounds: state.maxRounds,
+    },
+  };
+}
+
+function applyRoleFailurePolicy(state, role, errorMessage) {
+  let run = ensureRunState(state);
+  const policy = run.policy || {};
+  const currentRetries = roleRetryCount(run, role);
+  const canRetry = currentRetries < (policy.retryOnTimeout ?? 0);
+
+  run = appendRunEvent(run, 'role_failed', {
+    role,
+    retry: canRetry,
+    error: errorMessage,
+  });
+
+  if (canRetry) {
+    run = incrementRoleRetry(run, role);
+    return {
+      ...state,
+      run: {
+        ...run,
+        currentRole: role,
+        status: 'running',
+        lastError: null,
+      },
+      activeAgent: null,
+      // retry same role by rewinding index
+      nextRoleIndex: state.roles.indexOf(role),
+    };
+  }
+
+  const fallback = policy.fallbackOnFailure || 'abort';
+  if (fallback === 'skip') {
+    const skipped = appendRunEvent(run, 'role_skipped', { role, error: errorMessage });
+    return {
+      ...state,
+      run: {
+        ...skipped,
+        currentRole: null,
+        status: 'running',
+        lastError: null,
+      },
+      activeAgent: null,
+    };
+  }
+
+  const failed = appendRunEvent(run, 'run_failed', { role, error: errorMessage });
+  return {
+    ...state,
+    status: 'failed',
+    activeAgent: null,
+    run: {
+      ...failed,
+      status: 'failed',
+      currentRole: null,
+      finishedAt: new Date().toISOString(),
+      lastError: {
+        code: 'ROLE_FAILURE',
+        message: errorMessage,
+        role,
+      },
+    },
+  };
+}
+
 export async function runTurn(sessionId, options = {}) {
   return withSessionLock(sessionId, async () => {
     let state = await loadSessionState(sessionId);
     if (shouldStop(state)) {
       if (state.status === 'running') {
         state = await stopSession(state, 'completed');
+        state = await finalizeSessionArtifacts(state);
       }
       return state;
     }
@@ -44,7 +179,7 @@ export async function runTurn(sessionId, options = {}) {
     let content;
     try {
       const effectiveModel = resolveRoleModel(state, scheduled.role, options.model);
-      content = await runOpenCodePrompt({
+      const output = await runOpenCodePromptDetailed({
         prompt,
         cwd: options.cwd || process.cwd(),
         model: effectiveModel,
@@ -52,6 +187,7 @@ export async function runTurn(sessionId, options = {}) {
         binaryPath: options.opencodeBin,
         timeoutMs: options.timeoutMs,
       });
+      content = output.text;
     } catch (error) {
       content = `Agent failed: ${error.message}`;
     }
@@ -64,6 +200,7 @@ export async function runTurn(sessionId, options = {}) {
 
     if (shouldStop(state)) {
       state = await stopSession(state, 'completed');
+      state = await finalizeSessionArtifacts(state);
     }
 
     return state;
@@ -109,7 +246,7 @@ export async function executeActiveTurn(sessionId, role, options = {}) {
     let content;
     try {
       const effectiveModel = resolveRoleModel(state, role, options.model);
-      content = await runOpenCodePrompt({
+      const output = await runOpenCodePromptDetailed({
         prompt,
         cwd: options.cwd || process.cwd(),
         model: effectiveModel,
@@ -117,6 +254,7 @@ export async function executeActiveTurn(sessionId, role, options = {}) {
         binaryPath: options.opencodeBin,
         timeoutMs: options.timeoutMs,
       });
+      content = output.text;
     } catch (error) {
       content = `Agent failed: ${error.message}`;
     }
@@ -129,6 +267,7 @@ export async function executeActiveTurn(sessionId, role, options = {}) {
 
     if (shouldStop(state)) {
       state = await stopSession(state, 'completed');
+      state = await finalizeSessionArtifacts(state);
     }
 
     return state;
@@ -141,13 +280,33 @@ export async function runWorkerIteration(sessionId, role, options = {}) {
     if (state.status !== 'running') return state;
     if (!state.roles.includes(role)) return state;
 
+    const run = ensureRunState(state);
+    if (run.status === 'cancelled' || run.status === 'failed' || run.status === 'completed') {
+      return state;
+    }
+
     if (!state.activeAgent) {
       const scheduled = nextRole(state);
+      const startedRun = run.status === 'idle'
+        ? appendRunEvent({
+          ...run,
+          status: 'running',
+          startedAt: new Date().toISOString(),
+          currentRole: scheduled.role,
+          round: scheduled.round,
+        }, 'run_started', { round: scheduled.round })
+        : appendRunEvent({
+          ...run,
+          currentRole: scheduled.role,
+          round: scheduled.round,
+        }, 'role_scheduled', { role: scheduled.role, round: scheduled.round });
+
       state = await saveSessionState({
         ...state,
         activeAgent: scheduled.role,
         nextRoleIndex: scheduled.nextRoleIndex,
         round: scheduled.round,
+        run: startedRun,
       });
     }
 
@@ -157,28 +316,88 @@ export async function runWorkerIteration(sessionId, role, options = {}) {
 
     const prompt = buildRuntimePrompt({ state, role });
     let content;
+    let outputEvents = [];
+    let effectiveModel = null;
+    let failed = false;
+    let errorMessage = '';
     try {
-      const effectiveModel = resolveRoleModel(state, role, options.model);
-      content = await runOpenCodePrompt({
+      effectiveModel = resolveRoleModel(state, role, options.model);
+      state = await saveSessionState({
+        ...state,
+        run: appendRunEvent({
+          ...ensureRunState(state),
+          currentRole: role,
+          status: 'running',
+        }, 'role_started', { role, model: effectiveModel }),
+      });
+      const output = await runOpenCodePromptDetailed({
         prompt,
         cwd: options.cwd || process.cwd(),
         model: effectiveModel,
         agent: options.agent,
         binaryPath: options.opencodeBin,
-        timeoutMs: options.timeoutMs,
+        timeoutMs: options.timeoutMs || ensureRunState(state).policy?.timeoutPerRoleMs || 180000,
       });
+      content = output.text;
+      outputEvents = output.events || [];
     } catch (error) {
+      failed = true;
+      errorMessage = error.message;
       content = `Agent failed: ${error.message}`;
     }
 
     state = await addAgentMessage(state, role, content);
+    if (failed) {
+      await appendMeetingTurn(sessionId, createTurnRecord({
+        round: state.round,
+        role,
+        model: effectiveModel,
+        content,
+        events: outputEvents,
+      }));
+      state = await saveSessionState(applyRoleFailurePolicy(state, role, errorMessage));
+      if (state.status === 'failed') {
+        state = await finalizeSessionArtifacts(state);
+      }
+      return state;
+    }
+
+    const turnRecord = createTurnRecord({
+      round: state.round,
+      role,
+      model: effectiveModel,
+      content,
+      events: outputEvents,
+    });
+    await appendMeetingTurn(sessionId, turnRecord);
+
+    const updatedShared = updateSharedContext(ensureRunState(state).sharedContext, turnRecord);
+    const succeededRun = appendRunEvent({
+      ...ensureRunState(state),
+      currentRole: null,
+      lastError: null,
+      sharedContext: updatedShared,
+    }, 'role_succeeded', { role, chars: content.length, events: outputEvents.length });
+
     state = await saveSessionState({
       ...state,
       activeAgent: null,
+      run: succeededRun,
     });
 
     if (shouldStop(state)) {
       state = await stopSession(state, 'completed');
+      const finalRun = appendRunEvent({
+        ...ensureRunState(state),
+        status: 'completed',
+        finishedAt: new Date().toISOString(),
+        finalSummary: extractFinalSummary(state.messages, ensureRunState(state)),
+      }, 'run_completed', { round: state.round });
+      state = await saveSessionState({
+        ...state,
+        run: finalRun,
+      });
+      state = await finalizeSessionArtifacts(state);
     }
 
     return state;

package/src/agents/role-prompts.js

@@ -25,11 +25,41 @@ export const ROLE_SYSTEM_PROMPTS = {
   ].join(' '),
 };
 
-export function buildAgentPrompt({ role, task, round, messages, maxMessages = 24 }) {
+function formatSharedContext(sharedContext) {
+  if (!sharedContext || typeof sharedContext !== 'object') {
+    return 'No shared summary yet.';
+  }
+
+  const sections = [
+    ['Decisions', sharedContext.decisions],
+    ['Open issues', sharedContext.openIssues],
+    ['Risks', sharedContext.risks],
+    ['Action items', sharedContext.actionItems],
+    ['Notes', sharedContext.notes],
+  ];
+
+  const lines = [];
+  for (const [name, list] of sections) {
+    const items = Array.isArray(list) ? list.slice(-6) : [];
+    lines.push(`${name}:`);
+    if (items.length === 0) {
+      lines.push('- (none)');
+    } else {
+      for (const item of items) {
+        lines.push(`- ${item}`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function buildAgentPrompt({ role, task, round, messages, sharedContext = null, maxMessages = 18 }) {
   const recent = messages.slice(-maxMessages);
   const transcript = recent.length
     ? recent.map((msg, idx) => `${idx + 1}. [${msg.from}] ${msg.content}`).join('\n')
     : 'No previous messages.';
+  const shared = formatSharedContext(sharedContext);
 
   return [
     `ROLE: ${role}`,
@@ -37,6 +67,9 @@ export function buildAgentPrompt({ role, task, round, messages, maxMessages = 24
     '',
     `TASK: ${task}`,
     '',
+    'SHARED CONTEXT SUMMARY:',
+    shared,
+    '',
     'TEAM TRANSCRIPT (latest first-order history):',
     transcript,
     '',

package/src/agents/run-state.js

@@ -0,0 +1,113 @@
+import { randomUUID } from 'node:crypto';
+import {
+  DEFAULT_ROLE_RETRIES,
+  DEFAULT_ROLE_TIMEOUT_MS,
+  DEFAULT_MAX_ROUNDS,
+} from './constants.js';
+
+export function normalizeRunPolicy(policy = {}, maxRounds = DEFAULT_MAX_ROUNDS) {
+  const timeoutPerRoleMs = Number.isInteger(policy.timeoutPerRoleMs) && policy.timeoutPerRoleMs > 0
+    ? policy.timeoutPerRoleMs
+    : DEFAULT_ROLE_TIMEOUT_MS;
+  const retryOnTimeout = Number.isInteger(policy.retryOnTimeout) && policy.retryOnTimeout >= 0
+    ? policy.retryOnTimeout
+    : DEFAULT_ROLE_RETRIES;
+  const fallbackOnFailure = ['retry', 'skip', 'abort'].includes(policy.fallbackOnFailure)
+    ? policy.fallbackOnFailure
+    : 'abort';
+  const rounds = Number.isInteger(maxRounds) && maxRounds > 0 ? maxRounds : DEFAULT_MAX_ROUNDS;
+
+  return {
+    timeoutPerRoleMs,
+    retryOnTimeout,
+    fallbackOnFailure,
+    maxRounds: rounds,
+  };
+}
+
+export function createRunState(policy = {}, maxRounds = DEFAULT_MAX_ROUNDS) {
+  return {
+    runId: randomUUID(),
+    status: 'idle',
+    startedAt: null,
+    finishedAt: null,
+    currentRole: null,
+    retriesUsed: {},
+    round: 1,
+    events: [],
+    finalSummary: null,
+    sharedContext: {
+      decisions: [],
+      openIssues: [],
+      risks: [],
+      actionItems: [],
+      notes: [],
+    },
+    lastError: null,
+    policy: normalizeRunPolicy(policy, maxRounds),
+  };
+}
+
+export function appendRunEvent(run, type, details = {}) {
+  const event = {
+    id: randomUUID(),
+    type,
+    timestamp: new Date().toISOString(),
+    ...details,
+  };
+  const events = [...(run.events || []), event];
+  return {
+    ...run,
+    events,
+  };
+}
+
+export function roleRetryCount(run, role) {
+  return Number(run?.retriesUsed?.[role] || 0);
+}
+
+export function incrementRoleRetry(run, role) {
+  return {
+    ...run,
+    retriesUsed: {
+      ...(run.retriesUsed || {}),
+      [role]: roleRetryCount(run, role) + 1,
+    },
+  };
+}
+
+export function extractFinalSummary(messages = [], run = null) {
+  const agentMessages = messages.filter((msg) => msg?.from && msg.from !== 'user');
+  if (agentMessages.length === 0) return '';
+  const orderedRoles = ['planner', 'critic', 'coder', 'reviewer'];
+  const lastByRole = new Map();
+  for (const msg of agentMessages) lastByRole.set(msg.from, msg.content || '');
+
+  const sections = ['# SynapseGrid Final Summary', ''];
+  sections.push('## Per-role last contributions');
+  for (const role of orderedRoles) {
+    const content = String(lastByRole.get(role) || '').trim();
+    sections.push(`- ${role}: ${content ? content.slice(0, 500) : '(none)'}`);
+  }
+
+  const shared = run?.sharedContext;
+  if (shared && typeof shared === 'object') {
+    const writeList = (title, items) => {
+      sections.push('');
+      sections.push(`## ${title}`);
+      const list = Array.isArray(items) ? items.slice(-10) : [];
+      if (list.length === 0) {
+        sections.push('- (none)');
+      } else {
+        for (const item of list) sections.push(`- ${item}`);
+      }
+    };
+
+    writeList('Decisions', shared.decisions);
+    writeList('Open issues', shared.openIssues);
+    writeList('Risks', shared.risks);
+    writeList('Action items', shared.actionItems);
+  }
+
+  return sections.join('\n').trim();
+}

package/src/agents/runtime.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { writeFile } from 'node:fs/promises';
 import { COLLAB_ROLES } from './constants.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -10,7 +11,7 @@ export function roleLogPath(sessionDir, role) {
   return resolve(sessionDir, `${role}.log`);
 }
 
-export function runTmux(command, args, options = {}) {
+function runCommand(command, args, options = {}) {
   return new Promise((resolvePromise, rejectPromise) => {
     const child = spawn(command, args, {
       cwd: options.cwd || process.cwd(),
@@ -42,6 +43,14 @@ export function runTmux(command, args, options = {}) {
   });
 }
 
+function workerCommand(sessionId, role, roleLog) {
+  return `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role} 2>&1 | tee -a "${roleLog}"'`;
+}
+
+export async function runTmux(command, args, options = {}) {
+  return runCommand(command, args, options);
+}
+
 export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
   const role0 = COLLAB_ROLES[0];
   const role0Log = roleLogPath(sessionDir, role0);
@@ -52,7 +61,7 @@ export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
     sessionName,
     '-n',
     role0,
-    `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role0} 2>&1 | tee -a "${role0Log}"'`,
+    workerCommand(sessionId, role0, role0Log),
   ]);
 
   for (let idx = 1; idx < COLLAB_ROLES.length; idx += 1) {
@@ -63,7 +72,7 @@ export async function spawnTmuxSession({ sessionName, sessionDir, sessionId }) {
       '-t',
       sessionName,
       '-v',
-      `bash -lc 'node "${runnerPath}" agents worker --session ${sessionId} --role ${role} 2>&1 | tee -a "${roleLog}"'`,
+      workerCommand(sessionId, role, roleLog),
     ]);
   }
 
@@ -80,3 +89,66 @@ export async function tmuxSessionExists(sessionName) {
     return false;
   }
 }
+
+async function writeZellijLayout({ layoutPath, sessionId, sessionDir }) {
+  const panes = COLLAB_ROLES.map((role) => {
+    const roleLog = roleLogPath(sessionDir, role);
+    const cmd = workerCommand(sessionId, role, roleLog).replace(/"/g, '\\"');
+    return `                    pane name="${role}" command="bash" args { "-lc" "${cmd}" }`;
+  });
+
+  const content = [
+    'layout {',
+    '    default_tab_template {',
+    '        tab name="SynapseGrid" {',
+    '            pane split_direction="vertical" {',
+    '                pane split_direction="horizontal" {',
+    panes[0],
+    panes[1],
+    '                }',
+    '                pane split_direction="horizontal" {',
+    panes[2],
+    panes[3],
+    '                }',
+    '            }',
+    '        }',
+    '    }',
+    '}',
+    '',
+  ].join('\n');
+
+  await writeFile(layoutPath, content, 'utf8');
+}
+
+export async function spawnZellijSession({ sessionName, sessionDir, sessionId }) {
+  const layoutPath = resolve(sessionDir, 'synapsegrid-layout.kdl');
+  await writeZellijLayout({ layoutPath, sessionId, sessionDir });
+  await runCommand('zellij', ['--session', sessionName, '--layout', layoutPath, '--detach']);
+  return { layoutPath };
+}
+
+export async function zellijSessionExists(sessionName) {
+  try {
+    const result = await runCommand('zellij', ['list-sessions']);
+    const lines = result.stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+    return lines.some((line) => line === sessionName || line.startsWith(`${sessionName} `));
+  } catch {
+    return false;
+  }
+}
+
+export async function runZellij(args, options = {}) {
+  return runCommand('zellij', args, options);
+}
+
+export function resolveMultiplexer(preferred = 'auto', hasTmuxCommand = false, hasZellijCommand = false) {
+  if (preferred === 'tmux') {
+    return hasTmuxCommand ? 'tmux' : null;
+  }
+  if (preferred === 'zellij') {
+    return hasZellijCommand ? 'zellij' : null;
+  }
+  if (hasZellijCommand) return 'zellij';
+  if (hasTmuxCommand) return 'tmux';
+  return null;
+}