ai-control-center 1.15.2

package/lib/roleplay/discussion-threads.js

@@ -0,0 +1,303 @@
+/**
+ * Discussion Threads — Asynchronous agent-to-agent communication.
+ *
+ * A "thread" is a structured conversation between agents about a specific topic:
+ * - Bug found by QA → thread for root cause discussion
+ * - Feature suggested → thread for feasibility discussion
+ * - Review blocked → thread for resolution
+ *
+ * Storage: .ai-workflow/discussion-threads/{threadId}.json
+ *
+ * Thread lifecycle: OPEN → RESOLVED | ESCALATED
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync } from 'fs';
+import { resolve } from 'path';
+import { randomUUID } from 'crypto';
+import { getWorkflowDir, atomicWriteSync } from '../utils/pipeline.js';
+import { logActivity } from '../utils/activity-log.js';
+import { bus } from '../shared/event-bus.js';
+
+const THREADS_DIR = () => resolve(getWorkflowDir(), 'discussion-threads');
+
+function ensureDir() {
+  const dir = THREADS_DIR();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Create a new discussion thread.
+ * @param {string|object} topicOrOptions - Topic string (V1 compat) or options object (V2)
+ * @param {string} [title] - Thread title (V1 compat)
+ * @param {object|string} [context] - Relevant context
+ * @param {string} [openedBy] - Agent who opened the thread (V1 compat)
+ * @returns {object|string} The created thread object (V2) or threadId (V1)
+ */
+export function openThread(topicOrOptions, title, context, openedBy = 'pm') {
+  const dir = ensureDir();
+
+  // V2 API: openThread({ title, initiator, type, context, participants })
+  if (typeof topicOrOptions === 'object' && topicOrOptions !== null) {
+    const opts = topicOrOptions;
+    const threadId = `THREAD-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    const thread = {
+      id: threadId,
+      title: opts.title,
+      type: opts.type || 'general',
+      topic: opts.type || 'general',
+      status: 'open',
+      initiator: opts.initiator || 'pm',
+      openedBy: opts.initiator || 'pm',
+      participants: [opts.initiator || 'pm', ...(opts.participants || [])],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      resolvedAt: null,
+      resolvedBy: null,
+      resolution: null,
+      messages: [
+        {
+          from: opts.initiator || 'pm',
+          agent: opts.initiator || 'pm',
+          timestamp: new Date().toISOString(),
+          content: opts.context || '',
+          message: opts.context || '',
+          type: 'context',
+        },
+      ],
+    };
+
+    atomicWriteSync(resolve(dir, `${threadId}.json`), JSON.stringify(thread, null, 2));
+    logActivity('THREAD', `Opened thread: ${opts.title} (${threadId})`, 'info');
+    bus.emit('thread_opened', { threadId, title: opts.title, type: opts.type, initiator: opts.initiator });
+
+    return thread;
+  }
+
+  // V1 API: openThread(topic, title, context, openedBy)
+  const topic = topicOrOptions;
+  const threadId = `${topic}_${Date.now()}`;
+  const thread = {
+    id: threadId,
+    topic,
+    title,
+    type: topic,
+    context,
+    openedBy,
+    initiator: openedBy,
+    status: 'open',
+    participants: [openedBy],
+    messages: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    resolvedAt: null,
+    resolvedBy: null,
+    resolution: null,
+  };
+
+  atomicWriteSync(resolve(dir, `${threadId}.json`), JSON.stringify(thread, null, 2));
+  bus.emitEvent('room:thread_opened', thread);
+
+  return threadId;
+}
+
+/**
+ * Post a message to an existing thread.
+ * Supports both V1 (threadId, agent, message, options) and V2 (threadId, { from, content, type }) API.
+ */
+export function postToThread(threadId, agentOrOptions, message, options = {}) {
+  const dir = ensureDir();
+  const filePath = resolve(dir, `${threadId}.json`);
+
+  if (!existsSync(filePath)) {
+    throw new Error(`Thread not found: ${threadId}`);
+  }
+
+  const thread = JSON.parse(readFileSync(filePath, 'utf8'));
+
+  if (thread.status !== 'open') {
+    throw new Error(`Thread ${threadId} is ${thread.status}, cannot post`);
+  }
+
+  // V2 API: postToThread(threadId, { from, content, type })
+  let entry;
+  if (typeof agentOrOptions === 'object') {
+    entry = {
+      from: agentOrOptions.from,
+      agent: agentOrOptions.from,
+      timestamp: new Date().toISOString(),
+      content: agentOrOptions.content,
+      message: agentOrOptions.content,
+      type: agentOrOptions.type || 'message',
+    };
+  } else {
+    // V1 API: postToThread(threadId, agent, message, options)
+    entry = {
+      from: agentOrOptions,
+      agent: agentOrOptions,
+      timestamp: new Date().toISOString(),
+      content: message,
+      message,
+      type: options.type || 'text',
+    };
+  }
+
+  thread.messages.push(entry);
+  thread.updatedAt = new Date().toISOString();
+  const from = entry.from || entry.agent;
+  if (from && !thread.participants.includes(from)) {
+    thread.participants.push(from);
+  }
+
+  atomicWriteSync(filePath, JSON.stringify(thread, null, 2));
+  bus.emit('thread_message', { threadId, from, content: (entry.content || '').slice(0, 100) });
+
+  return thread;
+}
+
+/**
+ * Resolve a thread with a decision.
+ * Supports both V1 (threadId, resolution, resolvedBy) and V2 (threadId, { by, resolution }) API.
+ */
+export function resolveThread(threadId, resolutionOrOpts, resolvedByV1 = 'pm') {
+  const dir = ensureDir();
+  const filePath = resolve(dir, `${threadId}.json`);
+  if (!existsSync(filePath)) return null;
+
+  const thread = JSON.parse(readFileSync(filePath, 'utf8'));
+
+  let by, resolution;
+  if (typeof resolutionOrOpts === 'object') {
+    by = resolutionOrOpts.by || 'pm';
+    resolution = resolutionOrOpts.resolution;
+  } else {
+    by = resolvedByV1;
+    resolution = resolutionOrOpts;
+  }
+
+  thread.status = 'resolved';
+  thread.resolvedAt = new Date().toISOString();
+  thread.resolvedBy = by;
+  thread.resolution = resolution;
+  thread.updatedAt = new Date().toISOString();
+
+  thread.messages.push({
+    from: by,
+    agent: by,
+    timestamp: new Date().toISOString(),
+    content: `RESOLVED: ${resolution}`,
+    message: `RESOLVED: ${resolution}`,
+    type: 'decision',
+  });
+
+  atomicWriteSync(filePath, JSON.stringify(thread, null, 2));
+  logActivity('THREAD', `Resolved thread ${threadId}: ${(resolution || '').slice(0, 80)}`, 'success');
+  bus.emit('thread_resolved', { threadId, by, resolution });
+
+  return thread;
+}
+
+/**
+ * Escalate a thread to CEO.
+ */
+export function escalateThread(threadId, reasonOrOpts) {
+  const dir = ensureDir();
+  const filePath = resolve(dir, `${threadId}.json`);
+  if (!existsSync(filePath)) return null;
+
+  const thread = JSON.parse(readFileSync(filePath, 'utf8'));
+
+  let by, reason;
+  if (typeof reasonOrOpts === 'object') {
+    by = reasonOrOpts.by || 'PM';
+    reason = reasonOrOpts.reason;
+  } else {
+    by = 'PM';
+    reason = reasonOrOpts;
+  }
+
+  thread.status = 'escalated';
+  thread.updatedAt = new Date().toISOString();
+  thread.escalated = { reason, at: new Date().toISOString() };
+
+  thread.messages.push({
+    from: by,
+    agent: by,
+    timestamp: new Date().toISOString(),
+    content: `ESCALATED TO CEO: ${reason}`,
+    message: `ESCALATED TO CEO: ${reason}`,
+    type: 'escalation',
+  });
+
+  atomicWriteSync(filePath, JSON.stringify(thread, null, 2));
+  logActivity('THREAD', `Escalated thread ${threadId} to CEO: ${(reason || '').slice(0, 80)}`, 'warn');
+  bus.emit('thread_escalated', { threadId, by, reason });
+
+  return thread;
+}
+
+/**
+ * List threads (filterable).
+ */
+export function listThreads({ status = null, type = null, limit = 20 } = {}) {
+  const dir = ensureDir();
+  const files = readdirSync(dir)
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .reverse();
+
+  const threads = files.slice(0, limit * 2).map(f => {
+    try { return JSON.parse(readFileSync(resolve(dir, f), 'utf8')); }
+    catch { return null; }
+  }).filter(Boolean);
+
+  let result = threads;
+  if (status) result = result.filter(t => t.status === status);
+  if (type) result = result.filter(t => t.type === type);
+
+  return result.slice(0, limit);
+}
+
+/**
+ * Get a single thread by ID.
+ */
+export function getThread(threadId) {
+  const filePath = resolve(ensureDir(), `${threadId}.json`);
+  if (!existsSync(filePath)) return null;
+  try { return JSON.parse(readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+/**
+ * Get all open threads.
+ */
+export function getOpenThreads() {
+  return listThreads({ status: 'open' });
+}
+
+/**
+ * Get all threads (any status).
+ */
+export function getAllThreads() {
+  return listThreads({ limit: 100 });
+}
+
+/**
+ * Get thread summary (for Telegram / room digest).
+ */
+export function getThreadSummary(threadId) {
+  const thread = getThread(threadId);
+  if (!thread) return null;
+
+  const msgCount = thread.messages.length;
+  const agents = [...new Set(thread.messages.map(m => m.from || m.agent))];
+  const last = thread.messages[thread.messages.length - 1];
+
+  return {
+    id: threadId,
+    title: thread.title,
+    status: thread.status,
+    messages: msgCount,
+    agents: agents.join(', '),
+    lastPost: (last?.content || last?.message || '').slice(0, 100),
+  };
+}

package/lib/roleplay/health-monitor.js

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync } from 'fs';
+import { getConfig } from '../config.js';
+import { ROOT_DIR } from '../shared/event-bus.js';
+import { resolve } from 'path';
+
+let _monitorInterval = null;
+let _bus = null;
+
+// Stage expected durations (ms) — used to detect slow vs stalled stages
+const STAGE_EXPECTED_MS = {
+  spec:      2 * 60_000,   // 2 min
+  arch:      3 * 60_000,   // 3 min
+  impl:     10 * 60_000,   // 10 min
+  review:    3 * 60_000,   // 3 min
+  fix:       5 * 60_000,   // 5 min
+  deploy:    2 * 60_000,   // 2 min
+  default:   5 * 60_000,
+};
+
+export function startMonitor(bus, config = {}) {
+  _bus = bus;
+  const interval = config.checkInterval || 30_000;
+
+  stopMonitor(); // clear any existing
+  _monitorInterval = setInterval(() => {
+    try {
+      const status = getProviderStatus();
+      // Emit health status on each tick for interested parties
+      if (_bus) {
+        _bus.emitEvent('health_status', { providers: status, timestamp: new Date().toISOString() });
+      }
+    } catch { /* non-fatal */ }
+  }, interval);
+}
+
+export function stopMonitor() {
+  if (_monitorInterval) {
+    clearInterval(_monitorInterval);
+    _monitorInterval = null;
+  }
+}
+
+export function getProviderStatus() {
+  const result = { copilot: 'healthy', gemini: 'healthy', claude: 'healthy', ollama: 'healthy' };
+
+  // Read circuit-breaker state
+  try {
+    const cbFile = resolve(ROOT_DIR, '.ai-workflow/circuit-breakers.json');
+    if (existsSync(cbFile)) {
+      const cbs = JSON.parse(readFileSync(cbFile, 'utf8'));
+      for (const [provider, state] of Object.entries(cbs)) {
+        if (state.state === 'OPEN') result[provider] = 'down';
+        else if (state.state === 'HALF_OPEN') result[provider] = 'degraded';
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  // Read model bans
+  try {
+    const bansFile = resolve(ROOT_DIR, '.ai-workflow/model-bans.json');
+    if (existsSync(bansFile)) {
+      const bans = JSON.parse(readFileSync(bansFile, 'utf8'));
+      const now = Date.now();
+      for (const [model, ban] of Object.entries(bans)) {
+        if (ban.expiresAt && ban.expiresAt > now) {
+          // Determine provider from model name
+          const provider = model.includes('gemini') ? 'gemini'
+            : model.includes('claude') ? 'claude'
+            : model.includes('copilot') ? 'copilot'
+            : null;
+          if (provider && result[provider] === 'healthy') {
+            result[provider] = 'degraded';
+          }
+        }
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  return result;
+}
+
+export function getStageHealth(stage, stageStartTime) {
+  const expectedMs = STAGE_EXPECTED_MS[stage] || STAGE_EXPECTED_MS.default;
+  const durationMs = stageStartTime ? Date.now() - stageStartTime : 0;
+
+  let status = 'progressing';
+  if (durationMs > expectedMs * 3) status = 'stalled';
+  else if (durationMs > expectedMs * 1.5) status = 'slow';
+
+  return { status, durationMs, expectedMs };
+}
+
+export function getAvailableProviders(stage) {
+  try {
+    const config = getConfig();
+    const stageProviders = config.models?.stageProviders || {};
+    const providers = stageProviders[stage] || stageProviders.default || ['copilot', 'gemini', 'ollama'];
+    const status = getProviderStatus();
+    return providers.filter(p => status[p] !== 'down');
+  } catch {
+    return ['copilot', 'gemini', 'ollama'];
+  }
+}
+
+export function suggestRecoveryAction(stage, error) {
+  const errorMsg = error?.message || String(error || '');
+  const isRateLimit = /429|rate.?limit|quota/i.test(errorMsg);
+  const isCapacity = /capacity|exhausted|overload/i.test(errorMsg);
+  const isTimeout = /timeout|ETIMEDOUT|hung/i.test(errorMsg);
+  const isCircuitOpen = /circuit.?open|OPEN/i.test(errorMsg);
+
+  if (isCircuitOpen) return 'switch_provider';
+  if (isRateLimit && !isCapacity) return 'wait_and_retry'; // short rate limit
+  if (isCapacity) return 'switch_provider'; // capacity exhausted
+  if (isTimeout) return 'retry_same'; // retry once, then switch
+
+  const available = getAvailableProviders(stage);
+  if (available.length === 0) return 'escalate_ceo';
+  if (available.length === 1) return 'wait_and_retry';
+  return 'switch_provider';
+}