@stackbilt/aegis-core 0.1.0

package/src/kernel/scheduled/board-sync.ts

@@ -0,0 +1,110 @@
+// --- Board Sync -- GitHub Projects v2 Reconciliation ---
+// Hourly safety net: fetches all project items from GitHub and
+// reconciles with D1 board_items cache. Catches manual moves,
+// external additions, and any webhook events we missed.
+//
+// Runs every 2 hours (time-gated in scheduled/index.ts).
+// Cost: 2-4 GraphQL API calls per run.
+
+import { type EdgeEnv } from '../dispatch.js';
+import { listProjectItems, type ProjectItem } from '../../github-projects.js';
+import { upsertBoardItem, type BoardColumn, PROJECT_TITLE, ORG_LOGIN } from '../board.js';
+import { findOrCreateProject } from '../../github-projects.js';
+
+/** Map GitHub Projects Status field values to our internal column names. */
+function resolveStatus(item: ProjectItem): BoardColumn {
+  const statusNode = item.fieldValues.nodes.find(n => n.field?.name === 'Status');
+  const statusName = statusNode?.name ?? '';
+  const map: Record<string, BoardColumn> = {
+    'Backlog': 'backlog',
+    'Queued': 'queued',
+    'In Progress': 'in_progress',
+    'Blocked': 'blocked',
+    'Shipped': 'shipped',
+  };
+  return map[statusName] ?? 'backlog';
+}
+
+export async function runBoardSync(env: EdgeEnv): Promise<void> {
+  if (!env.githubToken) {
+    console.log('[board-sync] No GITHUB_TOKEN -- skipping');
+    return;
+  }
+
+  // Get project ID (cached in D1 via web_events)
+  const cachedId = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'board_project_id'"
+  ).first<{ received_at: string }>();
+
+  let projectId = cachedId?.received_at;
+  if (!projectId) {
+    try {
+      projectId = await findOrCreateProject(env.githubToken, ORG_LOGIN, PROJECT_TITLE);
+      await env.db.prepare(
+        "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('board_project_id', ?)"
+      ).bind(projectId).run();
+    } catch (err) {
+      console.error(`[board-sync] Failed to find/create project: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  }
+
+  // Fetch all items from the project (paginated)
+  const allItems: ProjectItem[] = [];
+  let cursor: string | null = null;
+  const maxPages = 4; // Safety: 50 items/page x 4 = 200 max
+
+  for (let page = 0; page < maxPages; page++) {
+    const result = await listProjectItems(env.githubToken, projectId, cursor ?? undefined);
+    allItems.push(...result.items);
+    if (!result.nextCursor) break;
+    cursor = result.nextCursor;
+  }
+
+  // Track which repo+number combinations we see from GitHub
+  const seenKeys = new Set<string>();
+
+  // Upsert each item into D1
+  for (const item of allItems) {
+    if (!item.content) continue; // Draft items have no content
+
+    const repo = item.content.repository.nameWithOwner;
+    const number = item.content.number;
+    const key = `${repo}:${number}`;
+    seenKeys.add(key);
+
+    const labels = item.content.labels.nodes.map(l => l.name);
+    const assignee = item.content.assignees.nodes[0]?.login ?? null;
+    const status = resolveStatus(item);
+
+    await upsertBoardItem(env.db, {
+      id: item.id,
+      project_id: projectId,
+      content_type: item.content.__typename === 'PullRequest' ? 'pr' : 'issue',
+      content_node_id: '', // Not available from list query -- set on first add
+      repo,
+      number,
+      title: item.content.title,
+      status,
+      labels: JSON.stringify(labels),
+      assignee,
+    });
+  }
+
+  // Remove D1 items that no longer exist on the project
+  // (deleted via GitHub UI or removed from project)
+  const localItems = await env.db.prepare(
+    "SELECT repo, number FROM board_items WHERE status != 'shipped'"
+  ).all<{ repo: string; number: number }>();
+
+  for (const local of localItems.results ?? []) {
+    const key = `${local.repo}:${local.number}`;
+    if (!seenKeys.has(key)) {
+      await env.db.prepare(
+        'DELETE FROM board_items WHERE repo = ? AND number = ?'
+      ).bind(local.repo, local.number).run();
+    }
+  }
+
+  console.log(`[board-sync] Synced ${allItems.length} items, ${seenKeys.size} active`);
+}

package/src/kernel/scheduled/ci-watcher.ts

@@ -0,0 +1,125 @@
+// --- CI Failure Watcher ---
+// Polls GitHub Actions workflow runs for watched repos and surfaces
+// failures via the agenda system. Zero LM calls -- pure GitHub API
+// + string matching. Runs hourly in the heartbeat phase.
+
+import { type EdgeEnv } from '../dispatch.js';
+import { listWorkflowRuns, resolveRepoName, type WorkflowRun } from '../../github.js';
+import { addAgendaItem } from '../memory/agenda.js';
+
+const WATCHED_REPO = 'aegis-oss';
+const WATERMARK_KEY = 'last_ci_watcher_run';
+const CHECK_INTERVAL_HOURS = 1;
+
+// Keywords in workflow run names or commit messages that indicate
+// breaking-change risk to key interfaces.
+const BREAKING_CHANGE_KEYWORDS = [
+  'breaking',
+  'interface',
+  'type change',
+  'constructor',
+  'signature',
+  'schema',
+  'migration',
+];
+
+/** Check if a workflow run is relevant to breaking-change interfaces */
+function isBreakingChangeRelated(run: WorkflowRun): boolean {
+  const text = `${run.name} ${run.branch}`.toLowerCase();
+  return BREAKING_CHANGE_KEYWORDS.some(kw => text.includes(kw));
+}
+
+export async function runCiWatcher(env: EdgeEnv): Promise<void> {
+  if (!env.githubToken) {
+    console.log('[ci-watcher] Skipped: missing githubToken');
+    return;
+  }
+
+  // Rate-limit: run once per hour
+  const lastRun = await env.db.prepare(
+    `SELECT received_at FROM web_events WHERE event_id = ?`
+  ).bind(WATERMARK_KEY).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const hoursSince = (Date.now() - new Date(lastRun.received_at + 'Z').getTime()) / (1000 * 60 * 60);
+    if (hoursSince < CHECK_INTERVAL_HOURS) return;
+  }
+
+  const repo = resolveRepoName(WATCHED_REPO);
+
+  // Fetch recent workflow runs (main branch + PRs)
+  let runs: WorkflowRun[];
+  try {
+    runs = await listWorkflowRuns(env.githubToken, repo, undefined, 10);
+  } catch (err) {
+    console.warn(`[ci-watcher] Failed to list workflow runs for ${repo}:`, err instanceof Error ? err.message : String(err));
+    return;
+  }
+
+  if (runs.length === 0) {
+    console.log(`[ci-watcher] ${repo}: no workflow runs found`);
+    await advanceWatermark(env.db);
+    return;
+  }
+
+  // Find failed runs that completed since our last check
+  const sinceDate = lastRun
+    ? new Date(lastRun.received_at + 'Z')
+    : new Date(Date.now() - CHECK_INTERVAL_HOURS * 60 * 60 * 1000);
+
+  const newFailures = runs.filter(r =>
+    r.conclusion === 'failure' &&
+    r.status === 'completed' &&
+    new Date(r.created_at) > sinceDate
+  );
+
+  if (newFailures.length === 0) {
+    console.log(`[ci-watcher] ${repo}: no new failures`);
+    await advanceWatermark(env.db);
+    return;
+  }
+
+  console.log(`[ci-watcher] ${repo}: ${newFailures.length} new CI failure(s)`);
+
+  for (const run of newFailures) {
+    // Dedup: skip if we already created an agenda item for this run
+    const existing = await env.db.prepare(
+      `SELECT 1 FROM web_events WHERE event_id = ? LIMIT 1`
+    ).bind(`ci-fail:${repo}:${run.id}`).first();
+
+    if (existing) continue;
+
+    const isBreaking = isBreakingChangeRelated(run);
+    const priority = run.branch === 'main'
+      ? 'high'
+      : (isBreaking ? 'high' : 'medium');
+
+    const breakingTag = isBreaking ? ' [possible breaking change]' : '';
+    const branchTag = run.branch === 'main' ? ' (main branch)' : ` (branch: ${run.branch})`;
+
+    await addAgendaItem(
+      env.db,
+      `CI failure: "${run.name}"${branchTag}${breakingTag}`,
+      `Workflow run #${run.id} failed on ${run.branch} (event: ${run.event}). ` +
+        `Created: ${run.created_at}. ` +
+        `${isBreaking ? 'May affect key interfaces or schemas. ' : ''}` +
+        `URL: ${run.url}`,
+      priority,
+    );
+
+    // Mark this run as reported
+    await env.db.prepare(
+      `INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES (?, datetime('now'))`
+    ).bind(`ci-fail:${repo}:${run.id}`).run();
+
+    console.log(`[ci-watcher] Agenda item created for run #${run.id} (${priority} priority${breakingTag})`);
+  }
+
+  await advanceWatermark(env.db);
+}
+
+async function advanceWatermark(db: D1Database): Promise<void> {
+  await db.prepare(
+    `INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES (?, datetime('now'))`
+  ).bind(WATERMARK_KEY).run();
+}

package/src/kernel/scheduled/cognitive-metrics.ts

@@ -0,0 +1,377 @@
+// Cognitive Self-Measurement (#255)
+// Computes whether AEGIS is getting smarter by aggregating existing data.
+// Runs daily. Stores a snapshot to D1 for trend analysis.
+// No LLM calls — pure D1 queries.
+
+import { type EdgeEnv } from '../dispatch.js';
+
+// ─── Metrics Schema ──────────────────────────────────────────
+
+export interface CognitiveSnapshot {
+  // Dispatch quality
+  dispatch_success_rate_7d: number;      // % success in last 7 days
+  dispatch_success_rate_prior_7d: number; // % success in prior 7 days (for delta)
+  dispatch_volume_7d: number;
+  avg_cost_7d: number;
+  avg_cost_prior_7d: number;
+  avg_latency_ms_7d: number;
+  avg_latency_ms_prior_7d: number;
+  reclassification_rate_7d: number;      // % of dispatches that got reclassified
+
+  // Procedural learning
+  procedures_learned: number;
+  procedures_learning: number;
+  procedures_degraded: number;
+  procedures_broken: number;
+  procedure_convergence_rate: number;     // learned / total
+
+  // Task execution
+  tasks_completed_7d: number;
+  tasks_failed_7d: number;
+  task_success_rate_7d: number;
+  task_success_rate_prior_7d: number;
+  top_failure_kind: string | null;
+
+  // Scheduled task health
+  scheduled_task_error_rate_24h: number;
+
+  // Classifier source breakdown (classify-cast monitoring)
+  classify_cast_rate_48h: number;       // % of dispatches using classify-cast
+  user_correction_rate_48h: number;     // % of dispatches followed by user_correction
+  classify_cast_correction_rate_48h: number; // user_correction rate specifically for classify-cast episodes
+
+  // Memory growth
+  memory_count: number;
+  memory_count_prior: number;             // from last snapshot
+
+  // Composite score (0-100)
+  cognitive_score: number;
+  score_delta: number;                    // vs last snapshot
+
+  computed_at: string;
+}
+
+// ─── Queries ─────────────────────────────────────────────────
+
+async function queryDispatchMetrics(db: D1Database): Promise<{
+  success_rate_7d: number;
+  success_rate_prior_7d: number;
+  volume_7d: number;
+  avg_cost_7d: number;
+  avg_cost_prior_7d: number;
+  avg_latency_7d: number;
+  avg_latency_prior_7d: number;
+  reclassification_rate_7d: number;
+}> {
+  const [current, prior, reclass] = await Promise.all([
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as successes,
+             AVG(cost) as avg_cost,
+             AVG(latency_ms) as avg_latency
+      FROM episodic_memory
+      WHERE created_at > datetime('now', '-7 days')
+    `).first<{ total: number; successes: number; avg_cost: number; avg_latency: number }>(),
+
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN outcome = 'success' THEN 1 ELSE 0 END) as successes,
+             AVG(cost) as avg_cost,
+             AVG(latency_ms) as avg_latency
+      FROM episodic_memory
+      WHERE created_at > datetime('now', '-14 days')
+        AND created_at <= datetime('now', '-7 days')
+    `).first<{ total: number; successes: number; avg_cost: number; avg_latency: number }>(),
+
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN reclassified = 1 THEN 1 ELSE 0 END) as reclassified
+      FROM episodic_memory
+      WHERE created_at > datetime('now', '-7 days')
+    `).first<{ total: number; reclassified: number }>(),
+  ]);
+
+  const curTotal = current?.total ?? 0;
+  const priorTotal = prior?.total ?? 0;
+
+  return {
+    success_rate_7d: curTotal > 0 ? (current?.successes ?? 0) / curTotal : 1,
+    success_rate_prior_7d: priorTotal > 0 ? (prior?.successes ?? 0) / priorTotal : 1,
+    volume_7d: curTotal,
+    avg_cost_7d: current?.avg_cost ?? 0,
+    avg_cost_prior_7d: prior?.avg_cost ?? 0,
+    avg_latency_7d: current?.avg_latency ?? 0,
+    avg_latency_prior_7d: prior?.avg_latency ?? 0,
+    reclassification_rate_7d: (reclass?.total ?? 0) > 0
+      ? (reclass?.reclassified ?? 0) / (reclass?.total ?? 1)
+      : 0,
+  };
+}
+
+async function queryProceduralMetrics(db: D1Database): Promise<{
+  learned: number;
+  learning: number;
+  degraded: number;
+  broken: number;
+  convergence_rate: number;
+}> {
+  const result = await db.prepare(`
+    SELECT status, COUNT(*) as count
+    FROM procedural_memory
+    GROUP BY status
+  `).all<{ status: string; count: number }>();
+
+  const counts: Record<string, number> = {};
+  for (const row of result.results) {
+    counts[row.status] = row.count;
+  }
+
+  const total = Object.values(counts).reduce((a, b) => a + b, 0);
+
+  return {
+    learned: counts['learned'] ?? 0,
+    learning: counts['learning'] ?? 0,
+    degraded: counts['degraded'] ?? 0,
+    broken: counts['broken'] ?? 0,
+    convergence_rate: total > 0 ? (counts['learned'] ?? 0) / total : 0,
+  };
+}
+
+async function queryTaskMetrics(db: D1Database): Promise<{
+  completed_7d: number;
+  failed_7d: number;
+  success_rate_7d: number;
+  success_rate_prior_7d: number;
+  top_failure_kind: string | null;
+}> {
+  const [current, prior, failures] = await Promise.all([
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+             SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed
+      FROM cc_tasks
+      WHERE completed_at > datetime('now', '-7 days')
+    `).first<{ total: number; completed: number; failed: number }>(),
+
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed
+      FROM cc_tasks
+      WHERE completed_at > datetime('now', '-14 days')
+        AND completed_at <= datetime('now', '-7 days')
+    `).first<{ total: number; completed: number }>(),
+
+    db.prepare(`
+      SELECT failure_kind, COUNT(*) as cnt
+      FROM cc_tasks
+      WHERE status = 'failed' AND completed_at > datetime('now', '-7 days')
+        AND failure_kind IS NOT NULL
+      GROUP BY failure_kind
+      ORDER BY cnt DESC
+      LIMIT 1
+    `).first<{ failure_kind: string; cnt: number }>(),
+  ]);
+
+  const curTotal = (current?.completed ?? 0) + (current?.failed ?? 0);
+  const priorTotal = prior?.total ?? 0;
+
+  return {
+    completed_7d: current?.completed ?? 0,
+    failed_7d: current?.failed ?? 0,
+    success_rate_7d: curTotal > 0 ? (current?.completed ?? 0) / curTotal : 1,
+    success_rate_prior_7d: priorTotal > 0 ? (prior?.completed ?? 0) / priorTotal : 1,
+    top_failure_kind: failures?.failure_kind ?? null,
+  };
+}
+
+async function queryScheduledTaskHealth(db: D1Database): Promise<number> {
+  const result = await db.prepare(`
+    SELECT COUNT(*) as total,
+           SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as errors
+    FROM task_runs
+    WHERE created_at > datetime('now', '-24 hours')
+  `).first<{ total: number; errors: number }>();
+
+  const total = result?.total ?? 0;
+  return total > 0 ? (result?.errors ?? 0) / total : 0;
+}
+
+async function queryClassifierMetrics(db: D1Database): Promise<{
+  classify_cast_rate: number;
+  user_correction_rate: number;
+  classify_cast_correction_rate: number;
+}> {
+  const [totals, corrections] = await Promise.all([
+    db.prepare(`
+      SELECT COUNT(*) as total,
+             SUM(CASE WHEN summary LIKE '%[clf:classify-cast]%' THEN 1 ELSE 0 END) as classify_cast,
+             SUM(CASE WHEN intent_class = 'user_correction' THEN 1 ELSE 0 END) as user_corrections
+      FROM episodic_memory
+      WHERE created_at > datetime('now', '-48 hours')
+        AND channel != 'internal'
+    `).first<{ total: number; classify_cast: number; user_corrections: number }>(),
+
+    // Count user_corrections that follow a classify-cast episode in the same thread
+    db.prepare(`
+      SELECT COUNT(DISTINCT e2.id) as cc_corrections
+      FROM episodic_memory e2
+      INNER JOIN episodic_memory e1
+        ON e1.thread_id = e2.thread_id
+        AND e1.created_at < e2.created_at
+      WHERE e2.intent_class = 'user_correction'
+        AND e1.summary LIKE '%[clf:classify-cast]%'
+        AND e2.created_at > datetime('now', '-48 hours')
+    `).first<{ cc_corrections: number }>(),
+  ]);
+
+  const total = totals?.total ?? 0;
+  const ccTotal = totals?.classify_cast ?? 0;
+
+  return {
+    classify_cast_rate: total > 0 ? ccTotal / total : 0,
+    user_correction_rate: total > 0 ? (totals?.user_corrections ?? 0) / total : 0,
+    classify_cast_correction_rate: ccTotal > 0 ? (corrections?.cc_corrections ?? 0) / ccTotal : 0,
+  };
+}
+
+async function queryMemoryCount(db: D1Database): Promise<number> {
+  const result = await db.prepare(
+    "SELECT COUNT(*) as cnt FROM memory_entries WHERE valid_until IS NULL"
+  ).first<{ cnt: number }>();
+  return result?.cnt ?? 0;
+}
+
+// ─── Composite Score ─────────────────────────────────────────
+// Weighted average of key health indicators, 0-100 scale.
+
+function computeScore(snapshot: Omit<CognitiveSnapshot, 'cognitive_score' | 'score_delta' | 'computed_at'>): number {
+  const weights = {
+    dispatch_success: 25,    // most important — is the kernel routing correctly?
+    procedure_convergence: 20, // is learning working?
+    task_success: 20,        // is autonomous work succeeding?
+    cost_efficiency: 15,     // is cost trending down?
+    routing_stability: 10,   // low reclassification = stable routing
+    scheduled_health: 10,    // are cron tasks healthy?
+  };
+
+  const scores = {
+    dispatch_success: snapshot.dispatch_success_rate_7d * 100,
+    procedure_convergence: snapshot.procedure_convergence_rate * 100,
+    task_success: snapshot.task_success_rate_7d * 100,
+    cost_efficiency: snapshot.avg_cost_prior_7d > 0
+      ? Math.min(100, (1 - (snapshot.avg_cost_7d - snapshot.avg_cost_prior_7d) / snapshot.avg_cost_prior_7d) * 50 + 50)
+      : 50, // neutral if no prior data
+    routing_stability: (1 - snapshot.reclassification_rate_7d) * 100,
+    scheduled_health: (1 - snapshot.scheduled_task_error_rate_24h) * 100,
+  };
+
+  let weighted = 0;
+  let totalWeight = 0;
+  for (const [key, weight] of Object.entries(weights)) {
+    weighted += (scores[key as keyof typeof scores] ?? 50) * weight;
+    totalWeight += weight;
+  }
+
+  return Math.round(Math.max(0, Math.min(100, weighted / totalWeight)));
+}
+
+// ─── Storage ─────────────────────────────────────────────────
+
+// Store snapshots in digest_sections for the Co-Founder Brief
+async function storeSnapshot(db: D1Database, snapshot: CognitiveSnapshot): Promise<void> {
+  const payload = JSON.stringify({
+    type: 'cognitive_metrics',
+    ...snapshot,
+  });
+  await db.prepare(
+    "INSERT INTO digest_sections (section, payload) VALUES ('cognitive_metrics', ?)"
+  ).bind(payload).run();
+}
+
+async function getLastScore(db: D1Database): Promise<{ score: number; memory_count: number } | null> {
+  const row = await db.prepare(
+    "SELECT payload FROM digest_sections WHERE section = 'cognitive_metrics' ORDER BY created_at DESC LIMIT 1"
+  ).first<{ payload: string }>();
+
+  if (!row) return null;
+  try {
+    const parsed = JSON.parse(row.payload);
+    return { score: parsed.cognitive_score ?? 50, memory_count: parsed.memory_count ?? 0 };
+  } catch { return null; }
+}
+
+// ─── Main ────────────────────────────────────────────────────
+
+export async function runCognitiveMetrics(env: EdgeEnv): Promise<void> {
+  // Daily gate — run once per day at 11 UTC (before the 12 UTC digest)
+  const hour = new Date().getUTCHours();
+  if (hour !== 11) return;
+
+  // Cooldown: 22 hours
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'cognitive_metrics'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < 22 * 60 * 60 * 1000) return;
+  }
+
+  // Gather all metrics in parallel
+  const [dispatch, procedural, tasks, scheduledHealth, memoryCount, lastSnapshot, classifier] = await Promise.all([
+    queryDispatchMetrics(env.db),
+    queryProceduralMetrics(env.db),
+    queryTaskMetrics(env.db),
+    queryScheduledTaskHealth(env.db),
+    queryMemoryCount(env.db),
+    getLastScore(env.db),
+    queryClassifierMetrics(env.db),
+  ]);
+
+  const partial = {
+    dispatch_success_rate_7d: dispatch.success_rate_7d,
+    dispatch_success_rate_prior_7d: dispatch.success_rate_prior_7d,
+    dispatch_volume_7d: dispatch.volume_7d,
+    avg_cost_7d: dispatch.avg_cost_7d,
+    avg_cost_prior_7d: dispatch.avg_cost_prior_7d,
+    avg_latency_ms_7d: dispatch.avg_latency_7d,
+    avg_latency_ms_prior_7d: dispatch.avg_latency_prior_7d,
+    reclassification_rate_7d: dispatch.reclassification_rate_7d,
+    procedures_learned: procedural.learned,
+    procedures_learning: procedural.learning,
+    procedures_degraded: procedural.degraded,
+    procedures_broken: procedural.broken,
+    procedure_convergence_rate: procedural.convergence_rate,
+    tasks_completed_7d: tasks.completed_7d,
+    tasks_failed_7d: tasks.failed_7d,
+    task_success_rate_7d: tasks.success_rate_7d,
+    task_success_rate_prior_7d: tasks.success_rate_prior_7d,
+    top_failure_kind: tasks.top_failure_kind,
+    scheduled_task_error_rate_24h: scheduledHealth,
+    classify_cast_rate_48h: classifier.classify_cast_rate,
+    user_correction_rate_48h: classifier.user_correction_rate,
+    classify_cast_correction_rate_48h: classifier.classify_cast_correction_rate,
+    memory_count: memoryCount,
+    memory_count_prior: lastSnapshot?.memory_count ?? memoryCount,
+  };
+
+  const score = computeScore(partial);
+  const scoreDelta = score - (lastSnapshot?.score ?? score);
+
+  const snapshot: CognitiveSnapshot = {
+    ...partial,
+    cognitive_score: score,
+    score_delta: scoreDelta,
+    computed_at: new Date().toISOString(),
+  };
+
+  await storeSnapshot(env.db, snapshot);
+
+  await env.db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('cognitive_metrics', datetime('now'))"
+  ).run();
+
+  const arrow = scoreDelta > 0 ? '+' : scoreDelta < 0 ? '' : '=';
+  console.log(`[cognitive-metrics] Score: ${score}/100 (${arrow}${scoreDelta}) | dispatch: ${Math.round(dispatch.success_rate_7d * 100)}% | procedures: ${procedural.learned}/${procedural.learned + procedural.learning} learned | tasks: ${tasks.completed_7d}/${tasks.completed_7d + tasks.failed_7d}`);
+  console.log(`[cognitive-metrics] classifier: classify-cast=${Math.round(classifier.classify_cast_rate * 100)}% | correction_rate=${Math.round(classifier.user_correction_rate * 100)}% | cc_correction_rate=${Math.round(classifier.classify_cast_correction_rate * 100)}%`);
+}