@stackbilt/aegis-core 0.1.0

package/src/kernel/scheduled/agent-dispatch.ts

@@ -0,0 +1,252 @@
+// --- Agent Dispatch -- Proactive Inter-Agent Coordination ---
+// Runs hourly in the heartbeat phase. Scans recent events, task
+// completions, and repo activity, then inboxes the right agent
+// without human intervention.
+//
+// AEGIS is the orchestrator. Agents are specialists:
+//   CodeBeast -- adversarial code review
+//   MARA     -- colony governance, multi-agent coordination
+//   Sera     -- symbolic classification
+//
+// This module replaces the operator as the manual message bus.
+
+import { type EdgeEnv } from '../dispatch.js';
+
+// --- Agent Capability Registry ---
+
+interface AgentCapability {
+  id: string;
+  name: string;
+  capabilities: string[];
+  inboxRecipient: string;
+}
+
+const AGENTS: AgentCapability[] = [
+  {
+    id: 'codebeast',
+    name: 'CodeBeast',
+    capabilities: ['code_review', 'security_audit', 'adversarial_review', 'fix_suggestion'],
+    inboxRecipient: 'codebeast',
+  },
+  {
+    id: 'mara',
+    name: 'MARA',
+    capabilities: ['governance', 'colony_coordination', 'agent_lifecycle', 'resource_allocation'],
+    inboxRecipient: 'mara',
+  },
+  {
+    id: 'sera',
+    name: 'Sera',
+    capabilities: ['classification', 'symbolic_computation', 'tarotscript', 'intent_analysis'],
+    inboxRecipient: 'sera',
+  },
+];
+
+// --- Inbox Helper ---
+
+async function sendInboxMessage(
+  db: D1Database,
+  recipient: string,
+  msgType: string,
+  subject: string,
+  body: string,
+  channel = 'ops',
+): Promise<void> {
+  const id = crypto.randomUUID();
+  await db.prepare(`
+    INSERT INTO agent_inbox (id, sender, recipient, channel, msg_type, subject, body)
+    VALUES (?, 'aegis', ?, ?, ?, ?, ?)
+  `).bind(id, recipient, channel, msgType, subject, body).run();
+  console.log(`[agent-dispatch] Sent ${msgType} to ${recipient}: ${subject}`);
+}
+
+// --- Watermark Helper ---
+
+async function getWatermark(db: D1Database, key: string): Promise<string | null> {
+  const row = await db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = ? LIMIT 1"
+  ).bind(`dispatch_watermark:${key}`).first<{ received_at: string }>();
+  return row?.received_at ?? null;
+}
+
+async function setWatermark(db: D1Database, key: string): Promise<void> {
+  await db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES (?, datetime('now'))"
+  ).bind(`dispatch_watermark:${key}`).run();
+}
+
+// --- Trigger: Merged PRs -> CodeBeast Review ---
+// When PRs merge on watched repos, auto-request CodeBeast review.
+
+async function dispatchMergedPrReviews(db: D1Database): Promise<number> {
+  const watermark = await getWatermark(db, 'pr_reviews');
+  const since = watermark || "datetime('now', '-2 hours')";
+
+  // Find recently merged PRs from ARGUS events
+  const events = await db.prepare(`
+    SELECT payload, ts FROM events
+    WHERE source = 'github'
+      AND event_type = 'pull_request.merged'
+      AND ts > ?
+    ORDER BY ts ASC
+    LIMIT 10
+  `).bind(since).all<{ payload: string; ts: string }>();
+
+  let dispatched = 0;
+  for (const event of events.results ?? []) {
+    try {
+      const payload = JSON.parse(event.payload);
+      const pr = payload.pull_request ?? payload;
+      const repo = (payload.repository?.full_name as string) ?? '';
+      const prNumber = pr.number ?? 0;
+      const title = pr.title ?? '';
+      const additions = pr.additions ?? 0;
+      const deletions = pr.deletions ?? 0;
+      const totalLoc = additions + deletions;
+
+      // Skip tiny PRs (< 10 LOC) and auto-branch PRs from taskrunner
+      if (totalLoc < 10) continue;
+      if (title.startsWith('[auto]')) continue;
+
+      // Dedup: check if we already requested review for this PR
+      const existingMsg = await db.prepare(
+        "SELECT 1 FROM agent_inbox WHERE sender = 'aegis' AND recipient = 'codebeast' AND subject LIKE ? LIMIT 1"
+      ).bind(`%${repo}#${prNumber}%`).first();
+      if (existingMsg) continue;
+
+      await sendInboxMessage(
+        db, 'codebeast', 'context_request',
+        `Review: ${repo}#${prNumber} -- ${title}`,
+        `PR merged: ${title}\nRepo: ${repo}\nPR: #${prNumber}\nLOC: +${additions}/-${deletions}\n\nPlease run adversarial review on this merge. Flag security issues, correctness problems, and test gaps. Post findings back via inbox as alert (critical) or task_proposal (suggested fix).`,
+        'code-review',
+      );
+      dispatched++;
+    } catch {
+      // Skip malformed events
+    }
+  }
+
+  if (dispatched > 0 || (events.results?.length ?? 0) > 0) {
+    await setWatermark(db, 'pr_reviews');
+  }
+
+  return dispatched;
+}
+
+// --- Trigger: Completed Tasks -> Status Updates ---
+// When cc_tasks complete, notify relevant agents if the work
+// touches their domain.
+
+async function dispatchTaskCompletions(db: D1Database): Promise<number> {
+  const watermark = await getWatermark(db, 'task_completions');
+  const since = watermark || "datetime('now', '-2 hours')";
+
+  const tasks = await db.prepare(`
+    SELECT id, title, repo, category, result, exit_code
+    FROM cc_tasks
+    WHERE status = 'completed'
+      AND completed_at > ?
+      AND exit_code = 0
+    ORDER BY completed_at ASC
+    LIMIT 10
+  `).bind(since).all<{
+    id: string; title: string; repo: string; category: string;
+    result: string | null; exit_code: number;
+  }>();
+
+  let dispatched = 0;
+  for (const task of tasks.results ?? []) {
+    // Route to agent based on repo/category
+    const repo = task.repo.toLowerCase();
+
+    // TarotScript work -> notify Sera
+    if (repo.includes('tarotscript') || repo.includes('tarot')) {
+      await sendInboxMessage(
+        db, 'sera', 'status_update',
+        `Task completed: ${task.title.slice(0, 100)}`,
+        `Repo: ${task.repo}\nCategory: ${task.category}\nResult: ${(task.result ?? '').slice(0, 500)}`,
+      );
+      dispatched++;
+    }
+
+    // Colony OS work -> notify MARA
+    if (repo.includes('colony') || repo.includes('colonyos')) {
+      await sendInboxMessage(
+        db, 'mara', 'status_update',
+        `Task completed: ${task.title.slice(0, 100)}`,
+        `Repo: ${task.repo}\nCategory: ${task.category}\nResult: ${(task.result ?? '').slice(0, 500)}`,
+      );
+      dispatched++;
+    }
+  }
+
+  if (dispatched > 0 || (tasks.results?.length ?? 0) > 0) {
+    await setWatermark(db, 'task_completions');
+  }
+
+  return dispatched;
+}
+
+// --- Trigger: Failed Tasks -> Alert Relevant Agent ---
+// When tasks fail repeatedly on the same repo, alert the agent
+// that owns that domain.
+
+async function dispatchTaskFailures(db: D1Database): Promise<number> {
+  // Find repos with 2+ failures in last 24h
+  const failClusters = await db.prepare(`
+    SELECT repo, COUNT(*) as fail_count, GROUP_CONCAT(title, ' | ') as titles
+    FROM cc_tasks
+    WHERE status = 'failed'
+      AND completed_at > datetime('now', '-24 hours')
+    GROUP BY repo
+    HAVING COUNT(*) >= 2
+    LIMIT 5
+  `).all<{ repo: string; fail_count: number; titles: string }>();
+
+  let dispatched = 0;
+  for (const cluster of failClusters.results ?? []) {
+    // Dedup: don't re-alert for same cluster
+    const existing = await db.prepare(
+      "SELECT 1 FROM agent_inbox WHERE sender = 'aegis' AND subject LIKE ? AND created_at > datetime('now', '-24 hours') LIMIT 1"
+    ).bind(`%${cluster.repo}%failure cluster%`).first();
+    if (existing) continue;
+
+    // Route to CodeBeast for code-related failure analysis
+    await sendInboxMessage(
+      db, 'codebeast', 'alert',
+      `${cluster.repo}: failure cluster (${cluster.fail_count} tasks)`,
+      `${cluster.fail_count} tasks failed in ${cluster.repo} in the last 24h.\n\nTitles:\n${cluster.titles.split(' | ').map(t => `- ${t}`).join('\n')}\n\nInvestigate common root cause. Check for environment issues, missing dependencies, or systematic test failures.`,
+      'code-review',
+    );
+    dispatched++;
+  }
+
+  return dispatched;
+}
+
+// --- Main Entry Point ---
+
+export async function runAgentDispatch(env: EdgeEnv): Promise<void> {
+  if (!env.githubToken) {
+    console.log('[agent-dispatch] Skipped: missing githubToken');
+    return;
+  }
+
+  let totalDispatched = 0;
+
+  // 1. Merged PRs -> CodeBeast review
+  const prReviews = await dispatchMergedPrReviews(env.db);
+  totalDispatched += prReviews;
+
+  // 2. Completed tasks -> relevant agent notifications
+  const taskNotifs = await dispatchTaskCompletions(env.db);
+  totalDispatched += taskNotifs;
+
+  // 3. Failure clusters -> CodeBeast alert
+  const failAlerts = await dispatchTaskFailures(env.db);
+  totalDispatched += failAlerts;
+
+  if (totalDispatched > 0) {
+    console.log(`[agent-dispatch] Dispatched ${totalDispatched} messages (PR reviews: ${prReviews}, task notifs: ${taskNotifs}, fail alerts: ${failAlerts})`);
+  }
+}

package/src/kernel/scheduled/argus-analytics.ts

@@ -0,0 +1,247 @@
+// ARGUS Analytics: GA4 insight extraction
+// Queries Google Analytics Data API daily, stores findings for the digest.
+// Surfaces: traffic trends, top pages, traffic sources, bounce anomalies.
+// Zero inference — pure API queries and threshold logic.
+
+import { type EdgeEnv } from '../dispatch.js';
+
+// ─── GA4 OAuth2 ──────────────────────────────────────────────
+
+interface GACredentials {
+  client_id: string;
+  client_secret: string;
+  refresh_token: string;
+  property_id: string;
+}
+
+async function getAccessToken(creds: GACredentials): Promise<string> {
+  const res = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      refresh_token: creds.refresh_token,
+      client_id: creds.client_id,
+      client_secret: creds.client_secret,
+      grant_type: 'refresh_token',
+    }),
+    signal: AbortSignal.timeout(10_000),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`GA token refresh failed: ${res.status} ${err}`);
+  }
+
+  const data = await res.json<{ access_token: string }>();
+  return data.access_token;
+}
+
+// ─── GA4 Data API ────────────────────────────────────────────
+
+interface GAReport {
+  rows?: Array<{
+    dimensionValues: Array<{ value: string }>;
+    metricValues: Array<{ value: string }>;
+  }>;
+  rowCount?: number;
+}
+
+async function runReport(
+  accessToken: string,
+  propertyId: string,
+  body: Record<string, unknown>,
+): Promise<GAReport> {
+  const res = await fetch(
+    `https://analyticsdata.googleapis.com/v1beta/properties/${propertyId}:runReport`,
+    {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15_000),
+    },
+  );
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`GA4 report failed: ${res.status} ${err}`);
+  }
+
+  return res.json<GAReport>();
+}
+
+// ─── Analytics Snapshot ──────────────────────────────────────
+
+export interface AnalyticsSnapshot {
+  // Traffic overview
+  sessions_7d: number;
+  sessions_prior_7d: number;
+  users_7d: number;
+  bounce_rate_7d: number;
+
+  // Top pages
+  top_pages: Array<{ path: string; sessions: number; bounce_rate: number }>;
+
+  // Traffic sources
+  top_sources: Array<{ source: string; medium: string; sessions: number }>;
+
+  // Insights (derived)
+  insights: string[];
+
+  computed_at: string;
+}
+
+// ─── Main ────────────────────────────────────────────────────
+
+export async function runArgusAnalytics(env: EdgeEnv): Promise<void> {
+  // Daily gate — run at 08 UTC (before digest at 09)
+  const hour = new Date().getUTCHours();
+  if (hour !== 8) return;
+
+  // Cooldown: 22 hours
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'argus_analytics'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < 22 * 60 * 60 * 1000) return;
+  }
+
+  // Parse credentials from env (JSON: { client_id, client_secret, refresh_token, property_id })
+  const rawCreds = env.gaCredentials;
+  if (!rawCreds) {
+    console.log('[argus-analytics] Skipping — no GA_CREDENTIALS');
+    return;
+  }
+
+  let creds: GACredentials;
+  try {
+    creds = JSON.parse(rawCreds);
+  } catch {
+    console.error('[argus-analytics] Failed to parse GA_CREDENTIALS');
+    return;
+  }
+
+  const accessToken = await getAccessToken(creds);
+
+  // Run reports in parallel
+  const [trafficCurrent, trafficPrior, topPages, sources] = await Promise.all([
+    // Total sessions + users + bounce rate (last 7 days)
+    runReport(accessToken, creds.property_id, {
+      dateRanges: [{ startDate: '7daysAgo', endDate: 'today' }],
+      metrics: [
+        { name: 'sessions' },
+        { name: 'activeUsers' },
+        { name: 'bounceRate' },
+      ],
+    }),
+
+    // Prior 7 days for comparison
+    runReport(accessToken, creds.property_id, {
+      dateRanges: [{ startDate: '14daysAgo', endDate: '8daysAgo' }],
+      metrics: [{ name: 'sessions' }],
+    }),
+
+    // Top pages by sessions
+    runReport(accessToken, creds.property_id, {
+      dateRanges: [{ startDate: '7daysAgo', endDate: 'today' }],
+      dimensions: [{ name: 'pagePath' }],
+      metrics: [{ name: 'sessions' }, { name: 'bounceRate' }],
+      limit: 10,
+      orderBys: [{ metric: { metricName: 'sessions' }, desc: true }],
+    }),
+
+    // Traffic sources
+    runReport(accessToken, creds.property_id, {
+      dateRanges: [{ startDate: '7daysAgo', endDate: 'today' }],
+      dimensions: [{ name: 'sessionSource' }, { name: 'sessionMedium' }],
+      metrics: [{ name: 'sessions' }],
+      limit: 10,
+      orderBys: [{ metric: { metricName: 'sessions' }, desc: true }],
+    }),
+  ]);
+
+  // Parse results
+  const currentRow = trafficCurrent.rows?.[0];
+  const sessions_7d = parseInt(currentRow?.metricValues[0].value ?? '0');
+  const users_7d = parseInt(currentRow?.metricValues[1].value ?? '0');
+  const bounce_rate_7d = parseFloat(currentRow?.metricValues[2].value ?? '0');
+
+  const priorRow = trafficPrior.rows?.[0];
+  const sessions_prior_7d = parseInt(priorRow?.metricValues[0].value ?? '0');
+
+  const top_pages = (topPages.rows ?? []).map(row => ({
+    path: row.dimensionValues[0].value,
+    sessions: parseInt(row.metricValues[0].value),
+    bounce_rate: parseFloat(row.metricValues[1].value),
+  }));
+
+  const top_sources = (sources.rows ?? []).map(row => ({
+    source: row.dimensionValues[0].value,
+    medium: row.dimensionValues[1].value,
+    sessions: parseInt(row.metricValues[0].value),
+  }));
+
+  // Generate insights
+  const insights: string[] = [];
+
+  // Traffic trend
+  if (sessions_prior_7d > 0) {
+    const delta = ((sessions_7d - sessions_prior_7d) / sessions_prior_7d * 100);
+    if (delta > 50) {
+      insights.push(`Traffic up ${Math.round(delta)}% week-over-week (${sessions_prior_7d} → ${sessions_7d} sessions). Find out what's driving it.`);
+    } else if (delta < -30) {
+      insights.push(`Traffic down ${Math.round(Math.abs(delta))}% week-over-week (${sessions_prior_7d} → ${sessions_7d} sessions). Check if something broke or if last week was an anomaly.`);
+    }
+  }
+
+  // Bounce rate
+  if (bounce_rate_7d > 0.8 && sessions_7d > 10) {
+    insights.push(`Overall bounce rate is ${(bounce_rate_7d * 100).toFixed(0)}% — more than 4 out of 5 visitors leave immediately. Landing page isn't converting.`);
+  }
+
+  // High-bounce pages with traffic
+  for (const page of top_pages) {
+    if (page.bounce_rate > 0.9 && page.sessions >= 5) {
+      insights.push(`${page.path} has ${(page.bounce_rate * 100).toFixed(0)}% bounce rate with ${page.sessions} sessions. Users are landing and leaving.`);
+    }
+  }
+
+  // Zero-traffic detection (have pages but nobody's visiting)
+  if (sessions_7d < 5) {
+    insights.push(`Only ${sessions_7d} total sessions this week. No meaningful traffic. Distribution is the bottleneck, not product.`);
+  }
+
+  // New traffic source spike
+  for (const src of top_sources) {
+    if (src.sessions >= 10 && src.source !== '(direct)' && src.source !== '(not set)') {
+      insights.push(`${src.sessions} sessions from ${src.source} (${src.medium}). Worth investigating — is this organic or a mention?`);
+    }
+  }
+
+  const snapshot: AnalyticsSnapshot = {
+    sessions_7d,
+    sessions_prior_7d,
+    users_7d,
+    bounce_rate_7d,
+    top_pages,
+    top_sources,
+    insights,
+    computed_at: new Date().toISOString(),
+  };
+
+  // Store for digest
+  await env.db.prepare(
+    "INSERT INTO digest_sections (section, payload) VALUES ('analytics', ?)"
+  ).bind(JSON.stringify(snapshot)).run();
+
+  // Update watermark
+  await env.db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('argus_analytics', datetime('now'))"
+  ).run();
+
+  console.log(`[argus-analytics] ${sessions_7d} sessions (${sessions_prior_7d} prior), ${users_7d} users, ${(bounce_rate_7d * 100).toFixed(0)}% bounce, ${insights.length} insights`);
+}