@stackbilt/aegis-core 0.1.0

package/src/routes/dynamic-tools.ts

@@ -0,0 +1,111 @@
+// Dynamic Tools API — CRUD + invocation for runtime-created tools
+
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import type { Env } from '../types.js';
+import {
+  createDynamicTool,
+  getDynamicTool,
+  listDynamicTools,
+  updateDynamicTool,
+  retireDynamicTool,
+  executeDynamicTool,
+  invalidateToolCache,
+} from '../kernel/dynamic-tools.js';
+import { buildEdgeEnv } from '../edge-env.js';
+import type { ToolExecutor, ToolStatus } from '../schema-enums.js';
+
+const DYNAMIC_TOOLS_BODY_LIMIT = 100 * 1024;
+
+const dynamicToolsRoutes = new Hono<{ Bindings: Env }>();
+
+// GET /api/dynamic-tools — list active tools
+dynamicToolsRoutes.get('/api/dynamic-tools', async (c) => {
+  const status = c.req.query('status');
+  const limit = Math.min(Number(c.req.query('limit') ?? 50), 100);
+  const tools = await listDynamicTools(c.env.DB, { status: status ?? undefined, limit });
+  return c.json({ tools, count: tools.length });
+});
+
+// POST /api/dynamic-tools — create a new tool
+dynamicToolsRoutes.post('/api/dynamic-tools', bodyLimit({ maxSize: DYNAMIC_TOOLS_BODY_LIMIT }), async (c) => {
+  try {
+    const body = await c.req.json<{
+      name: string;
+      description: string;
+      input_schema?: string;
+      prompt_template: string;
+      executor?: ToolExecutor;
+      created_by?: string;
+      ttl_days?: number;
+      status?: 'active' | 'draft';
+    }>();
+
+    if (!body.name || !body.description || !body.prompt_template) {
+      return c.json({ error: 'name, description, and prompt_template are required' }, 400);
+    }
+
+    const id = await createDynamicTool(c.env.DB, body);
+    invalidateToolCache();
+    return c.json({ id, name: body.name, status: body.status ?? 'active' }, 201);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 400);
+  }
+});
+
+// GET /api/dynamic-tools/:id — get tool details
+dynamicToolsRoutes.get('/api/dynamic-tools/:id', async (c) => {
+  const tool = await getDynamicTool(c.env.DB, c.req.param('id'));
+  if (!tool) return c.json({ error: 'Not found' }, 404);
+  return c.json(tool);
+});
+
+// PUT /api/dynamic-tools/:id — update a tool
+dynamicToolsRoutes.put('/api/dynamic-tools/:id', async (c) => {
+  const id = c.req.param('id');
+  const tool = await getDynamicTool(c.env.DB, id);
+  if (!tool) return c.json({ error: 'Not found' }, 404);
+
+  const body = await c.req.json<{
+    description?: string;
+    prompt_template?: string;
+    executor?: ToolExecutor;
+    input_schema?: string;
+    status?: ToolStatus;
+  }>();
+
+  await updateDynamicTool(c.env.DB, tool.id, body);
+  invalidateToolCache();
+  return c.json({ updated: true, id: tool.id });
+});
+
+// DELETE /api/dynamic-tools/:id — retire a tool
+dynamicToolsRoutes.delete('/api/dynamic-tools/:id', async (c) => {
+  const id = c.req.param('id');
+  const tool = await getDynamicTool(c.env.DB, id);
+  if (!tool) return c.json({ error: 'Not found' }, 404);
+
+  await retireDynamicTool(c.env.DB, tool.id);
+  invalidateToolCache();
+  return c.json({ retired: true, id: tool.id });
+});
+
+// POST /api/dynamic-tools/:id/invoke — execute a dynamic tool
+dynamicToolsRoutes.post('/api/dynamic-tools/:id/invoke', bodyLimit({ maxSize: DYNAMIC_TOOLS_BODY_LIMIT }), async (c) => {
+  const tool = await getDynamicTool(c.env.DB, c.req.param('id'));
+  if (!tool) return c.json({ error: 'Not found' }, 404);
+  if (tool.status === 'draft') return c.json({ error: 'Tool is in draft status — activate it first' }, 400);
+
+  try {
+    const body = await c.req.json<{ inputs?: Record<string, unknown> }>();
+    const env = buildEdgeEnv(c.env);
+    const result = await executeDynamicTool(tool, body.inputs ?? {}, env);
+    return c.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return c.json({ error: msg }, 500);
+  }
+});
+
+export { dynamicToolsRoutes };

package/src/routes/feedback.ts

@@ -0,0 +1,192 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import type { Env } from '../types.js';
+import { McpClient } from '../mcp-client.js';
+import { addAgendaItem } from '../kernel/memory/agenda.js';
+import { FEEDBACK_CATEGORIES, validateEnum } from '../schema-enums.js';
+
+const FEEDBACK_BODY_LIMIT = 100 * 1024;
+
+export const feedback = new Hono<{ Bindings: Env }>();
+
+// CORS preflight for cross-origin feedback submissions (Client App UI → AEGIS)
+feedback.options('/api/feedback', (c) => {
+  return new Response(null, {
+    status: 204,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+      'Access-Control-Allow-Headers': 'Content-Type',
+      'Access-Control-Max-Age': '86400',
+    },
+  });
+});
+
+// Middleware: add CORS headers to all feedback responses
+feedback.use('/api/feedback', async (c, next) => {
+  await next();
+  c.header('Access-Control-Allow-Origin', '*');
+});
+
+feedback.post('/api/feedback', bodyLimit({ maxSize: FEEDBACK_BODY_LIMIT }), async (c) => {
+  const body = await c.req.json<{ email?: string; category?: string; message?: string }>().catch(() => null);
+  if (!body?.message || body.message.length < 5 || body.message.length > 5000) {
+    return c.json({ error: 'message required (5-5000 chars)' }, 400);
+  }
+  const category = validateEnum(FEEDBACK_CATEGORIES, body.category, 'general');
+  const id = crypto.randomUUID();
+  const userAgent = c.req.header('User-Agent') ?? null;
+  await c.env.DB.prepare(
+    'INSERT INTO feedback (id, email, category, message, source, user_agent) VALUES (?, ?, ?, ?, ?, ?)'
+  ).bind(id, body.email ?? null, category, body.message, 'web', userAgent).run();
+
+  // Notify operator via email
+  if (c.env.RESEND_API_KEY) {
+    const subject = `[Feedback] ${category}: ${body.message.slice(0, 60)}${body.message.length > 60 ? '…' : ''}`;
+    const html = `<p><strong>Category:</strong> ${category}</p>
+      <p><strong>From:</strong> ${body.email ?? 'anonymous'}</p>
+      <p><strong>Message:</strong></p><p>${body.message.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</p>`;
+    try {
+      await fetch('https://api.resend.com/emails', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${c.env.RESEND_API_KEY}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ from: 'AEGIS <agent@example.com>', to: 'admin@example.com', subject, html }),
+      });
+    } catch { /* best-effort */ }
+  }
+
+  // ─── BizOps CRM integration ────────────────────────────────
+  // Wire feedback to CRM contacts + interactions (mirrors voice funnel pattern)
+  // TarotScript triage-cast runs first for deterministic classification
+  const email = body.email;
+  const message = body.message;
+  if (email && c.env.BIZOPS && c.env.BIZOPS_TOKEN) {
+    const crmWork = async () => {
+      try {
+        // ─── TarotScript triage-cast (zero-inference classification) ──
+        let triage: { ticket_category?: string; urgency_level?: string; sentiment_signal?: string; complexity_tier?: string; needs_escalation?: boolean } = {};
+        if (c.env.TAROTSCRIPT) {
+          try {
+            const triageRes = await c.env.TAROTSCRIPT.fetch('https://internal/run', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                spreadType: 'triage-cast',
+                querent: {
+                  id: email,
+                  intention: message,
+                  state: { source: 'human', channel: 'feedback_form', account_tier: 'free' },
+                },
+              }),
+            });
+            if (triageRes.ok) {
+              const triageData = await triageRes.json<{ facts?: typeof triage }>();
+              triage = triageData.facts ?? {};
+              console.log(`[feedback] triage-cast: category=${triage.ticket_category} urgency=${triage.urgency_level} sentiment=${triage.sentiment_signal} escalation=${triage.needs_escalation}`);
+            }
+          } catch (err) {
+            console.warn('[feedback] triage-cast failed:', err instanceof Error ? err.message : String(err));
+          }
+        }
+
+        const bizops = new McpClient({
+          url: 'https://your-bizops.example.com/mcp',
+          token: c.env.BIZOPS_TOKEN,
+          prefix: 'bizops',
+          fetcher: c.env.BIZOPS,
+          rpcPath: '/rpc',
+        });
+
+        const STACKBILT_ORG_ID = 'f876b6eb-332f-44a8-9683-342b2147d98b';
+
+        // Upsert contact
+        let contactId: string | undefined;
+        try {
+          const searchResult = await bizops.callTool('search_contacts', { query: email });
+          const parsed = JSON.parse(searchResult);
+          if (parsed.contacts?.length > 0) {
+            contactId = parsed.contacts[0].id;
+          }
+        } catch {
+          // Contact search failed — proceed to create
+        }
+
+        if (!contactId) {
+          try {
+            const name = email.split('@')[0] || 'Anonymous';
+            const createResult = await bizops.callTool('create_contact', {
+              org_id: STACKBILT_ORG_ID,
+              name,
+              email,
+              source: 'FEEDBACK',
+            });
+            const parsed = JSON.parse(createResult);
+            if (parsed.id) contactId = parsed.id;
+          } catch {
+            // Contact creation failed
+          }
+        }
+
+        // Log interaction — enriched with triage-cast classification
+        if (contactId) {
+          const triageCategory = triage.ticket_category ?? category;
+          const interactionBody = [
+            `**Category:** ${triageCategory}`,
+            triage.urgency_level ? `**Urgency:** ${triage.urgency_level}` : '',
+            triage.sentiment_signal ? `**Sentiment:** ${triage.sentiment_signal}` : '',
+            triage.complexity_tier ? `**Complexity:** ${triage.complexity_tier}` : '',
+            triage.needs_escalation ? '**⚠ ESCALATION FLAGGED**' : '',
+            `**Message:** ${message}`,
+            userAgent ? `**User-Agent:** ${userAgent}` : '',
+          ].filter(Boolean).join('\n');
+
+          await bizops.callTool('log_interaction', {
+            org_id: STACKBILT_ORG_ID,
+            contact_id: contactId,
+            type: 'FEEDBACK',
+            direction: 'INBOUND',
+            subject: `[${triageCategory}] ${message.slice(0, 80)}`,
+            body: interactionBody.slice(0, 5000),
+            channel: 'web_form',
+            metadata_json: JSON.stringify({
+              category: triageCategory,
+              triage,
+              user_agent: userAgent,
+            }),
+          });
+        }
+
+        // Create agenda item — priority informed by triage
+        const triagePriority = triage.needs_escalation || triage.urgency_level === 'critical'
+          ? 'high' as const
+          : (category === 'bug' || triage.urgency_level === 'high')
+            ? 'high' as const
+            : 'medium' as const;
+        await addAgendaItem(
+          c.env.DB,
+          `Follow up on ${triage.ticket_category ?? category} feedback from ${email}`,
+          JSON.stringify({ feedback_id: id, category: triage.ticket_category ?? category, urgency: triage.urgency_level, sentiment: triage.sentiment_signal, email, message_preview: message.slice(0, 200) }),
+          triagePriority,
+        );
+      } catch {
+        // Non-fatal — feedback already stored in D1 + email sent
+      }
+    };
+
+    if (c.executionCtx) {
+      c.executionCtx.waitUntil(crmWork());
+    } else {
+      await crmWork();
+    }
+  }
+
+  return c.json({ id, received: true });
+});
+
+feedback.get('/api/feedback', async (c) => {
+  const limit = Math.min(parseInt(c.req.query('limit') ?? '50', 10), 200);
+  const rows = await c.env.DB.prepare(
+    'SELECT id, email, category, message, source, created_at FROM feedback ORDER BY created_at DESC LIMIT ?'
+  ).bind(limit).all();
+  return c.json({ feedback: rows.results });
+});

package/src/routes/health.ts

@@ -0,0 +1,147 @@
+import { Hono } from 'hono';
+import type { Env } from '../types.js';
+import { getAllProcedures } from '../kernel/memory/index.js';
+import { VERSION } from '../version.js';
+import { healthPage, type HealthData } from '../health-page.js';
+
+/** Allow consuming apps to override the reported version (set by createAegisApp). */
+let appVersion: string | undefined;
+export function setAppVersion(v: string): void { appVersion = v; }
+
+interface CostHealthEntry {
+  spend_usd: number;
+  monthly_budget: number;
+  threshold_tier: string;
+  projected_depletion_days: number | null;
+  burn_rate_per_hour: number;
+}
+
+async function loadCostHealth(db: D1Database): Promise<Record<string, CostHealthEntry> | null> {
+  // Tables are owned by cost-monitor scheduled task; may not exist in fresh installs.
+  const budgets = await db
+    .prepare('SELECT provider, monthly_budget, current_spend, threshold_tier, current_period_start FROM cost_budgets')
+    .all<{ provider: string; monthly_budget: number; current_spend: number; threshold_tier: string; current_period_start: string }>()
+    .catch(() => null);
+  if (!budgets || budgets.results.length === 0) return null;
+
+  const result: Record<string, CostHealthEntry> = {};
+  for (const b of budgets.results) {
+    // Latest snapshot = best burn-rate signal. Fall back to spend/hours_elapsed.
+    const snap = await db
+      .prepare(
+        'SELECT burn_rate_per_hour FROM cost_snapshots WHERE provider = ?1 ORDER BY created_at DESC LIMIT 1'
+      )
+      .bind(b.provider)
+      .first<{ burn_rate_per_hour: number }>()
+      .catch(() => null);
+
+    let burn = snap?.burn_rate_per_hour ?? 0;
+    if (!burn && b.current_spend > 0) {
+      const hoursElapsed = Math.max(
+        1,
+        (Date.now() - new Date(b.current_period_start + 'Z').getTime()) / 3_600_000
+      );
+      burn = b.current_spend / hoursElapsed;
+    }
+
+    let depletion: number | null = null;
+    if (b.monthly_budget > 0 && burn > 0) {
+      const remaining = b.monthly_budget - b.current_spend;
+      depletion = remaining <= 0 ? 0 : remaining / burn / 24;
+    }
+
+    result[b.provider] = {
+      spend_usd: Number(b.current_spend.toFixed(4)),
+      monthly_budget: b.monthly_budget,
+      threshold_tier: b.threshold_tier,
+      projected_depletion_days: depletion != null ? Number(depletion.toFixed(2)) : null,
+      burn_rate_per_hour: Number(burn.toFixed(6)),
+    };
+  }
+  return result;
+}
+
+export const health = new Hono<{ Bindings: Env }>();
+
+health.get('/health', async (c) => {
+  const procedures = await getAllProcedures(c.env.DB);
+
+  // Last 24h task run stats
+  const taskStats = await c.env.DB.prepare(`
+    SELECT task_name,
+      COUNT(*) as runs,
+      SUM(CASE WHEN status = 'ok' THEN 1 ELSE 0 END) as ok,
+      SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as errors,
+      MAX(created_at) as last_run
+    FROM task_runs
+    WHERE created_at > datetime('now', '-24 hours')
+    GROUP BY task_name
+    ORDER BY errors DESC, task_name
+  `).all<{ task_name: string; runs: number; ok: number; errors: number; last_run: string }>().catch(() => ({ results: [] }));
+
+  const kernel = {
+    learned: procedures.filter(p => p.status === 'learned').length,
+    learning: procedures.filter(p => p.status === 'learning').length,
+    degraded: procedures.filter(p => p.status === 'degraded').length,
+    broken: procedures.filter(p => p.status === 'broken').length,
+  };
+
+  // Docs sync staleness watermark
+  const lastDocSync = await c.env.DB.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'last_docs_sync_at'"
+  ).first<{ received_at: string }>().catch(() => null);
+  const docsSyncAgeMs = lastDocSync ? Date.now() - new Date(lastDocSync.received_at + 'Z').getTime() : null;
+  const docsSyncAgeHours = docsSyncAgeMs != null ? Math.round(docsSyncAgeMs / 3_600_000) : null;
+  const docsSyncStatus = {
+    lastSyncAge: docsSyncAgeHours,
+    status: (docsSyncAgeHours == null || docsSyncAgeHours > 168 ? 'alert' : docsSyncAgeHours > 48 ? 'warn' : 'ok') as 'ok' | 'warn' | 'alert',
+  };
+
+  // JSON response for programmatic consumers (?format=json, explicit Accept, curl)
+  const accept = c.req.header('accept') ?? '';
+  const wantsJson = c.req.query('format') === 'json'
+    || (accept.includes('application/json') && !accept.includes('text/html'));
+
+  if (wantsJson) {
+    const costHealth = await loadCostHealth(c.env.DB);
+    return c.json({
+      status: 'ok',
+      service: 'aegis-web',
+      version: appVersion ?? VERSION,
+      mode: 'edge-native',
+      timestamp: new Date().toISOString(),
+      kernel,
+      tasks_24h: taskStats.results,
+      docs_sync_status: docsSyncStatus,
+      cost_health: costHealth,
+    });
+  }
+
+  // Gather extra stats for the HTML dashboard (non-sensitive counts only)
+  const [memoryRow, agendaRow, goalRow, uptimeRow] = await Promise.all([
+    // Memory count from Memory Worker (sole knowledge store)
+    c.env.MEMORY
+      ? c.env.MEMORY.health().then(h => ({ c: h.active_fragments })).catch(() => ({ c: 0 }))
+      : Promise.resolve({ c: 0 }),
+    c.env.DB.prepare("SELECT COUNT(*) as c FROM agent_agenda WHERE status = 'active'").first<{ c: number }>().catch(() => ({ c: 0 })),
+    c.env.DB.prepare("SELECT COUNT(*) as c FROM agent_goals WHERE status = 'active'").first<{ c: number }>().catch(() => ({ c: 0 })),
+    c.env.DB.prepare("SELECT MIN(created_at) as first_run FROM task_runs").first<{ first_run: string | null }>().catch(() => ({ first_run: null })),
+  ]);
+
+  const uptimeHours = uptimeRow?.first_run
+    ? Math.round((Date.now() - new Date(uptimeRow.first_run + 'Z').getTime()) / 3_600_000)
+    : 0;
+
+  const healthData: HealthData = {
+    version: appVersion ?? VERSION,
+    kernel,
+    tasks: taskStats.results,
+    memoryCount: memoryRow?.c ?? 0,
+    agendaCount: agendaRow?.c ?? 0,
+    goalCount: goalRow?.c ?? 0,
+    uptimeHours,
+    docsSyncStatus,
+  };
+
+  return c.html(healthPage(healthData));
+});

package/src/routes/messages.ts

@@ -0,0 +1,228 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { createIntent, dispatch, dispatchStream } from '../kernel/dispatch.js';
+import { askGroq } from '../groq.js';
+import type { Env, MessageMetadata } from '../types.js';
+import { buildEdgeEnv } from '../edge-env.js';
+
+// 100 KB — generous for chat text, blocks payload abuse
+const MESSAGE_BODY_LIMIT = 100 * 1024;
+
+const messages = new Hono<{ Bindings: Env }>();
+
+// ─── Gateway URL helpers ──────────────────────────────────
+
+function groqBaseUrl(env: Env): string | undefined {
+  if (!env.AI_GATEWAY_ID) return undefined;
+  if (!env.CF_ACCOUNT_ID) return undefined;
+  return `https://gateway.ai.cloudflare.com/v1/${env.CF_ACCOUNT_ID}/${env.AI_GATEWAY_ID}/groq`;
+}
+
+// ─── Auto-generate conversation title (#21) ──────────────
+
+async function generateConversationTitle(
+  db: D1Database,
+  conversationId: string,
+  firstMessage: string,
+  groqApiKey: string,
+  groqModel: string,
+  groqBase?: string,
+): Promise<void> {
+  try {
+    const title = await askGroq(
+      groqApiKey,
+      groqModel,
+      'Generate a concise 3-6 word title for a conversation that starts with the following message. Return ONLY the title, no quotes, no punctuation at the end.',
+      firstMessage,
+      groqBase,
+    );
+    const cleaned = title.trim().slice(0, 100);
+    if (cleaned) {
+      await db.prepare('UPDATE conversations SET title = ? WHERE id = ?').bind(cleaned, conversationId).run();
+    }
+  } catch {
+    // Non-fatal — leaves first-message slice as title
+  }
+}
+
+// ─── Send Message (edge-native kernel) ───────────────────────
+messages.post('/api/message', bodyLimit({ maxSize: MESSAGE_BODY_LIMIT }), async (c) => {
+  const body = await c.req.json<{ text: string; conversationId?: string }>();
+  if (!body.text?.trim()) {
+    return c.json({ error: 'text is required' }, 400);
+  }
+
+  const text = body.text.trim();
+  const conversationId = body.conversationId ?? crypto.randomUUID();
+  const userMessageId = crypto.randomUUID();
+  const eventId = crypto.randomUUID();
+
+  // Event dedup
+  const existing = await c.env.DB.prepare(
+    'SELECT event_id FROM web_events WHERE event_id = ?'
+  ).bind(eventId).first();
+  if (existing) {
+    return c.json({ error: 'duplicate event' }, 409);
+  }
+  await c.env.DB.prepare(
+    'INSERT INTO web_events (event_id) VALUES (?)'
+  ).bind(eventId).run();
+
+  // Ensure conversation exists
+  const convInsert = await c.env.DB.prepare(
+    'INSERT OR IGNORE INTO conversations (id, title) VALUES (?, ?)'
+  ).bind(conversationId, text.slice(0, 100)).run();
+  const isNewConversation = (convInsert.meta.changes ?? 0) > 0;
+
+  // Save user message
+  await c.env.DB.prepare(
+    'INSERT INTO messages (id, conversation_id, role, content) VALUES (?, ?, ?, ?)'
+  ).bind(userMessageId, conversationId, 'user', text).run();
+
+  // Fire-and-forget title generation for new conversations (#21)
+  if (isNewConversation && c.executionCtx) {
+    c.executionCtx.waitUntil(
+      generateConversationTitle(c.env.DB, conversationId, text, c.env.GROQ_API_KEY, c.env.GROQ_MODEL || 'llama-3.3-70b-versatile', groqBaseUrl(c.env)),
+    );
+  }
+
+  // Dispatch through edge kernel
+  const edgeEnv = buildEdgeEnv(c.env, c.executionCtx);
+  const intent = createIntent(conversationId, text);
+
+  try {
+    const result = await dispatch(intent, edgeEnv);
+
+    // Save assistant message
+    const assistantMessageId = crypto.randomUUID();
+    const metadata: MessageMetadata = {
+      classification: result.classification,
+      executor: result.executor,
+      procHit: result.procedureHit,
+      latencyMs: result.latency_ms,
+      cost: result.cost,
+      confidence: result.confidence,
+      reclassified: result.reclassified,
+      probeResult: result.probeResult,
+    };
+
+    await c.env.DB.prepare(
+      'INSERT INTO messages (id, conversation_id, role, content, metadata) VALUES (?, ?, ?, ?, ?)'
+    ).bind(assistantMessageId, conversationId, 'assistant', result.text, JSON.stringify(metadata)).run();
+
+    await c.env.DB.prepare(
+      "UPDATE conversations SET updated_at = datetime('now') WHERE id = ?"
+    ).bind(conversationId).run();
+
+    return c.json({
+      conversationId,
+      message: {
+        id: assistantMessageId,
+        role: 'assistant',
+        content: result.text,
+        metadata,
+      },
+    });
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMessageId = crypto.randomUUID();
+
+    await c.env.DB.prepare(
+      'INSERT INTO messages (id, conversation_id, role, content, metadata) VALUES (?, ?, ?, ?, ?)'
+    ).bind(errMessageId, conversationId, 'assistant', `Error: ${errMsg}`, JSON.stringify({ error: true })).run();
+
+    console.error('Kernel error:', errMsg);
+    return c.json({
+      conversationId,
+      message: {
+        id: errMessageId,
+        role: 'assistant',
+        content: 'An error occurred processing your message',
+        metadata: { error: true },
+      },
+    }, 500);
+  }
+});
+
+// ─── Streaming Message (SSE) ─────────────────────────────────
+messages.post('/api/message/stream', bodyLimit({ maxSize: MESSAGE_BODY_LIMIT }), async (c) => {
+  const body = await c.req.json<{ text: string; conversationId?: string }>();
+  if (!body.text?.trim()) {
+    return c.json({ error: 'text is required' }, 400);
+  }
+
+  const text = body.text.trim();
+  const conversationId = body.conversationId ?? crypto.randomUUID();
+  const userMessageId = crypto.randomUUID();
+  const eventId = crypto.randomUUID();
+
+  // Event dedup
+  const existing = await c.env.DB.prepare(
+    'SELECT event_id FROM web_events WHERE event_id = ?'
+  ).bind(eventId).first();
+  if (existing) return c.json({ error: 'duplicate event' }, 409);
+  await c.env.DB.prepare('INSERT INTO web_events (event_id) VALUES (?)').bind(eventId).run();
+
+  // Ensure conversation + save user message
+  const convInsertStream = await c.env.DB.prepare('INSERT OR IGNORE INTO conversations (id, title) VALUES (?, ?)').bind(conversationId, text.slice(0, 100)).run();
+  const isNewConvStream = (convInsertStream.meta.changes ?? 0) > 0;
+  await c.env.DB.prepare('INSERT INTO messages (id, conversation_id, role, content) VALUES (?, ?, ?, ?)').bind(userMessageId, conversationId, 'user', text).run();
+
+  // Fire-and-forget title generation for new conversations (#21)
+  if (isNewConvStream && c.executionCtx) {
+    c.executionCtx.waitUntil(
+      generateConversationTitle(c.env.DB, conversationId, text, c.env.GROQ_API_KEY, c.env.GROQ_MODEL || 'llama-3.3-70b-versatile', groqBaseUrl(c.env)),
+    );
+  }
+
+  const edgeEnv = buildEdgeEnv(c.env, c.executionCtx);
+  const intent = createIntent(conversationId, text);
+
+  const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>();
+  const writer = writable.getWriter();
+  const encoder = new TextEncoder();
+
+  const writeSSE = (data: unknown) => writer.write(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+
+  // Run dispatch async — stream stays open until writer.close()
+  (async () => {
+    try {
+      await writeSSE({ type: 'start', conversationId });
+
+      const result = await dispatchStream(intent, edgeEnv, async (delta) => {
+        await writeSSE({ type: 'delta', text: delta });
+      });
+
+      // Persist assistant message
+      const assistantMessageId = crypto.randomUUID();
+      const metadata: MessageMetadata = {
+        classification: result.classification,
+        executor: result.executor,
+        procHit: result.procedureHit,
+        latencyMs: result.latency_ms,
+        cost: result.cost,
+        confidence: result.confidence,
+        reclassified: result.reclassified,
+        probeResult: result.probeResult,
+      };
+      await c.env.DB.prepare('INSERT INTO messages (id, conversation_id, role, content, metadata) VALUES (?, ?, ?, ?, ?)').bind(assistantMessageId, conversationId, 'assistant', result.text, JSON.stringify(metadata)).run();
+      await c.env.DB.prepare("UPDATE conversations SET updated_at = datetime('now') WHERE id = ?").bind(conversationId).run();
+
+      await writeSSE({ type: 'done', conversationId, metadata: { id: assistantMessageId, ...metadata } });
+    } catch (err) {
+      await writeSSE({ type: 'error', error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      await writer.close();
+    }
+  })();
+
+  return new Response(readable, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+});
+
+export { messages };