@stackbilt/aegis-core 0.1.0

package/src/kernel/scheduled/dreaming/task-proposals.ts

@@ -0,0 +1,80 @@
+// Phase 1b: Task Proposal Processing — routes dreaming-extracted task
+// proposals into cc_tasks with governance checks.
+
+import { checkTaskGovernanceLimits } from '../governance.js';
+import { AUTO_SAFE_CATEGORIES, PROPOSED_CATEGORIES } from '../../../schema-enums.js';
+
+const VALID_CATEGORIES = new Set([...AUTO_SAFE_CATEGORIES, ...PROPOSED_CATEGORIES]);
+
+// Valid repos the taskrunner can resolve — must match aliases in taskrunner.sh
+// Customize this set for your org's repos
+const VALID_TASK_REPOS = new Set([
+  'aegis',
+  // Add your repo directory names here
+]);
+
+const MIN_PROMPT_LENGTH = 80;
+
+export async function processTaskProposals(
+  db: D1Database,
+  proposedTasks?: Array<{ title: string; repo: string; prompt: string; category: string; rationale: string }>,
+): Promise<number> {
+  if (!proposedTasks || proposedTasks.length === 0) return 0;
+
+  let tasksCreated = 0;
+  for (const task of proposedTasks.slice(0, 3)) {
+    if (!task.title || !task.repo || !task.prompt || !task.category) {
+      console.warn(`[dreaming:tasks] Skipping task with missing fields: ${task.title ?? '(no title)'}`);
+      continue;
+    }
+
+    const repoNormalized = task.repo.trim().toLowerCase();
+    if (!VALID_TASK_REPOS.has(repoNormalized)) {
+      console.warn(`[dreaming:tasks] Skipping task with unknown repo '${task.repo}': ${task.title}`);
+      continue;
+    }
+
+    if (task.prompt.trim().length < MIN_PROMPT_LENGTH) {
+      console.warn(`[dreaming:tasks] Skipping task with prompt too short (${task.prompt.length} chars): ${task.title}`);
+      continue;
+    }
+
+    const category = task.category.toLowerCase().trim();
+
+    if (category === 'deploy') {
+      console.log(`[dreaming:tasks] Skipping deploy task: ${task.title}`);
+      continue;
+    }
+
+    if (!VALID_CATEGORIES.has(category as any)) {
+      console.warn(`[dreaming:tasks] Skipping task with invalid category '${category}': ${task.title}`);
+      continue;
+    }
+
+    const authority = 'auto_safe';
+
+    const governance = await checkTaskGovernanceLimits(db, { repo: task.repo.trim(), title: task.title.trim(), category: category as string });
+    if (!governance.allowed) {
+      console.log(`[dreaming:tasks] Governance blocked '${task.title}': ${governance.reason}`);
+      continue;
+    }
+
+    const id = crypto.randomUUID();
+    try {
+      await db.prepare(`
+        INSERT INTO cc_tasks (id, title, repo, prompt, completion_signal, status, priority, max_turns, created_by, authority, category)
+        VALUES (?, ?, ?, ?, 'TASK_COMPLETE', 'pending', 50, 25, 'aegis', ?, ?)
+      `).bind(id, task.title.trim(), task.repo.trim(), task.prompt.trim(), authority, category).run();
+
+      tasksCreated++;
+      console.log(`[dreaming:tasks] Created ${authority} task: ${task.title} (${category}, ${task.repo}) → ${id}`);
+    } catch (err) {
+      console.warn(`[dreaming:tasks] Failed to insert task '${task.title}':`, err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  if (tasksCreated > 0) {
+    console.log(`[dreaming:tasks] Proposed ${tasksCreated} task(s) from dreaming cycle`);
+  }
+  return tasksCreated;
+}

package/src/kernel/scheduled/dreaming.ts

@@ -0,0 +1,66 @@
+// Dreaming Cycle — nightly reflection over conversation threads.
+// Thin orchestrator that sequences 5 independent phase modules.
+//
+// Phase 1: Fact extraction (conversation analysis → memory)
+// Phase 1b: Task proposals (extracted tasks → cc_tasks queue)
+// Phase 2: Agenda triage (promote work items → GitHub issues)
+// Phase 3: Persona extraction (behavioral patterns → memory)
+// Phase 4: Pattern synthesis / PRISM (cross-topic connections → meta_insight)
+// Phase 5: Symbolic reflection (TarotScript SingleDraw → memory)
+
+import type { EdgeEnv } from '../dispatch.js';
+import { fetchConversationThreads, extractFacts, processFacts } from './dreaming/facts.js';
+import { processTaskProposals } from './dreaming/task-proposals.js';
+import { triageAgendaToIssues } from './dreaming/agenda-triage.js';
+import { extractPersonaDimensions } from './dreaming/persona.js';
+import { runPatternSynthesis } from './dreaming/pattern-synthesis.js';
+import { runSymbolicReflection } from './dreaming/symbolic.js';
+import { createDynamicTool, listDynamicTools, invalidateToolCache } from '../dynamic-tools.js';
+
+export async function runDreamingCycle(env: EdgeEnv): Promise<void> {
+  // Guard: only run once per day
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'last_dreaming_at'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const hoursSince = (Date.now() - new Date(lastRun.received_at + 'Z').getTime()) / (1000 * 60 * 60);
+    if (hoursSince < 20) return;
+  }
+
+  // Load conversation threads + CC sessions from past 24h
+  const threadContents = await fetchConversationThreads(env);
+
+  if (threadContents.length === 0) {
+    await advanceWatermark(env.db);
+    return;
+  }
+
+  // Phase 1: Fact extraction (blocking — phases 1b, 2 depend on result)
+  const result = await extractFacts(env, threadContents);
+  if (!result) {
+    await advanceWatermark(env.db);
+    return;
+  }
+
+  await processFacts(env, result);
+
+  // Phase 1b + 2: Sequential (depend on extraction result)
+  await processTaskProposals(env.db, result.proposed_tasks);
+  await triageAgendaToIssues(env);
+
+  // Phase 3 + 4 + 5: Independent — run in parallel
+  await Promise.all([
+    extractPersonaDimensions(env, threadContents),
+    runPatternSynthesis(env),
+    runSymbolicReflection(env),
+  ]);
+
+  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 ('last_dreaming_at', datetime('now'))"
+  ).run();
+}

package/src/kernel/scheduled/entropy.ts

@@ -0,0 +1,149 @@
+// Entropy Detection — ghost tasks, stale agenda, dormant goals
+// Inspired by command_desk. Runs in heartbeat phase (hourly).
+// Writes findings to digest_sections for the morning co-founder brief.
+
+import { type EdgeEnv } from '../dispatch.js';
+
+const AGENDA_STALE_DAYS = 7;    // Active agenda items untouched >7d
+const TASK_STALE_DAYS = 7;      // Pending cc_tasks untouched >7d
+const GOAL_DORMANT_DAYS = 14;   // Active goals with no runs in >14d
+
+export interface EntropyReport {
+  score: number;                 // 0-100 — percentage of active items that are stale
+  ghostAgendaItems: Array<{ id: number; item: string; daysSinceCreated: number }>;
+  ghostTasks: Array<{ id: string; title: string; repo: string; daysSinceCreated: number }>;
+  dormantGoals: Array<{ id: string; title: string; daysSinceLastRun: number }>;
+  summary: string;
+}
+
+export async function runEntropyDetection(env: EdgeEnv): Promise<void> {
+  // Time gate: run every 6 hours (00, 06, 12, 18 UTC)
+  const hour = new Date().getUTCHours();
+  if (hour % 6 !== 0) return;
+
+  const report = await detectEntropy(env);
+
+  // Only write to digest if there's something worth reporting
+  if (report.ghostAgendaItems.length === 0 && report.ghostTasks.length === 0 && report.dormantGoals.length === 0) {
+    console.log(`[entropy] Clean — score ${report.score}, no stale items`);
+    return;
+  }
+
+  // Queue as service alert so the digest picks it up without template changes.
+  // severity scales with score: >50% = high, >25% = medium, else low
+  const severity = report.score > 50 ? 'high' : report.score > 25 ? 'medium' : 'low';
+
+  const details: string[] = [];
+  for (const a of report.ghostAgendaItems.slice(0, 5)) {
+    details.push(`agenda #${a.id}: "${a.item}" (${a.daysSinceCreated}d)`);
+  }
+  for (const t of report.ghostTasks.slice(0, 5)) {
+    details.push(`task ${t.id.slice(0, 8)}: "${t.title}" in ${t.repo} (${t.daysSinceCreated}d)`);
+  }
+  for (const g of report.dormantGoals.slice(0, 5)) {
+    details.push(`goal "${g.title}" (${g.daysSinceLastRun}d since last run)`);
+  }
+
+  await env.db.prepare(`
+    INSERT INTO digest_sections (id, section, payload, consumed, created_at)
+    VALUES (?, 'entropy', ?, 0, datetime('now'))
+  `).bind(
+    `entropy-${Date.now()}`,
+    JSON.stringify({
+      source: 'entropy',
+      severity,
+      summary: report.summary,
+      detail: details.join(' · '),
+      findings: details,
+      score: report.score,
+    }),
+  ).run();
+
+  console.log(`[entropy] Score ${report.score} — ${report.ghostAgendaItems.length} ghost agenda, ${report.ghostTasks.length} ghost tasks, ${report.dormantGoals.length} dormant goals`);
+}
+
+export async function detectEntropy(env: EdgeEnv): Promise<EntropyReport> {
+  const now = Date.now();
+
+  // 1. Ghost agenda items — active but created >7d ago with no resolution
+  const agendaRows = await env.db.prepare(`
+    SELECT id, item, created_at
+    FROM agent_agenda
+    WHERE status = 'active'
+      AND created_at < datetime('now', '-${AGENDA_STALE_DAYS} days')
+    ORDER BY created_at ASC
+  `).all<{ id: number; item: string; created_at: string }>();
+
+  const ghostAgendaItems = agendaRows.results.map(r => ({
+    id: r.id,
+    item: r.item.slice(0, 100),
+    daysSinceCreated: Math.floor((now - new Date(r.created_at + 'Z').getTime()) / (1000 * 60 * 60 * 24)),
+  }));
+
+  // 2. Ghost cc_tasks — pending but created >7d ago, never started
+  const taskRows = await env.db.prepare(`
+    SELECT id, title, repo, created_at
+    FROM cc_tasks
+    WHERE status = 'pending'
+      AND created_at < datetime('now', '-${TASK_STALE_DAYS} days')
+    ORDER BY created_at ASC
+  `).all<{ id: string; title: string; repo: string; created_at: string }>();
+
+  const ghostTasks = taskRows.results.map(r => ({
+    id: r.id,
+    title: r.title.slice(0, 100),
+    repo: r.repo,
+    daysSinceCreated: Math.floor((now - new Date(r.created_at + 'Z').getTime()) / (1000 * 60 * 60 * 24)),
+  }));
+
+  // 3. Dormant goals — active but no run in >14d
+  const goalRows = await env.db.prepare(`
+    SELECT id, title, last_run_at
+    FROM agent_goals
+    WHERE status = 'active'
+      AND (last_run_at IS NULL OR last_run_at < datetime('now', '-${GOAL_DORMANT_DAYS} days'))
+  `).all<{ id: string; title: string; last_run_at: string | null }>();
+
+  const dormantGoals = goalRows.results.map(r => ({
+    id: r.id,
+    title: r.title.slice(0, 100),
+    daysSinceLastRun: r.last_run_at
+      ? Math.floor((now - new Date(r.last_run_at + 'Z').getTime()) / (1000 * 60 * 60 * 24))
+      : 999,
+  }));
+
+  // 4. Entropy score — percentage of active items that are stale
+  const totalActiveAgenda = await env.db.prepare(
+    "SELECT COUNT(*) as cnt FROM agent_agenda WHERE status = 'active'"
+  ).first<{ cnt: number }>();
+
+  const totalPendingTasks = await env.db.prepare(
+    "SELECT COUNT(*) as cnt FROM cc_tasks WHERE status = 'pending'"
+  ).first<{ cnt: number }>();
+
+  const totalActiveGoals = await env.db.prepare(
+    "SELECT COUNT(*) as cnt FROM agent_goals WHERE status = 'active'"
+  ).first<{ cnt: number }>();
+
+  const totalActive = (totalActiveAgenda?.cnt ?? 0) + (totalPendingTasks?.cnt ?? 0) + (totalActiveGoals?.cnt ?? 0);
+  const totalStale = ghostAgendaItems.length + ghostTasks.length + dormantGoals.length;
+  const score = totalActive > 0 ? Math.round((totalStale / totalActive) * 100) : 0;
+
+  // 5. Build human summary
+  const parts: string[] = [];
+  if (ghostAgendaItems.length > 0) {
+    parts.push(`${ghostAgendaItems.length} agenda item${ghostAgendaItems.length > 1 ? 's' : ''} stale >${AGENDA_STALE_DAYS}d`);
+  }
+  if (ghostTasks.length > 0) {
+    parts.push(`${ghostTasks.length} queued task${ghostTasks.length > 1 ? 's' : ''} untouched >${TASK_STALE_DAYS}d`);
+  }
+  if (dormantGoals.length > 0) {
+    parts.push(`${dormantGoals.length} goal${dormantGoals.length > 1 ? 's' : ''} dormant >${GOAL_DORMANT_DAYS}d`);
+  }
+
+  const summary = parts.length > 0
+    ? `Entropy ${score}% — ${parts.join(', ')}.`
+    : `Entropy ${score}% — all clear.`;
+
+  return { score, ghostAgendaItems, ghostTasks, dormantGoals, summary };
+}

package/src/kernel/scheduled/escalation.ts

@@ -0,0 +1,192 @@
+import { type EdgeEnv } from '../dispatch.js';
+import { getActiveAgendaItems, PROPOSED_ACTION_PREFIX } from '../memory/index.js';
+import { listIssues } from '../../github.js';
+
+// ─── Stale Proposed Action Expiry ─────────────────────────────
+// Proposed actions from self-improvement, dreaming, and goal loops
+// lose context relevance quickly. Auto-dismiss after 7 days if
+// the operator hasn't approved or rejected them.
+const PROPOSAL_EXPIRY_DAYS = 7;
+
+// ─── Stale GitHub Issue Ref Cleanup (#81) ─────────────────────
+
+export const ISSUE_REF_PATTERN = /#(\d+)/g;
+
+const MAX_REPOS = 5; // Cap repo-specific API calls to stay within subrequest budget
+
+export async function resolveStaleIssueRefs(
+  db: D1Database,
+  items: Array<{ id: number; item: string; context: string | null }>,
+  githubToken: string,
+  githubRepo: string,
+): Promise<void> {
+  // Extract unique issue numbers referenced in agenda items
+  const issueRefs = new Map<number, number[]>(); // issueNumber → agendaItemIds
+  for (const item of items) {
+    const matches = item.item.matchAll(ISSUE_REF_PATTERN);
+    for (const match of matches) {
+      const issueNum = parseInt(match[1], 10);
+      if (issueNum > 0 && issueNum < 10000) {
+        const ids = issueRefs.get(issueNum) ?? [];
+        ids.push(item.id);
+        issueRefs.set(issueNum, ids);
+      }
+    }
+  }
+
+  if (issueRefs.size === 0) return;
+
+  // Build repo → issueNumbers mapping from cc_tasks linkages
+  // issueNumber → repo (specific repo from cc_tasks, or default)
+  const issueToRepo = new Map<number, string>();
+  try {
+    const issueNumbers = [...issueRefs.keys()];
+    // D1 doesn't support WHERE IN with bind params for dynamic lists, batch in chunks
+    const placeholders = issueNumbers.map(() => '?').join(',');
+    const linked = await db.prepare(
+      `SELECT DISTINCT github_issue_number, github_issue_repo FROM cc_tasks
+       WHERE github_issue_repo IS NOT NULL
+       AND github_issue_number IN (${placeholders})`
+    ).bind(...issueNumbers).all<{ github_issue_number: number; github_issue_repo: string }>();
+
+    for (const row of linked.results ?? []) {
+      issueToRepo.set(row.github_issue_number, row.github_issue_repo);
+    }
+  } catch (err) {
+    // Non-fatal — fall back to default repo for all
+    console.warn(`[escalation] cc_tasks linkage query failed:`, err instanceof Error ? err.message : String(err));
+  }
+
+  // Group issues by repo (linked repo or default)
+  const repoToIssues = new Map<string, number[]>();
+  for (const issueNum of issueRefs.keys()) {
+    const repo = issueToRepo.get(issueNum) ?? githubRepo;
+    const nums = repoToIssues.get(repo) ?? [];
+    nums.push(issueNum);
+    repoToIssues.set(repo, nums);
+  }
+
+  // Fetch open issues per distinct repo (capped to MAX_REPOS)
+  try {
+    const repos = [...repoToIssues.keys()].slice(0, MAX_REPOS);
+    const openByRepo = new Map<string, Set<number>>();
+
+    // Fetch all repos in parallel
+    const results = await Promise.allSettled(
+      repos.map(async (repo) => {
+        const openIssues = await listIssues(githubToken, repo, 'open');
+        return { repo, numbers: new Set(openIssues.map(i => i.number)) };
+      })
+    );
+
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        openByRepo.set(result.value.repo, result.value.numbers);
+      } else {
+        console.warn(`[escalation] Failed to fetch issues for a repo:`, result.reason instanceof Error ? result.reason.message : String(result.reason));
+      }
+    }
+
+    let resolved = 0;
+    for (const [issueNum, agendaIds] of issueRefs) {
+      const repo = issueToRepo.get(issueNum) ?? githubRepo;
+      const openNumbers = openByRepo.get(repo);
+      // Skip if we couldn't fetch this repo's issues
+      if (!openNumbers) continue;
+
+      if (!openNumbers.has(issueNum)) {
+        // Issue is closed — auto-resolve the agenda items
+        for (const agendaId of agendaIds) {
+          await db.prepare(
+            "UPDATE agent_agenda SET status = 'done', resolved_at = datetime('now'), context = COALESCE(context, '') || ? WHERE id = ? AND status = 'active'"
+          ).bind(` [auto-resolved: GitHub ${repo}#${issueNum} is closed]`, agendaId).run();
+          resolved++;
+        }
+      }
+    }
+
+    if (resolved > 0) {
+      console.log(`[escalation] Auto-resolved ${resolved} agenda item(s) referencing closed GitHub issues across ${openByRepo.size} repo(s)`);
+    }
+  } catch (err) {
+    // Non-fatal — don't block escalation if GitHub is unreachable
+    console.warn(`[escalation] Stale issue ref check failed:`, err instanceof Error ? err.message : String(err));
+  }
+}
+
+// ─── Stale Agenda Escalation (#61) ────────────────────────────
+
+export const ESCALATION_THRESHOLDS: Record<string, { days: number; newPriority: string }> = {
+  low: { days: 7, newPriority: 'medium' },
+  medium: { days: 3, newPriority: 'high' },
+};
+export const STALE_HIGH_ALERT_DAYS = 1;
+
+export type StaleHighItem = { id: number; item: string; context: string | null; ageDays: number };
+
+/**
+ * Run agenda escalation: bump stale priorities and return stale high-priority items.
+ * Does NOT send its own email — stale items are returned to the caller (heartbeat)
+ * which folds them into a single consolidated health report.
+ */
+export async function runAgendaEscalation(env: EdgeEnv): Promise<StaleHighItem[]> {
+  const items = await getActiveAgendaItems(env.db);
+  if (items.length === 0) return [];
+
+  // Auto-resolve agenda items that reference closed GitHub issues (#81)
+  if (env.githubToken && env.githubRepo) {
+    await resolveStaleIssueRefs(env.db, items, env.githubToken, env.githubRepo);
+  }
+
+  // Auto-dismiss stale proposed actions (>7 days without operator review)
+  const now = Date.now();
+  let expired = 0;
+  for (const item of items) {
+    if (!item.item.startsWith(PROPOSED_ACTION_PREFIX)) continue;
+    const ts = item.created_at.endsWith('Z') ? item.created_at : item.created_at + 'Z';
+    const ageDays = (now - new Date(ts).getTime()) / 86_400_000;
+    if (ageDays > PROPOSAL_EXPIRY_DAYS) {
+      await env.db.prepare(
+        "UPDATE agent_agenda SET status = 'dismissed', resolved_at = datetime('now'), context = COALESCE(context, '') || ? WHERE id = ? AND status = 'active'"
+      ).bind(` [auto-expired: ${Math.floor(ageDays)}d without review]`, item.id).run();
+      expired++;
+    }
+  }
+  if (expired > 0) {
+    console.log(`[escalation] Auto-expired ${expired} stale proposed action(s) (>${PROPOSAL_EXPIRY_DAYS}d)`);
+  }
+
+  // Re-fetch after expiry so escalation loop doesn't process expired items
+  const activeItems = items.filter(i => {
+    if (!i.item.startsWith(PROPOSED_ACTION_PREFIX)) return true;
+    const ts = i.created_at.endsWith('Z') ? i.created_at : i.created_at + 'Z';
+    return (now - new Date(ts).getTime()) / 86_400_000 <= PROPOSAL_EXPIRY_DAYS;
+  });
+
+  let escalated = 0;
+  const staleHighItems: StaleHighItem[] = [];
+
+  for (const item of activeItems) {
+    const ts = item.created_at.endsWith('Z') ? item.created_at : item.created_at + 'Z';
+    const ageDays = (now - new Date(ts).getTime()) / 86_400_000;
+    const threshold = ESCALATION_THRESHOLDS[item.priority];
+
+    if (threshold && ageDays > threshold.days) {
+      const date = new Date().toISOString().slice(0, 10);
+      const annotation = ` [escalated: ${item.priority}\u2192${threshold.newPriority} ${date}]`;
+      await env.db.prepare(
+        "UPDATE agent_agenda SET priority = ?, context = COALESCE(context, '') || ? WHERE id = ?"
+      ).bind(threshold.newPriority, annotation, item.id).run();
+      console.log(`[escalation] Agenda #${item.id} escalated: ${item.priority} \u2192 ${threshold.newPriority} (${ageDays.toFixed(1)}d stale)`);
+      escalated++;
+    } else if (item.priority === 'high' && ageDays > STALE_HIGH_ALERT_DAYS) {
+      staleHighItems.push({ id: item.id, item: item.item, context: item.context, ageDays });
+    }
+  }
+
+  if (escalated > 0) {
+    console.log(`[escalation] ${escalated} agenda item(s) escalated this cycle`);
+  }
+
+  return staleHighItems;
+}

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

@@ -0,0 +1,206 @@
+import { type EdgeEnv } from '../dispatch.js';
+import { recordMemory } from '../memory-adapter.js';
+
+// --- Feed Watcher ---
+// Polls RSS/Atom feeds every 6 hours, stores new entries in D1,
+// and records summaries to semantic memory for the dreaming cycle.
+//
+// Feeds are stored in `watched_feeds` table. New entries land in
+// `feed_entries` and get recorded to memory under topic 'feed_intel'.
+
+const FEED_POLL_HOURS = 6;
+const MAX_NEW_ENTRIES_PER_FEED = 5;
+const MAX_MEMORY_RECORDS_PER_RUN = 10;
+
+interface FeedRow {
+  id: string;
+  url: string;
+  title: string | null;
+  category: string;
+  last_entry_id: string | null;
+}
+
+interface ParsedEntry {
+  id: string;
+  title: string;
+  link: string;
+  summary: string;
+  published: string | null;
+}
+
+// --- Lightweight RSS/Atom parser (no dependencies) ---
+
+function extractTag(xml: string, tag: string): string {
+  // Match <tag>...</tag> or <tag ...>...</tag>
+  const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i');
+  const m = xml.match(re);
+  return m ? m[1].trim().replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1') : '';
+}
+
+function extractAttr(xml: string, tag: string, attr: string): string {
+  const re = new RegExp(`<${tag}[^>]*\\s${attr}=["']([^"']+)["']`, 'i');
+  const m = xml.match(re);
+  return m ? m[1] : '';
+}
+
+function parseEntries(xml: string): ParsedEntry[] {
+  const entries: ParsedEntry[] = [];
+
+  // Try Atom <entry> first, then RSS <item>
+  const isAtom = xml.includes('<feed') || xml.includes('<entry');
+  const tagName = isAtom ? 'entry' : 'item';
+  const re = new RegExp(`<${tagName}[^>]*>[\\s\\S]*?<\\/${tagName}>`, 'gi');
+  const items = xml.match(re) || [];
+
+  for (const item of items.slice(0, MAX_NEW_ENTRIES_PER_FEED * 2)) {
+    const title = extractTag(item, 'title');
+    if (!title) continue;
+
+    let link = '';
+    if (isAtom) {
+      // Atom: <link href="..." rel="alternate" />
+      link = extractAttr(item, 'link', 'href') || extractTag(item, 'link');
+    } else {
+      link = extractTag(item, 'link');
+    }
+
+    const id = isAtom
+      ? extractTag(item, 'id') || link
+      : extractTag(item, 'guid') || link;
+
+    const summary = extractTag(item, 'summary')
+      || extractTag(item, 'description')
+      || extractTag(item, 'content');
+
+    const published = extractTag(item, 'published')
+      || extractTag(item, 'pubDate')
+      || extractTag(item, 'updated')
+      || null;
+
+    if (id) {
+      entries.push({
+        id,
+        title,
+        link,
+        summary: summary.replace(/<[^>]+>/g, '').slice(0, 500), // strip HTML, cap length
+        published,
+      });
+    }
+  }
+
+  return entries;
+}
+
+// --- Main ---
+
+export async function runFeedWatcher(env: EdgeEnv): Promise<void> {
+  // Time gate: every 6 hours (0, 6, 12, 18 UTC)
+  const hour = new Date().getUTCHours();
+  if (hour % FEED_POLL_HOURS !== 0) return;
+
+  // Cooldown: 5 hours since last run
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'feed_watcher'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < 5 * 60 * 60 * 1000) return;
+  }
+
+  // Fetch enabled feeds
+  const feeds = await env.db.prepare(
+    'SELECT id, url, title, category, last_entry_id FROM watched_feeds WHERE enabled = 1'
+  ).all<FeedRow>();
+
+  if (!feeds.results?.length) {
+    console.log('[feed-watcher] No feeds configured -- skipping');
+    return;
+  }
+
+  let totalNew = 0;
+  let memoryRecords = 0;
+
+  for (const feed of feeds.results) {
+    try {
+      const resp = await fetch(feed.url, {
+        headers: { 'User-Agent': 'AEGIS-FeedWatcher/1.0' },
+        signal: AbortSignal.timeout(10_000),
+      });
+
+      if (!resp.ok) {
+        console.warn(`[feed-watcher] ${feed.url} returned ${resp.status}`);
+        continue;
+      }
+
+      const xml = await resp.text();
+      const entries = parseEntries(xml);
+
+      if (!entries.length) continue;
+
+      // Find new entries (not yet in DB)
+      let newCount = 0;
+      for (const entry of entries) {
+        if (newCount >= MAX_NEW_ENTRIES_PER_FEED) break;
+
+        // Skip if already ingested
+        const existing = await env.db.prepare(
+          'SELECT 1 FROM feed_entries WHERE feed_id = ? AND entry_id = ?'
+        ).bind(feed.id, entry.id).first();
+
+        if (existing) continue;
+
+        // Insert new entry
+        await env.db.prepare(
+          `INSERT INTO feed_entries (feed_id, entry_id, title, link, summary, published_at)
+           VALUES (?, ?, ?, ?, ?, ?)`
+        ).bind(feed.id, entry.id, entry.title, entry.link, entry.summary, entry.published).run();
+
+        newCount++;
+        totalNew++;
+
+        // Record to memory if binding available
+        if (env.memoryBinding && memoryRecords < MAX_MEMORY_RECORDS_PER_RUN) {
+          try {
+            const fact = `[${feed.category}] ${feed.title || 'Feed'}: "${entry.title}"${entry.summary ? ` -- ${entry.summary.slice(0, 200)}` : ''}${entry.link ? ` (${entry.link})` : ''}`;
+            await recordMemory(
+              env.memoryBinding,
+              'feed_intel',
+              fact,
+              0.75,
+              'feed_watcher',
+            );
+            await env.db.prepare(
+              'UPDATE feed_entries SET recorded_to_memory = 1 WHERE feed_id = ? AND entry_id = ?'
+            ).bind(feed.id, entry.id).run();
+            memoryRecords++;
+          } catch (err) {
+            console.warn('[feed-watcher] Memory record failed:', err instanceof Error ? err.message : String(err));
+          }
+        }
+      }
+
+      // Update watermark
+      if (entries.length > 0) {
+        await env.db.prepare(
+          "UPDATE watched_feeds SET last_fetched_at = datetime('now'), last_entry_id = ? WHERE id = ?"
+        ).bind(entries[0].id, feed.id).run();
+      }
+
+      if (newCount > 0) {
+        console.log(`[feed-watcher] ${feed.title || feed.url}: ${newCount} new entries`);
+      }
+    } catch (err) {
+      console.warn(`[feed-watcher] Error fetching ${feed.url}:`, err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  // Update watermark
+  await env.db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('feed_watcher', datetime('now'))"
+  ).run();
+
+  if (totalNew > 0) {
+    console.log(`[feed-watcher] Done: ${totalNew} new entries, ${memoryRecords} recorded to memory`);
+  }
+}