@stackbilt/aegis-core 0.1.0

package/src/kernel/scheduled/consolidation.ts

@@ -0,0 +1,229 @@
+import { type EdgeEnv } from '../dispatch.js';
+import { consolidateEpisodicToSemantic, maintainProcedures, getAllProcedures, PROCEDURE_MIN_SUCCESSES, PROCEDURE_MIN_SUCCESS_RATE } from '../memory/index.js';
+import { garbageCollectTools, promoteHighUsageTools } from '../dynamic-tools.js';
+import { publishInsight, type InsightType } from '../memory/insights.js';
+import { pruneMemory } from '../memory-adapter.js';
+import { runCrossDomainSynthesis } from '../memory/synthesis.js';
+import { maintainNarratives, detectStaleNarratives, precomputeCognitiveState, pruneNarratives, getCognitiveState, type ProductPortfolioEntry } from '../cognition.js';
+import { updateBlock } from '../memory/blocks.js';
+// topic-discovery is an extension point — consumers can provide their own
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function discoverEmergentTopics(_db: D1Database, _binding: any): Promise<void> { /* no-op in core */ }
+import { McpClient } from '../../mcp-client.js';
+import { operatorConfig } from '../../operator/index.js';
+
+export async function runMemoryConsolidation(env: EdgeEnv): Promise<void> {
+  await consolidateEpisodicToSemantic(env.db, env.groqApiKey, env.groqModel, env.groqBaseUrl, env.memoryBinding);
+  if (env.memoryBinding) {
+    await pruneMemory(env.memoryBinding, env.db);
+  }
+  await maintainProcedures(env.db);
+
+  // Dynamic tools lifecycle: expire TTL'd tools, retire unused, promote high-use
+  try {
+    const gc = await garbageCollectTools(env.db);
+    const promoted = await promoteHighUsageTools(env.db);
+    if (gc.expired > 0 || gc.unused > 0 || promoted > 0) {
+      console.log(`[consolidation] Dynamic tools: ${gc.expired} expired, ${gc.unused} unused retired, ${promoted} promoted`);
+    }
+  } catch {
+    // Non-fatal — table may not exist yet
+  }
+
+  // Emergent topic discovery: find orphaned facts that cluster into new topics
+  if (env.memoryBinding) {
+    await discoverEmergentTopics(env.db, env.memoryBinding);
+  }
+
+  // Cross-domain synthesis: find connections across memory topics
+  await runCrossDomainSynthesis(env);
+
+  // Cognitive layer: narratives + state precomputation
+  await maintainNarratives(env.db, env.groqApiKey, env.groqModel, env.groqBaseUrl);
+  await detectStaleNarratives(env.db);
+  await pruneNarratives(env.db);
+
+  // Fetch product portfolio from BizOps (1 MCP call, hourly cadence)
+  const portfolio = await fetchProductPortfolio(env);
+  await precomputeCognitiveState(env.db, portfolio.length > 0 ? portfolio : undefined, env.memoryBinding, env.mindspringFetcher, env.mindspringToken);
+
+  // Update active_context block from freshly computed CognitiveState
+  await refreshActiveContextBlock(env.db);
+
+  // ─── CRIX Phase 2c: Publish insights from procedural + semantic memory ───
+  await publishInsightsFromMemory(env);
+}
+
+export async function fetchProductPortfolio(env: EdgeEnv): Promise<ProductPortfolioEntry[]> {
+  if (!env.bizopsToken) return [];
+  try {
+    const client = new McpClient({
+      url: operatorConfig.integrations.bizops.fallbackUrl,
+      token: env.bizopsToken,
+      prefix: 'bizops',
+      fetcher: env.bizopsFetcher,
+      rpcPath: '/rpc',
+    });
+    const raw = await client.callTool('list_projects', {});
+    const projects = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    if (!Array.isArray(projects)) return [];
+    return projects.map((p: Record<string, unknown>) => ({
+      name: String(p.name ?? ''),
+      description: String(p.description ?? ''),
+      model: String(p.repo_kind ?? 'unknown'),
+      status: String(p.status ?? p.last_seen_at ? 'active' : 'unknown'),
+      revenue: p.revenue ? String(p.revenue) : undefined,
+    })).filter((p: ProductPortfolioEntry) => p.name);
+  } catch (err) {
+    console.warn('[scheduled] Product portfolio fetch failed:', err instanceof Error ? err.message : String(err));
+    return [];
+  }
+}
+
+// ─── CRIX Phase 2c: Insight Publishing ────────────────────────
+
+const INSIGHT_RATE_LIMIT = 5; // max per consolidation cycle
+const WATCH_REPOS = ['my-agent'] // Add your repos here;
+
+async function publishInsightsFromMemory(env: EdgeEnv): Promise<void> {
+  let published = 0;
+
+  // Source 1: Learned procedures — patterns with ≥70% success rate and 3+ successes
+  try {
+    const procedures = await getAllProcedures(env.db);
+    for (const proc of procedures) {
+      if (published >= INSIGHT_RATE_LIMIT) break;
+      if (proc.status !== 'learned') continue;
+      if (proc.success_count < PROCEDURE_MIN_SUCCESSES) continue;
+
+      const successRate = proc.success_count / (proc.success_count + proc.fail_count);
+      if (successRate < PROCEDURE_MIN_SUCCESS_RATE) continue;
+
+      // Already published check: handled by publishInsight() fact hash gate
+      const fact = `Learned procedure: "${proc.task_pattern}" routes to ${proc.executor} executor with ${(successRate * 100).toFixed(0)}% success rate (${proc.success_count} successes). Config: ${proc.executor_config?.slice(0, 200) ?? 'default'}`;
+
+      const result = await publishInsight(env.db, {
+        fact,
+        insight_type: 'pattern',
+        origin_repo: 'aegis',
+        keywords: [proc.task_pattern, proc.executor, 'routing', 'procedure'],
+        confidence: Math.min(0.95, 0.75 + successRate * 0.2),
+      }, env.memoryBinding);
+
+      if (result.published) {
+        published++;
+        console.log(`[crix] Published procedure insight: ${proc.task_pattern}`);
+      }
+    }
+  } catch (err) {
+    console.warn('[crix] Procedure scan failed:', err instanceof Error ? err.message : String(err));
+  }
+
+  // Source 2: High-confidence memory entries from the last 24h via Memory Worker
+  // Look for entries tagged with bug/perf/arch topics that could be cross-repo insights
+  if (env.memoryBinding) {
+    try {
+      const INSIGHT_TOPICS = new Map<string, InsightType>([
+        ['bug_signature', 'pattern'],
+        ['perf_pattern', 'heuristic'],
+        ['arch_improvement', 'principle'],
+      ]);
+
+      const fragments = await env.memoryBinding.recall('aegis', { limit: 20 });
+      // Filter to high-confidence entries suitable for cross-repo insight publishing
+      const recentHighConf = fragments.filter(f => f.confidence >= 0.85).slice(0, 10);
+
+      for (const entry of recentHighConf) {
+        if (published >= INSIGHT_RATE_LIMIT) break;
+
+        // Infer insight type from topic
+        let insightType: InsightType = 'pattern';
+        for (const [topicFragment, type] of INSIGHT_TOPICS) {
+          if (entry.topic.includes(topicFragment)) {
+            insightType = type;
+            break;
+          }
+        }
+
+        // Extract keywords from the fact text
+        const keywords = entry.content.toLowerCase()
+          .replace(/[^a-z0-9\s]/g, ' ')
+          .split(/\s+/)
+          .filter(w => w.length > 4)
+          .slice(0, 8);
+
+        if (keywords.length < 2) continue; // Not enough signal
+
+        const result = await publishInsight(env.db, {
+          fact: entry.content,
+          insight_type: insightType,
+          origin_repo: 'aegis',
+          keywords,
+          confidence: entry.confidence,
+        }, env.memoryBinding);
+
+        if (result.published) {
+          published++;
+        }
+      }
+    } catch (err) {
+      console.warn('[crix] Semantic scan failed:', err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  if (published > 0) {
+    console.log(`[crix] Published ${published} insights during consolidation cycle`);
+  }
+}
+
+// ─── Active Context Block Refresh ────────────────────────────
+
+async function refreshActiveContextBlock(db: D1Database): Promise<void> {
+  try {
+    const state = await getCognitiveState(db);
+    if (!state) return;
+
+    // Build active_context content from CognitiveState (skip self-model — that's the identity block)
+    const parts: string[] = [];
+
+    if (state.narratives.length > 0) {
+      parts.push('## Active Narratives');
+      for (const n of state.narratives) {
+        const tag = n.status === 'stalled' ? ' [STALLED]' : '';
+        parts.push(`### ${n.title}${tag}`);
+        parts.push(n.summary);
+        if (n.tension) parts.push(`**Tension**: ${n.tension}`);
+        if (n.last_beat) parts.push(`**Latest**: ${n.last_beat}`);
+      }
+    }
+
+    parts.push('\n## Operational Pulse');
+    parts.push(`- Memory: ${state.memory_count} active entries`);
+    parts.push(`- Last 24h: ${state.episode_count_24h} episodes`);
+    parts.push(`- Agenda: ${state.open_threads} open threads, ${state.proposed_actions} pending actions`);
+    if (state.last_heartbeat_severity) {
+      parts.push(`- Last heartbeat: ${state.last_heartbeat_severity}`);
+    }
+
+    if (state.activated_nodes.length > 0) {
+      parts.push('\n## Active Concepts');
+      for (const node of state.activated_nodes) {
+        parts.push(`- ${node.label} (${node.type}, activation: ${node.activation.toFixed(2)})`);
+      }
+    }
+
+    if (state.product_portfolio?.length > 0) {
+      parts.push('\n## Stackbilt Product Portfolio');
+      for (const p of state.product_portfolio) {
+        const rev = p.revenue ? ` | Revenue: ${p.revenue}` : '';
+        parts.push(`- **${p.name}** [${p.status}] — ${p.description}${rev}`);
+      }
+    }
+
+    const content = parts.join('\n');
+    await updateBlock(db, 'active_context', content, 'consolidation');
+    console.log('[blocks] Refreshed active_context block');
+  } catch (err) {
+    console.warn('[blocks] Failed to refresh active_context:', err instanceof Error ? err.message : String(err));
+  }
+}

package/src/kernel/scheduled/content-drip.ts

@@ -0,0 +1,47 @@
+// Content Drip — publishes scheduled posts to Bluesky
+// Runs in the hourly cron. Checks for posts where scheduled_at <= now and status = 'scheduled'.
+
+import { type EdgeEnv } from '../dispatch.js';
+import { postToBluesky } from '../../bluesky.js';
+
+export async function runContentDrip(env: EdgeEnv): Promise<void> {
+  if (!env.blueskyAppPassword) {
+    console.log('[content-drip] No BLUESKY_APP_PASSWORD configured, skipping');
+    return;
+  }
+
+  const due = await env.db.prepare(`
+    SELECT id, content, media_url, link_url, platform
+    FROM content_queue
+    WHERE status = 'scheduled' AND scheduled_at <= datetime('now') AND platform = 'bluesky'
+    ORDER BY scheduled_at ASC
+    LIMIT 5
+  `).all<{ id: string; content: string; media_url: string | null; link_url: string | null; platform: string }>();
+
+  if (due.results.length === 0) return;
+
+  const handle = env.blueskyHandle ?? 'your-handle.bsky.social';
+
+  for (const post of due.results) {
+    try {
+      const result = await postToBluesky(handle, env.blueskyAppPassword, {
+        text: post.content,
+        imageUrl: post.media_url ?? undefined,
+      });
+
+      await env.db.prepare(`
+        UPDATE content_queue SET status = 'published', published_at = datetime('now'), post_url = ?
+        WHERE id = ?
+      `).bind(result.url, post.id).run();
+
+      console.log(`[content-drip] Published: ${result.url}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await env.db.prepare(`
+        UPDATE content_queue SET status = 'failed', error = ?
+        WHERE id = ?
+      `).bind(msg, post.id).run();
+      console.error(`[content-drip] Failed to post ${post.id}: ${msg}`);
+    }
+  }
+}

package/src/kernel/scheduled/content.ts

@@ -0,0 +1,6 @@
+// Stub — full implementation not yet extracted to OSS
+import type { EdgeEnv } from '../dispatch.js';
+
+export async function runRoundtableContentGeneration(_env: EdgeEnv): Promise<void> {}
+export async function runDispatchContentGeneration(_env: EdgeEnv): Promise<void> {}
+export async function runColumnContentGeneration(_env: EdgeEnv): Promise<void> {}

package/src/kernel/scheduled/conversation-facts.ts

@@ -0,0 +1,204 @@
+// Per-conversation fact extraction (#324)
+// Complements the dreaming cycle (daily, batch) with near-real-time
+// fact capture from operator chat sessions. Runs every 2 hours,
+// processes conversations updated since last run. Uses Workers AI (free).
+
+import { type EdgeEnv } from '../dispatch.js';
+import { recordMemory as recordMemoryAdapter } from '../memory-adapter.js';
+import { askGroq } from '../../groq.js';
+
+const WATERMARK_KEY = 'conversation_facts_watermark';
+const MAX_CONVERSATIONS = 5;
+const MAX_MESSAGES_PER_CONV = 20;
+const MAX_FACTS_PER_CONV = 5;
+const RUN_INTERVAL_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+const BLOCKED_TOPIC_PREFIXES = ['synthesis_', 'cross_repo_insight'];
+const ALLOWED_TOPICS = new Set([
+  'aegis',
+  'auth',
+  'bizops',
+  'charter',
+  'codebeast',
+  'compliance',
+  'content',
+  'feed_intel',
+  'finance',
+  'img_forge',
+  'infrastructure',
+  'mcp_strategy',
+  'meta_insight',
+  'operator_persona',
+  'operator_preferences',
+  'organization',
+  'project',
+  'self_improvement',
+  'tarotscript',
+]);
+
+const TOPIC_ALIASES: Record<string, string> = {
+  operator_persona: 'operator_persona',
+  operator_preferences: 'operator_preferences',
+  stackbilt: 'project',
+  stackbilt_auth: 'auth',
+  roundtable: 'content',
+  memory_worker: 'aegis',
+  colonyos: 'project',
+  edgestack: 'project',
+  wip_techhuman: 'project',
+};
+
+const EXTRACTION_SYSTEM = `You extract durable facts from an AI assistant conversation. Focus on:
+- Business decisions, commitments, deadlines
+- Technical architecture changes or constraints
+- User preferences and corrections
+- New information not derivable from code
+
+Return ONLY valid JSON (no markdown fences):
+{
+  "facts": [
+    { "topic": "category", "fact": "specific durable fact", "confidence": 0.8 }
+  ]
+}
+
+Rules:
+- Max 5 facts. Fewer is better if conversation is routine.
+- Return {"facts":[]} if nothing worth remembering.
+- topic must be one of: aegis, auth, bizops, charter, codebeast, compliance, content, feed_intel, finance, img_forge, infrastructure, mcp_strategy, meta_insight, operator_persona, operator_preferences, organization, project, self_improvement, tarotscript
+- Each fact must be a complete sentence with concrete details (names, numbers, dates).
+- Do NOT extract: greetings, tool outputs, code snippets, or ephemeral task state.
+- confidence: 0.9 for explicit statements, 0.7 for inferences.`;
+
+interface ExtractedFact {
+  topic: string;
+  fact: string;
+  confidence: number;
+}
+
+function normalizeTopic(topic: string): string {
+  const normalized = topic.toLowerCase().trim().replace(/\s+/g, '_');
+  return TOPIC_ALIASES[normalized] ?? normalized;
+}
+
+async function askAi(
+  env: EdgeEnv,
+  system: string,
+  user: string,
+): Promise<string> {
+  if (env.ai) {
+    const result = await env.ai.run(
+      '@cf/meta/llama-3.3-70b-instruct-fp8-fast' as Parameters<Ai['run']>[0],
+      { messages: [{ role: 'system', content: system }, { role: 'user', content: user }] },
+    );
+    if (typeof result === 'string') return result;
+    const obj = result as { response?: string; choices?: Array<{ message?: { content?: string } }> };
+    return obj.choices?.[0]?.message?.content ?? obj.response ?? '';
+  }
+  return askGroq(env.groqApiKey, env.groqResponseModel, system, user, env.groqBaseUrl);
+}
+
+export async function runConversationFactExtraction(env: EdgeEnv): Promise<void> {
+  // Time gate: run every 2 hours (uses web_events for watermark, same as other scheduled tasks)
+  const lastRun = await env.db.prepare(
+    'SELECT received_at FROM web_events WHERE event_id = ?',
+  ).bind(WATERMARK_KEY).first<{ received_at: string }>().catch(() => null);
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < RUN_INTERVAL_MS) return;
+  }
+
+  // Find conversations with recent activity (since last run or last 2h)
+  const since = lastRun?.received_at ?? new Date(Date.now() - RUN_INTERVAL_MS).toISOString().replace('Z', '');
+
+  const conversations = await env.db.prepare(`
+    SELECT c.id, c.title, COUNT(m.id) as msg_count
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    WHERE m.created_at > ? AND m.role = 'user'
+    GROUP BY c.id
+    HAVING msg_count >= 2
+    ORDER BY MAX(m.created_at) DESC
+    LIMIT ?
+  `).bind(since, MAX_CONVERSATIONS).all<{ id: string; title: string; msg_count: number }>();
+
+  if (conversations.results.length === 0) {
+    await advanceWatermark(env.db);
+    return;
+  }
+
+  let totalFacts = 0;
+
+  for (const conv of conversations.results) {
+    const messages = await env.db.prepare(`
+      SELECT role, content FROM messages
+      WHERE conversation_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).bind(conv.id, MAX_MESSAGES_PER_CONV).all<{ role: string; content: string }>();
+
+    // Reverse to chronological order (queried DESC for recency limit)
+    const thread = messages.results.reverse();
+    if (thread.length < 2) continue;
+
+    const transcript = thread
+      .map((message) => `${message.role === 'user' ? 'operator' : 'AEGIS'}: ${message.content.slice(0, 1000)}`)
+      .join('\n\n');
+
+    let rawResponse: string;
+    try {
+      rawResponse = await askAi(env, EXTRACTION_SYSTEM, transcript.slice(0, 12000));
+    } catch (err) {
+      console.warn(`[conv-facts] LLM failed for ${conv.id}:`, err instanceof Error ? err.message : String(err));
+      continue;
+    }
+
+    if (!rawResponse) continue;
+
+    const cleaned = rawResponse.replace(/```json\s*/g, '').replace(/```\s*/g, '').trim();
+    let parsed: { facts?: ExtractedFact[] };
+    try {
+      parsed = JSON.parse(cleaned) as { facts?: ExtractedFact[] };
+    } catch {
+      console.warn(`[conv-facts] Failed to parse response for ${conv.id}: ${cleaned.slice(0, 100)}`);
+      continue;
+    }
+
+    if (!parsed.facts || !Array.isArray(parsed.facts)) continue;
+
+    for (const fact of parsed.facts.slice(0, MAX_FACTS_PER_CONV)) {
+      if (!fact.topic || !fact.fact || fact.fact.length < 20) continue;
+
+      const topicLower = normalizeTopic(fact.topic);
+      if (BLOCKED_TOPIC_PREFIXES.some((prefix) => topicLower.startsWith(prefix))) continue;
+      if (!ALLOWED_TOPICS.has(topicLower)) {
+        console.log(`[conv-facts] Blocked unknown topic '${fact.topic}'`);
+        continue;
+      }
+
+      try {
+        if (!env.memoryBinding) continue;
+        await recordMemoryAdapter(
+          env.memoryBinding,
+          topicLower,
+          fact.fact,
+          fact.confidence ?? 0.8,
+          'conversation_extraction',
+        );
+        totalFacts++;
+        console.log(`[conv-facts] Extracted: [${topicLower}] ${fact.fact.slice(0, 80)}`);
+      } catch (err) {
+        console.warn('[conv-facts] Failed to record:', err instanceof Error ? err.message : String(err));
+      }
+    }
+  }
+
+  await advanceWatermark(env.db);
+  console.log(`[conv-facts] Processed ${conversations.results.length} conversations, extracted ${totalFacts} facts`);
+}
+
+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().catch(() => {});
+}

package/src/kernel/scheduled/cost-report.ts

@@ -0,0 +1,84 @@
+import { type EdgeEnv } from '../dispatch.js';
+
+// --- Cost Report ---
+// Weekly cost aggregation by executor tier. Runs at 07 UTC on Mondays.
+// Stores snapshot in digest_sections for inclusion in the daily digest.
+// No LLM calls -- pure D1 queries.
+
+interface ExecutorCost {
+  executor: string;
+  count: number;
+  total_cost: number;
+  avg_cost: number;
+  avg_latency_ms: number;
+}
+
+export async function runCostReport(env: EdgeEnv): Promise<void> {
+  // Gate: Monday at 07 UTC
+  const now = new Date();
+  if (now.getUTCDay() !== 1 || now.getUTCHours() !== 7) return;
+
+  // Cooldown: 6 days
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'cost_report'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < 6 * 24 * 60 * 60 * 1000) return;
+  }
+
+  // Aggregate costs by executor for the past 7 days
+  const byExecutor = await env.db.prepare(`
+    SELECT
+      COALESCE(executor, 'unknown') as executor,
+      COUNT(*) as count,
+      ROUND(SUM(cost), 4) as total_cost,
+      ROUND(AVG(cost), 4) as avg_cost,
+      ROUND(AVG(latency_ms), 0) as avg_latency_ms
+    FROM episodic_memory
+    WHERE created_at > datetime('now', '-7 days')
+    GROUP BY executor
+    ORDER BY total_cost DESC
+  `).all<ExecutorCost>();
+
+  if (!byExecutor.results?.length) return;
+
+  // Total across all executors
+  const totalCost = byExecutor.results.reduce((sum, r) => sum + r.total_cost, 0);
+  const totalDispatches = byExecutor.results.reduce((sum, r) => sum + r.count, 0);
+
+  // Top intent classes by cost
+  const topIntents = await env.db.prepare(`
+    SELECT
+      intent_class,
+      COUNT(*) as count,
+      ROUND(SUM(cost), 4) as total_cost
+    FROM episodic_memory
+    WHERE created_at > datetime('now', '-7 days')
+    GROUP BY intent_class
+    ORDER BY total_cost DESC
+    LIMIT 5
+  `).all<{ intent_class: string; count: number; total_cost: number }>();
+
+  const snapshot = {
+    period: '7d',
+    generated_at: now.toISOString(),
+    total_cost: Math.round(totalCost * 10000) / 10000,
+    total_dispatches: totalDispatches,
+    by_executor: byExecutor.results,
+    top_intents: topIntents.results || [],
+  };
+
+  // Store for digest
+  await env.db.prepare(
+    "INSERT INTO digest_sections (section, payload) VALUES ('cost_report', ?)"
+  ).bind(JSON.stringify(snapshot)).run();
+
+  // Update watermark
+  await env.db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('cost_report', datetime('now'))"
+  ).run();
+
+  console.log(`[cost-report] Weekly: $${totalCost.toFixed(4)} across ${totalDispatches} dispatches, ${byExecutor.results.length} executors`);
+}