ac-framework 1.9.7 → 1.9.8

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/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');

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,
@@ -127,6 +128,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 {
@@ -419,6 +453,52 @@ export function agentsCommand() {
     .command('model')
     .description('Manage default SynapseGrid model configuration');
 
+  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')
@@ -447,6 +527,114 @@ export function agentsCommand() {
       }
     });
 
+  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 },
+            },
+          };
+
+          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);
+        if (!opts.json) console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
   model
     .command('set <modelId>')
     .description('Set default model globally or for a specific role')
@@ -545,6 +733,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 +827,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);
@@ -723,6 +990,11 @@ 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)'}`));
           for (const role of COLLAB_ROLES) {
             const configured = state.roleModels?.[role] || '-';
@@ -749,6 +1021,21 @@ export function agentsCommand() {
         const sessionId = await ensureSessionId(true);
         let state = await loadSessionState(sessionId);
         state = await stopSession(state, 'stopped');
+        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 (state.tmuxSessionName && hasCommand('tmux')) {
           try {
             await runTmux('tmux', ['kill-session', '-t', state.tmuxSessionName]);
@@ -765,6 +1052,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')