ac-framework 1.9.6 → 1.9.8

package/src/agents/orchestrator.js

@@ -1,12 +1,21 @@
 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';
 
@@ -17,11 +26,115 @@ 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,
+    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);
@@ -44,7 +157,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 +165,7 @@ export async function runTurn(sessionId, options = {}) {
         binaryPath: options.opencodeBin,
         timeoutMs: options.timeoutMs,
       });
+      content = output.text;
     } catch (error) {
       content = `Agent failed: ${error.message}`;
     }
@@ -109,7 +223,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 +231,7 @@ export async function executeActiveTurn(sessionId, role, options = {}) {
         binaryPath: options.opencodeBin,
         timeoutMs: options.timeoutMs,
       });
+      content = output.text;
     } catch (error) {
       content = `Agent failed: ${error.message}`;
     }
@@ -141,13 +256,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 +292,86 @@ 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));
+      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 summaryMd = buildMeetingSummary(state.messages, ensureRunState(state), ensureRunState(state).sharedContext);
+      await writeMeetingSummary(sessionId, summaryMd);
+      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,
+      });
     }
 
     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

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

@@ -8,6 +8,7 @@ import {
   SESSION_ROOT_DIR,
   CURRENT_SESSION_FILE,
 } from './constants.js';
+import { createRunState } from './run-state.js';
 import { sanitizeRoleModels } from './model-selection.js';
 
 function sleep(ms) {
@@ -38,6 +39,22 @@ function getTranscriptPath(sessionId) {
   return join(getSessionDir(sessionId), 'transcript.jsonl');
 }
 
+function getTurnsDir(sessionId) {
+  return join(getSessionDir(sessionId), 'turns');
+}
+
+function getMeetingLogPath(sessionId) {
+  return join(getSessionDir(sessionId), 'meeting-log.md');
+}
+
+function getMeetingLogJsonlPath(sessionId) {
+  return join(getSessionDir(sessionId), 'meeting-log.jsonl');
+}
+
+function getMeetingSummaryPath(sessionId) {
+  return join(getSessionDir(sessionId), 'meeting-summary.md');
+}
+
 function initialState(task, options = {}) {
   const sessionId = randomUUID();
   const createdAt = new Date().toISOString();
@@ -57,6 +74,7 @@ function initialState(task, options = {}) {
     roleModels: sanitizeRoleModels(options.roleModels),
     opencodeBin: options.opencodeBin || null,
     tmuxSessionName: options.tmuxSessionName || null,
+    run: createRunState(options.runPolicy, Number.isInteger(options.maxRounds) ? options.maxRounds : DEFAULT_MAX_ROUNDS),
     messages: [
       {
         from: 'user',
@@ -91,6 +109,57 @@ export async function appendTranscript(sessionId, message) {
   await appendFile(transcriptPath, line, 'utf8');
 }
 
+export async function appendMeetingTurn(sessionId, turnRecord) {
+  const sessionDir = getSessionDir(sessionId);
+  const turnsDir = getTurnsDir(sessionId);
+  await mkdir(sessionDir, { recursive: true });
+  await mkdir(turnsDir, { recursive: true });
+
+  const safeRole = String(turnRecord?.role || 'unknown').replace(/[^a-z0-9_-]/gi, '_');
+  const safeRound = Number.isInteger(turnRecord?.round) ? turnRecord.round : 0;
+  const turnFilePath = join(turnsDir, `${String(safeRound).padStart(3, '0')}-${safeRole}.json`);
+  await writeFile(turnFilePath, JSON.stringify(turnRecord, null, 2) + '\n', 'utf8');
+
+  const mdPath = getMeetingLogPath(sessionId);
+  const jsonlPath = getMeetingLogJsonlPath(sessionId);
+  const snippet = (turnRecord?.snippet || '').trim() || '(empty output)';
+  const keyPoints = Array.isArray(turnRecord?.keyPoints) ? turnRecord.keyPoints : [];
+
+  const mdBlock = [
+    `## Round ${safeRound} - ${safeRole}`,
+    `- timestamp: ${turnRecord?.timestamp || new Date().toISOString()}`,
+    `- model: ${turnRecord?.model || '(default)'}`,
+    `- events: ${turnRecord?.eventCount ?? 0}`,
+    '',
+    '### Output snippet',
+    snippet,
+    '',
+    '### Key points',
+    ...(keyPoints.length > 0 ? keyPoints.map((line) => `- ${line.replace(/^[-*]\s+/, '')}`) : ['- (none)']),
+    '',
+  ].join('\n');
+
+  if (!existsSync(mdPath)) {
+    const header = `# SynapseGrid Meeting Log\n\nSession: ${sessionId}\n\n`;
+    await writeFile(mdPath, header + mdBlock, 'utf8');
+  } else {
+    await appendFile(mdPath, mdBlock, 'utf8');
+  }
+
+  await appendFile(jsonlPath, JSON.stringify(turnRecord) + '\n', 'utf8');
+  return {
+    turnFilePath,
+    meetingLogPath: mdPath,
+    meetingJsonlPath: jsonlPath,
+  };
+}
+
+export async function writeMeetingSummary(sessionId, summaryMarkdown) {
+  const outputPath = getMeetingSummaryPath(sessionId);
+  await writeFile(outputPath, String(summaryMarkdown || '').trimEnd() + '\n', 'utf8');
+  return outputPath;
+}
+
 export async function loadCurrentSessionId() {
   if (!existsSync(CURRENT_SESSION_FILE)) return null;
   const raw = await readFile(CURRENT_SESSION_FILE, 'utf8');
@@ -109,7 +178,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;
 }