ai-control-center 1.15.2

package/lib/orchestrator/autonomous-loop.js

@@ -0,0 +1,429 @@
+/**
+ * Autonomous Loop — The main orchestration brain.
+ *
+ * Runs on a configurable interval (default: 30s).
+ * Reads status.json → decides what to do next → executes.
+ *
+ * This is the ONLY place that initiates pipeline actions.
+ * All other code (Telegram, web API, CLI) ONLY writes to status.json
+ * or emits events — the loop picks them up.
+ *
+ * Architecture:
+ *   status.json (state) + event-bus (signals) → loop reads → decides → acts
+ */
+
+import { getStatus, updateStatus } from '../utils/pipeline.js';
+import { logActivity } from '../utils/activity-log.js';
+import { getConfig } from '../config.js';
+import { bus } from '../shared/event-bus.js';
+import { validateTransition } from '../utils/state-machine.js';
+import { acquireLock, releaseLock } from '../utils/pipeline-lock.js';
+import { checkCostGuard } from '../utils/security.js';
+
+let loopInterval = null;
+let isRunning = false;
+
+// ─── Decision Table ──────────────────────────────────────────────────────────
+
+const DECISIONS = {
+  /**
+   * IDLE: Check if we should run suggestions or if a new assignment came in.
+   */
+  async idle(status, config) {
+    // Check for pending assignment (written by /assign command)
+    const pendingAssign = status.pendingAssignment;
+    if (pendingAssign) {
+      return { action: 'assign', data: pendingAssign };
+    }
+
+    // Check if idle long enough for suggestions
+    const idleMs = (config.suggestion?.idleAfterMinutes || 60) * 60 * 1000;
+    const idleSince = new Date(status.transitionedAt || 0).getTime();
+    if (Date.now() - idleSince > idleMs && config.suggestion?.enabled) {
+      return { action: 'suggestion' };
+    }
+
+    // Check for scheduled QA (cron-triggered, flag set in status.json)
+    if (status.scheduledQA) {
+      return { action: 'scheduled-qa' };
+    }
+
+    return { action: 'wait' };
+  },
+
+  /**
+   * ASSIGN: Parse URL + goal → run initial Browser QA audit.
+   */
+  async assign(status, config) {
+    const { assignProjectAction } = await import('../actions/assign-project.js');
+    const result = await assignProjectAction({
+      url: status.assignedUrl,
+      goal: status.assignedGoal,
+      config,
+    });
+    return { action: 'transition', nextState: 'browser-qa', data: result };
+  },
+
+  /**
+   * BROWSER-QA: Run QA → triage results.
+   */
+  async 'browser-qa'(status, config) {
+    const { browserTestAction } = await import('../actions/browser-test.js');
+    const result = await browserTestAction({ featureId: status.featureId, config });
+
+    if (result.skipped || result.success) {
+      // No bugs → proceed to spec (new feature) or idle (maintenance)
+      const nextState = status.assignedGoal ? 'spec' : 'idle';
+      return { action: 'transition', nextState, data: result };
+    }
+    return { action: 'transition', nextState: 'triage', data: result };
+  },
+
+  /**
+   * TRIAGE: Analyze QA failures → decide bugfix or spec.
+   */
+  async triage(status) {
+    const failCount = status.qa_fail_count || 0;
+
+    if (failCount > 0) {
+      return {
+        action: 'transition',
+        nextState: 'bugfix',
+        data: { currentCycle: 1, maxCycles: status.maxCycles || 3 },
+      };
+    }
+    // No fails (edge case: triage reached with 0 fails) → spec
+    return { action: 'transition', nextState: 'spec' };
+  },
+
+  /**
+   * BUGFIX: Run bugfix → re-QA to verify.
+   */
+  async bugfix(status) {
+    const { fixBugAction } = await import('../actions/fix-bug.js');
+    const result = await fixBugAction({ featureId: status.featureId, fromQA: true });
+
+    return { action: 'transition', nextState: 're-qa', data: result };
+  },
+
+  /**
+   * RE-QA: Re-run QA after bugfix → pass or retry.
+   */
+  async 're-qa'(status, config) {
+    const { browserTestAction } = await import('../actions/browser-test.js');
+    const result = await browserTestAction({ featureId: status.featureId, config });
+
+    if (result.success || result.skipped) {
+      // Bugs fixed → proceed to spec or idle
+      const nextState = status.assignedGoal ? 'spec' : 'idle';
+      return { action: 'transition', nextState, data: result };
+    }
+
+    // Still failing → check cycle limit
+    const cycle = (status.currentCycle || 1) + 1;
+    const maxCycles = status.maxCycles || config.browserQA?.maxBugfixCycles || 3;
+
+    if (cycle > maxCycles) {
+      return {
+        action: 'transition',
+        nextState: 'escalate',
+        data: {
+          reason: `Bug-fix loop exhausted after ${maxCycles} cycles`,
+          remainingFails: result.failCount,
+        },
+      };
+    }
+
+    return {
+      action: 'transition',
+      nextState: 'bugfix',
+      data: { currentCycle: cycle, maxCycles },
+    };
+  },
+
+  /**
+   * SPEC: Run PM spec stage.
+   */
+  async spec(status) {
+    const { runNewFeature } = await import('../shared/action-runner.js');
+    const result = await runNewFeature(
+      status.assignedGoal || status.featureDescription || 'Feature',
+      'auto',
+      'feature',
+    );
+    return { action: 'transition', nextState: 'arch', data: result };
+  },
+
+  /**
+   * ARCH: Run architecture stage.
+   */
+  async arch(status) {
+    const { runNewFeature } = await import('../shared/action-runner.js');
+    const result = await runNewFeature(
+      status.assignedGoal || 'Architecture',
+      'auto',
+      'feature',
+    );
+    return { action: 'transition', nextState: 'impl', data: result };
+  },
+
+  /**
+   * IMPL: Run implementation stage.
+   */
+  async impl(status) {
+    const { runImplementation } = await import('../shared/action-runner.js');
+    const result = await runImplementation();
+    return { action: 'transition', nextState: 'review', data: result };
+  },
+
+  /**
+   * REVIEW: Run review stage → deploy or re-impl.
+   */
+  async review(status) {
+    const { runReview } = await import('../shared/action-runner.js');
+    const result = await runReview();
+
+    if (result.verdict === 'APPROVED' || result.approved) {
+      return { action: 'transition', nextState: 'deploy', data: result };
+    }
+    // Rejected → re-implement
+    return { action: 'transition', nextState: 'impl', data: { reviewFeedback: result.feedback } };
+  },
+
+  /**
+   * DEPLOY: Run deploy → post-deploy QA.
+   */
+  async deploy(status, config) {
+    // Check if auto-deploy is allowed or CEO approval needed
+    if (!config.roleplay?.autoDeployOnApproval) {
+      bus.emit('pipeline-event', {
+        event: 'deploy_approval_needed',
+        data: { featureId: status.featureId },
+      });
+      return { action: 'transition', nextState: 'manual_hold', data: { reason: 'Deploy requires CEO approval' } };
+    }
+
+    const { runDeploy } = await import('../shared/action-runner.js');
+    const result = await runDeploy();
+
+    return { action: 'transition', nextState: 'deploy-verify', data: result };
+  },
+
+  /**
+   * DEPLOY-VERIFY: Post-deploy QA on production URL.
+   */
+  async 'deploy-verify'(status, config) {
+    const { browserTestAction } = await import('../actions/browser-test.js');
+    const result = await browserTestAction({
+      featureId: status.featureId,
+      config,
+      targetUrl: config.browserQA?.productionUrl || config.browserQA?.targetUrl,
+    });
+
+    if (result.success || result.skipped) {
+      logActivity('DEPLOY', 'Post-deploy QA PASSED — feature complete', 'success');
+      bus.emit('pipeline-event', {
+        event: 'feature_complete',
+        data: { featureId: status.featureId, passRate: result.report?.summary?.passRate },
+      });
+      return { action: 'transition', nextState: 'idle' };
+    }
+
+    // Post-deploy failure — bugfix
+    return { action: 'transition', nextState: 'bugfix', data: { postDeploy: true } };
+  },
+
+  /**
+   * ESCALATE: Notify CEO and wait.
+   */
+  async escalate(status) {
+    bus.emit('pipeline-event', {
+      event: 'escalation',
+      data: {
+        reason: status.escalation?.reason || 'Unknown escalation',
+        featureId: status.featureId,
+        failedStage: status.previousStage,
+      },
+    });
+    logActivity('ESCALATE', `Escalated to CEO: ${status.escalation?.reason || 'Unknown'}`, 'error');
+    return { action: 'transition', nextState: 'manual_hold' };
+  },
+
+  /**
+   * MANUAL_HOLD: Wait for CEO input. Do nothing.
+   */
+  async manual_hold() {
+    return { action: 'wait' };
+  },
+
+  /**
+   * SUGGESTION: Run suggestion agent → back to idle.
+   */
+  async suggestion() {
+    const { runSuggestionAgent } = await import('../agents/suggestion-agent.js');
+    const result = await runSuggestionAgent();
+    return { action: 'transition', nextState: 'idle', data: result };
+  },
+};
+
+// ─── Main Loop ────────────────────────────────────────────────────────────────
+
+async function tick() {
+  if (isRunning) {
+    logActivity('LOOP', 'Tick skipped — previous tick still running', 'warn');
+    return;
+  }
+
+  const lockAcquired = acquireLock('pipeline-loop', 120_000);
+  if (!lockAcquired) {
+    logActivity('LOOP', 'Could not acquire pipeline lock — another process holds it', 'warn');
+    return;
+  }
+
+  isRunning = true;
+
+  try {
+    const status = getStatus();
+    const config = getConfig();
+    const currentStage = status.stage || 'idle';
+
+    // Cost guard check before non-idle stages
+    if (currentStage !== 'idle' && currentStage !== 'manual_hold') {
+      const costCheck = checkCostGuard(config);
+      if (costCheck.exceeded) {
+        logActivity('LOOP', costCheck.message, 'error');
+        bus.emit('pipeline-event', { event: 'cost_exceeded', data: costCheck });
+        updateStatus({
+          stage: 'escalate',
+          previousStage: currentStage,
+          escalation: { reason: costCheck.message, failedStage: currentStage, timestamp: new Date().toISOString() },
+          transitionedAt: new Date().toISOString(),
+        });
+        return;
+      }
+    }
+
+    const handler = DECISIONS[currentStage];
+    if (!handler) {
+      logActivity('LOOP', `No handler for stage "${currentStage}" — treating as idle`, 'warn');
+      return;
+    }
+
+    const decision = await handler(status, config);
+
+    switch (decision.action) {
+      case 'transition': {
+        validateTransition(currentStage, decision.nextState);
+        updateStatus({
+          stage: decision.nextState,
+          previousStage: currentStage,
+          transitionedAt: new Date().toISOString(),
+          ...(decision.data || {}),
+        });
+        logActivity('LOOP', `Transition: ${currentStage} → ${decision.nextState}`, 'info');
+        bus.emit('stage_changed', { from: currentStage, to: decision.nextState, data: decision.data });
+        break;
+      }
+      case 'assign': {
+        // Triggered from idle with a pending assignment
+        validateTransition('idle', 'assign');
+        updateStatus({
+          stage: 'assign',
+          previousStage: 'idle',
+          transitionedAt: new Date().toISOString(),
+          assignedUrl: decision.data?.url,
+          assignedGoal: decision.data?.goal,
+          pendingAssignment: null,
+        });
+        logActivity('LOOP', `Assignment picked up: ${decision.data?.url}`, 'info');
+        break;
+      }
+      case 'suggestion': {
+        validateTransition('idle', 'suggestion');
+        updateStatus({
+          stage: 'suggestion',
+          previousStage: 'idle',
+          transitionedAt: new Date().toISOString(),
+        });
+        logActivity('LOOP', 'Running suggestion agent (idle timeout)', 'info');
+        break;
+      }
+      case 'scheduled-qa': {
+        validateTransition('idle', 'browser-qa');
+        updateStatus({
+          stage: 'browser-qa',
+          previousStage: 'idle',
+          transitionedAt: new Date().toISOString(),
+          scheduledQA: false,
+        });
+        logActivity('LOOP', 'Scheduled QA triggered', 'info');
+        break;
+      }
+      case 'wait':
+        // Do nothing, wait for next tick or external event
+        break;
+      default:
+        logActivity('LOOP', `Unknown decision action: ${decision.action}`, 'warn');
+    }
+
+  } catch (err) {
+    logActivity('LOOP', `Tick error: ${err.message}`, 'error');
+    bus.emit('pipeline-event', { event: 'loop_error', data: { error: err.message } });
+
+    // On error, don't crash — update status with error info
+    try {
+      const status = getStatus();
+      updateStatus({
+        error: err.message,
+        errorAt: new Date().toISOString(),
+        errorStage: status.stage,
+      });
+    } catch { /* status write failed — nothing we can do */ }
+
+  } finally {
+    isRunning = false;
+    releaseLock('pipeline-loop');
+  }
+}
+
+/**
+ * Start the autonomous loop.
+ * @param {number} intervalMs - Tick interval (default: 30s)
+ */
+export function startLoop(intervalMs = 30_000) {
+  if (loopInterval) {
+    logActivity('LOOP', 'Loop already running', 'warn');
+    return;
+  }
+
+  logActivity('LOOP', `Starting autonomous loop (interval: ${intervalMs}ms)`, 'info');
+  loopInterval = setInterval(tick, intervalMs);
+
+  // Run first tick immediately
+  tick();
+}
+
+/**
+ * Stop the loop.
+ */
+export function stopLoop() {
+  if (loopInterval) {
+    clearInterval(loopInterval);
+    loopInterval = null;
+    logActivity('LOOP', 'Autonomous loop stopped', 'info');
+  }
+}
+
+/**
+ * Force a single tick (for testing or manual trigger).
+ */
+export async function forceTick() {
+  await tick();
+}
+
+/**
+ * Check if the loop is currently running.
+ */
+export function isLoopRunning() {
+  return loopInterval !== null;
+}

package/lib/orchestrator/thread-triggers.js

@@ -0,0 +1,63 @@
+/**
+ * Thread Triggers — Automatically create discussion threads on key pipeline events.
+ *
+ * Wire into event-bus listeners. Call initThreadTriggers() once at startup.
+ */
+
+import { bus } from '../shared/event-bus.js';
+import { openThread } from '../roleplay/discussion-threads.js';
+
+let initialized = false;
+
+export function initThreadTriggers() {
+  if (initialized) return;
+  initialized = true;
+
+  bus.on('pipeline-event', (event) => {
+    try {
+      // When QA finds bugs
+      if (event.event === 'stage_error' && event.data?.stage === 'browser-qa') {
+        openThread({
+          title: `Browser QA failures: ${event.data.report?.failed || 'unknown'} pages`,
+          initiator: 'QA',
+          type: 'bug',
+          context: `QA found ${event.data.failedRoutes?.length || 0} failing routes:\n${(event.data.failedRoutes || []).join('\n')}`,
+          participants: ['CODER', 'PM'],
+        });
+      }
+
+      // When bugfix loop exhausted
+      if (event.event === 'qa_bugfix_exhausted') {
+        openThread({
+          title: `Bug-fix loop exhausted after ${event.data?.cycles || '?'} cycles`,
+          initiator: 'PM',
+          type: 'escalation',
+          context: `${event.data?.remainingFails || '?'} page(s) still failing after ${event.data?.cycles || '?'} fix attempts. CEO intervention needed.`,
+          participants: ['QA', 'CODER'],
+        });
+      }
+
+      // When review rejects
+      if (event.event === 'stage_complete' && event.data?.stage === 'review' && event.data?.verdict === 'REJECTED') {
+        openThread({
+          title: `Code review rejected: ${(event.data.reason || 'see feedback').slice(0, 60)}`,
+          initiator: 'REVIEWER',
+          type: 'review',
+          context: event.data.feedback || 'No detailed feedback provided',
+          participants: ['CODER', 'ARCHITECT'],
+        });
+      }
+
+      // When cost guard exceeded
+      if (event.event === 'cost_exceeded') {
+        openThread({
+          title: `Cost guard exceeded: $${event.data?.current?.toFixed(2) || '?'}`,
+          initiator: 'PM',
+          type: 'escalation',
+          context: event.data?.message || 'AI spend exceeded the configured limit.',
+          participants: ['CEO'],
+        });
+      }
+    } catch { /* thread creation should never crash the pipeline */ }
+  });
+}

package/lib/roleplay/agent-messenger.js

@@ -0,0 +1,75 @@
+export const AGENT_IDENTITIES = {
+  pm:        { name: 'PM',        emoji: '📋', color: '#4285F4', prefix: '[PM]' },
+  architect: { name: 'Architect', emoji: '🏗',  color: '#7C3AED', prefix: '[Architect]' },
+  coder:     { name: 'Coder',     emoji: '⚡',  color: '#22C55E', prefix: '[Coder]' },
+  reviewer:  { name: 'Reviewer',  emoji: '🔍',  color: '#F59E0B', prefix: '[Reviewer]' },
+  deployer:  { name: 'Deployer',  emoji: '📦',  color: '#EF4444', prefix: '[Deployer]' },
+  system:    { name: 'System',    emoji: '🤖',  color: '#6B7280', prefix: '[System]' },
+};
+
+// Type prefix map for Telegram formatting
+const TYPE_PREFIX = {
+  status:   '_',
+  handoff:  '',
+  error:    '⚠️ ',
+  question: '❓ ',
+  text:     '',
+  action:   '',
+};
+
+export function formatForTelegram(role, message, type = 'text') {
+  const id = AGENT_IDENTITIES[role] || AGENT_IDENTITIES.system;
+  const prefix = TYPE_PREFIX[type] || '';
+  return `${id.emoji} *${id.name}*: ${prefix}${message}`;
+}
+
+export function formatForSlack(role, message, type = 'text') {
+  const id = AGENT_IDENTITIES[role] || AGENT_IDENTITIES.system;
+  const prefix = TYPE_PREFIX[type] || '';
+  return {
+    blocks: [
+      {
+        type: 'context',
+        elements: [
+          { type: 'mrkdwn', text: `${id.emoji} *${id.name}*` },
+        ],
+      },
+      {
+        type: 'section',
+        text: { type: 'mrkdwn', text: `${prefix}${message}` },
+      },
+    ],
+    attachments: [
+      { color: id.color, fallback: `${id.name}: ${message}` },
+    ],
+  };
+}
+
+export function formatForWebSocket(role, message, type = 'text') {
+  const id = AGENT_IDENTITIES[role] || AGENT_IDENTITIES.system;
+  return {
+    role,
+    name: id.name,
+    emoji: id.emoji,
+    color: id.color,
+    message,
+    type,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export function formatForOffice(role, message, type = 'text') {
+  const id = AGENT_IDENTITIES[role] || AGENT_IDENTITIES.system;
+  return {
+    role,
+    name: id.name,
+    emoji: id.emoji,
+    message,
+    type,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export function getIdentity(role) {
+  return AGENT_IDENTITIES[role] || AGENT_IDENTITIES.system;
+}