@stackbilt/aegis-core 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbilt/aegis-core",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Persistent AI agent framework for Cloudflare Workers. Multi-tier memory, autonomous goals, dreaming cycles, MCP native.",
   "license": "Apache-2.0",
   "publishConfig": {

package/src/groq.ts

@@ -30,11 +30,16 @@ export async function askGroq(
   }
 
   const data = await response.json<{
-    choices: { message: { content: string } }[];
+    choices: { message: { content: unknown } }[];
     usage?: { total_tokens: number };
   }>();
 
-  return data.choices[0]?.message?.content ?? '';
+  const content = data.choices[0]?.message?.content;
+  if (typeof content === 'string') return content;
+  if (content == null) return '';
+  // Some Groq-routed models (notably gpt-oss tool-calling variants) return content
+  // as an array of content blocks. Coerce so downstream string operations don't crash.
+  return typeof content === 'object' ? JSON.stringify(content) : String(content);
 }
 
 // ─── Logprobs-enabled classification ─────────────────────────

package/src/kernel/dispatch.ts

@@ -54,6 +54,7 @@ export interface EdgeEnv {
   codebeastFetcher?: Fetcher;
   mindspringFetcher?: Fetcher;
   mindspringToken?: string;
+  mindspringIngestToken?: string;
   devtoApiKey?: string;
   gaCredentials?: string;
   blueskyHandle?: string;

package/src/kernel/memory/recall.ts

@@ -43,6 +43,8 @@ interface MindSpringResult {
   title: string;
   text: string;
   score: number;
+  notebook_id?: string;
+  notebook_title?: string;
 }
 
 // ─── RRF (Reciprocal Rank Fusion) ────────────────────────────
@@ -143,8 +145,12 @@ export async function recallForQuery(
         : query;
 
       const msResponse = await env.mindspringFetcher.fetch(
-        `https://mindspring/api/search?q=${encodeURIComponent(msQuery)}&limit=5&threshold=0.4`,
-        { headers: { 'Authorization': `Bearer ${env.mindspringToken}` } },
+        'https://mindspring/api/v2/workspaces/aegis-daemon/search',
+        {
+          method: 'POST',
+          headers: { 'Authorization': `Bearer ${env.mindspringToken}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({ query: msQuery, limit: 5, threshold: 0.4 }),
+        },
       );
 
       if (msResponse.ok) {

package/src/kernel/router.ts

@@ -79,8 +79,14 @@ async function classifyWithWorkersAI(
     ],
     max_tokens: 200,
     temperature: 0.1,
-  }) as { response?: string };
-  return result.response ?? '';
+  }) as { response?: unknown };
+  const raw = result.response;
+  if (typeof raw === 'string') return raw;
+  if (raw == null) return '';
+  // Workers AI sometimes returns structured responses (objects with tool_calls,
+  // arrays of segments, etc.). Coerce to string so downstream .trim()/JSON.parse
+  // callers don't crash on non-string payloads.
+  return typeof raw === 'object' ? JSON.stringify(raw) : String(raw);
 }
 
 

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

@@ -21,7 +21,15 @@ import type { CorrelationResult, IncidentCluster, ArgusDiagnosis } from '../argu
 // ─── Configuration ───────────────────────────────────────────
 
 const RUN_CADENCE_HOURS = 3;
-const COOLDOWN_MS = 12 * 60 * 60 * 1000; // 12h cooldown per pattern alert
+const COOLDOWN_MS = 12 * 60 * 60 * 1000; // 12h default cooldown per pattern alert
+
+// Per-pattern cooldown overrides. Drought patterns are expected to persist in
+// pre-revenue or low-activity states — a longer cooldown prevents daily noise
+// from a condition that isn't going to self-resolve on a 12h cycle.
+const PATTERN_COOLDOWN_MS: Record<string, number> = {
+  drought_stripe: 72 * 60 * 60 * 1000,  // 72h — expected in pre-revenue
+  drought_github: 48 * 60 * 60 * 1000,  // 48h
+};
 
 // Pattern thresholds
 const CI_FAILURE_WINDOW_HOURS = 6;
@@ -179,7 +187,8 @@ async function isOnCooldown(db: D1Database, pattern: string): Promise<boolean> {
   ).bind(key).first<{ received_at: string }>();
 
   if (!last) return false;
-  return (Date.now() - new Date(last.received_at + 'Z').getTime()) < COOLDOWN_MS;
+  const cooldown = PATTERN_COOLDOWN_MS[pattern] ?? COOLDOWN_MS;
+  return (Date.now() - new Date(last.received_at + 'Z').getTime()) < cooldown;
 }
 
 async function recordCooldown(db: D1Database, pattern: string): Promise<void> {

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

@@ -1,11 +1,13 @@
 // 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).
+// processes conversations updated since last run. Uses Groq (free) with
+// Workers AI llama-3.1-8b (free tier) as fallback.
 
 import { type EdgeEnv } from '../dispatch.js';
 import { recordMemory as recordMemoryAdapter } from '../memory-adapter.js';
 import { askGroq } from '../../groq.js';
+import { pushFactsToMindSpring, type FactEntry } from './mindspring-notebook.js';
 
 const WATERMARK_KEY = 'conversation_facts_watermark';
 const MAX_CONVERSATIONS = 5;
@@ -85,16 +87,25 @@ async function askAi(
   system: string,
   user: string,
 ): Promise<string> {
+  // Groq first — free, same 70B quality, no neuron consumption
+  if (env.groqApiKey) {
+    try {
+      return await askGroq(env.groqApiKey, env.groqResponseModel, system, user, env.groqBaseUrl);
+    } catch {
+      // fall through to Workers AI
+    }
+  }
+  // Workers AI fallback — llama-3.1-8b is on the genuine free tier
   if (env.ai) {
     const result = await env.ai.run(
-      '@cf/meta/llama-3.3-70b-instruct-fp8-fast' as Parameters<Ai['run']>[0],
+      '@cf/meta/llama-3.1-8b-instruct' 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);
+  throw new Error('[conv-facts] No LLM provider available (groqApiKey and env.ai both missing)');
 }
 
 export async function runConversationFactExtraction(env: EdgeEnv): Promise<void> {
@@ -128,6 +139,7 @@ export async function runConversationFactExtraction(env: EdgeEnv): Promise<void>
   }
 
   let totalFacts = 0;
+  const allFacts: FactEntry[] = [];
 
   for (const conv of conversations.results) {
     const messages = await env.db.prepare(`
@@ -185,6 +197,7 @@ export async function runConversationFactExtraction(env: EdgeEnv): Promise<void>
           fact.confidence ?? 0.8,
           'conversation_extraction',
         );
+        allFacts.push({ topic: topicLower, fact: fact.fact, confidence: fact.confidence ?? 0.8 });
         totalFacts++;
         console.log(`[conv-facts] Extracted: [${topicLower}] ${fact.fact.slice(0, 80)}`);
       } catch (err) {
@@ -195,6 +208,12 @@ export async function runConversationFactExtraction(env: EdgeEnv): Promise<void>
 
   await advanceWatermark(env.db);
   console.log(`[conv-facts] Processed ${conversations.results.length} conversations, extracted ${totalFacts} facts`);
+
+  // Push to MindSpring topic notebooks (non-blocking, never throws)
+  if (allFacts.length > 0) {
+    const runTag = `conv-facts-${Date.now().toString(36)}`;
+    await pushFactsToMindSpring(allFacts, runTag, env);
+  }
 }
 
 async function advanceWatermark(db: D1Database): Promise<void> {

package/src/kernel/scheduled/curiosity.ts

@@ -8,11 +8,12 @@ import { type HeartbeatCheck } from './heartbeat.js';
 export interface CuriosityCandidate {
   topic: string;
   reason: string;
-  source: 'memory_gap' | 'low_confidence' | 'failure_rate' | 'heartbeat_warn' | 'goal_failure' | 'self_interest';
+  source: 'memory_gap' | 'low_confidence' | 'failure_rate' | 'heartbeat_warn' | 'goal_failure' | 'self_interest' | 'conversation_gap';
 }
 
 export async function gatherCuriosityTopics(env: EdgeEnv): Promise<CuriosityCandidate[]> {
   const candidates: CuriosityCandidate[] = [];
+  const thinTopicSeeds: string[] = [];
 
   // Source 1: Memory gaps — topics with few entries relative to others
   if (env.memoryBinding) {
@@ -20,6 +21,7 @@ export async function gatherCuriosityTopics(env: EdgeEnv): Promise<CuriosityCand
       const stats = await env.memoryBinding.stats('aegis');
       const thinTopics = stats.topics.filter(t => t.count <= 2).slice(0, 5);
       for (const t of thinTopics) {
+        thinTopicSeeds.push(t.topic);
         candidates.push({
           topic: `What more should I know about "${t.topic}"?`,
           reason: `Only ${t.count} memory entries — thin coverage`,
@@ -154,6 +156,38 @@ export async function gatherCuriosityTopics(env: EdgeEnv): Promise<CuriosityCand
     }
   }
 
+  // Source 8: MindSpring conversation gap — topics MW barely knows but that appear in
+  // conversation history signal a consolidation pipeline failure, not just a knowledge gap.
+  const { mindspringFetcher, mindspringToken } = env;
+  if (mindspringFetcher && mindspringToken && thinTopicSeeds.length > 0) {
+    try {
+      const queryResults = await Promise.allSettled(
+        thinTopicSeeds.slice(0, 3).map(async (seed) => {
+          const res = await mindspringFetcher.fetch('https://mindspring/api/v2/workspaces/aegis-daemon/search', {
+            method: 'POST',
+            signal: AbortSignal.timeout(1500),
+            headers: { Authorization: `Bearer ${mindspringToken}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ query: seed, limit: 5, threshold: 0.5 }),
+          });
+          if (!res.ok) return { seed, count: 0 };
+          const data = await res.json<{ results: Array<{ title: string; score: number }> }>();
+          return { seed, count: (data.results ?? []).length };
+        })
+      );
+      for (const r of queryResults) {
+        if (r.status === 'fulfilled' && r.value.count > 0) {
+          candidates.push({
+            topic: `"${r.value.seed}" appears in conversation history but has thin memory coverage`,
+            reason: `${r.value.count} MindSpring matches vs ≤2 memory entries — consolidation gap`,
+            source: 'conversation_gap',
+          });
+        }
+      }
+    } catch (err) {
+      console.warn('[curiosity] MindSpring gap scan failed:', err instanceof Error ? err.message : String(err));
+    }
+  }
+
   return candidates;
 }
 

package/src/kernel/scheduled/dreaming/llm.ts

@@ -1,4 +1,4 @@
-// Shared LLM helper — Workers AI with Groq fallback (zero-cost primary, paid fallback)
+// Shared LLM helper — Groq first (free, 70B quality), Workers AI 70B fallback
 
 import type { EdgeEnv } from '../../dispatch.js';
 import { askGroq } from '../../../groq.js';
@@ -9,18 +9,24 @@ export async function askWorkersAiOrGroq(
   user: string,
   useResponseModel = false,
 ): Promise<string> {
+  const groqModel = useResponseModel ? env.groqResponseModel : env.groqModel;
+  // Groq first — free tier, same 70B quality, eliminates neuron consumption
+  if (env.groqApiKey) {
+    try {
+      return await askGroq(env.groqApiKey, groqModel, system, user, env.groqBaseUrl);
+    } catch {
+      // fall through to Workers AI
+    }
+  }
+  // Workers AI fallback — only fires if Groq is unavailable or throws
   if (env.ai) {
-    const model = useResponseModel
-      ? '@cf/meta/llama-3.3-70b-instruct-fp8-fast'
-      : (env.gptOssModel || '@cf/meta/llama-3.3-70b-instruct-fp8-fast');
     const result = await env.ai.run(
-      model as Parameters<Ai['run']>[0],
+      '@cf/meta/llama-3.3-70b-instruct-fp8-fast' as Parameters<Ai['run']>[0],
       { messages: [{ role: 'system', content: system }, { role: 'user', content: user }] },
     ) as { response?: string; choices?: Array<{ message?: { content?: string } }> };
     return result.choices?.[0]?.message?.content ?? result.response ?? '';
   }
-  const groqModel = useResponseModel ? env.groqResponseModel : env.groqModel;
-  return askGroq(env.groqApiKey, groqModel, system, user, env.groqBaseUrl);
+  throw new Error('[dreaming] No LLM provider available (groqApiKey and env.ai both missing)');
 }
 
 export function parseJsonResponse<T>(raw: string): T | null {

package/src/kernel/scheduled/mindspring-notebook.ts

@@ -0,0 +1,132 @@
+// MindSpring v2 write pipeline — push extracted facts to topic notebooks
+
+import type { EdgeEnv } from '../dispatch.js';
+
+const WORKSPACE_ID = 'aegis-daemon';
+const MS_BASE = 'https://mindspring';
+
+interface MsNotebook { id: string; title: string }
+interface UploadAccepted { uploadId: string; status: string }
+
+export interface FactEntry {
+  topic: string;
+  fact: string;
+  confidence: number;
+}
+
+function msHeaders(token: string, extra?: Record<string, string>): Headers {
+  const h = new Headers(extra);
+  h.set('Authorization', `Bearer ${token}`);
+  return h;
+}
+
+async function findOrCreateNotebook(topic: string, env: EdgeEnv): Promise<string> {
+  const token = env.mindspringIngestToken!;
+  const fetcher = env.mindspringFetcher!;
+
+  const listResp = await fetcher.fetch(
+    `${MS_BASE}/api/v2/workspaces/${WORKSPACE_ID}/notebooks`,
+    { headers: msHeaders(token) },
+  );
+  if (listResp.ok) {
+    const data = await listResp.json<{ notebooks: MsNotebook[] }>();
+    const existing = data.notebooks?.find((nb) => nb.title === topic);
+    if (existing) return existing.id;
+  }
+
+  const createResp = await fetcher.fetch(
+    `${MS_BASE}/api/v2/workspaces/${WORKSPACE_ID}/notebooks`,
+    {
+      method: 'POST',
+      headers: msHeaders(token, { 'Content-Type': 'application/json' }),
+      body: JSON.stringify({ title: topic, type: 'research' }),
+    },
+  );
+  if (!createResp.ok) {
+    const msg = await createResp.text().catch(() => '');
+    throw new Error(`create notebook failed: ${createResp.status} ${msg.slice(0, 120)}`);
+  }
+  const nb = await createResp.json<MsNotebook>();
+  return nb.id;
+}
+
+async function uploadContent(content: string, filename: string, env: EdgeEnv): Promise<string> {
+  const token = env.mindspringIngestToken!;
+  const fetcher = env.mindspringFetcher!;
+
+  const resp = await fetcher.fetch(`${MS_BASE}/api/uploads/simple`, {
+    method: 'POST',
+    headers: msHeaders(token, {
+      'Content-Type': 'text/plain',
+      'X-File-Name': filename,
+    }),
+    body: content,
+  });
+  if (!resp.ok) {
+    const msg = await resp.text().catch(() => '');
+    throw new Error(`upload failed: ${resp.status} ${msg.slice(0, 120)}`);
+  }
+  const { uploadId } = await resp.json<UploadAccepted>();
+  return uploadId;
+}
+
+async function registerSource(notebookId: string, title: string, uploadId: string, env: EdgeEnv): Promise<void> {
+  const token = env.mindspringIngestToken!;
+  const fetcher = env.mindspringFetcher!;
+
+  const resp = await fetcher.fetch(
+    `${MS_BASE}/api/v2/workspaces/${WORKSPACE_ID}/notebooks/${notebookId}/sources`,
+    {
+      method: 'POST',
+      headers: msHeaders(token, { 'Content-Type': 'application/json' }),
+      body: JSON.stringify({ title, type: 'txt', sourceUploadId: uploadId, parserType: 'txt' }),
+    },
+  );
+  if (!resp.ok && resp.status !== 202) {
+    const msg = await resp.text().catch(() => '');
+    throw new Error(`register source failed: ${resp.status} ${msg.slice(0, 120)}`);
+  }
+}
+
+/**
+ * Push extracted facts to MindSpring v2 topic notebooks.
+ * Groups facts by topic, creates notebooks as needed.
+ * Never throws — all errors are logged as warnings.
+ */
+export async function pushFactsToMindSpring(
+  facts: FactEntry[],
+  sourceTag: string,
+  env: EdgeEnv,
+): Promise<void> {
+  if (!env.mindspringFetcher || !env.mindspringIngestToken || facts.length === 0) return;
+
+  // Group by topic
+  const byTopic = new Map<string, string[]>();
+  for (const { topic, fact } of facts) {
+    const arr = byTopic.get(topic) ?? [];
+    arr.push(fact);
+    byTopic.set(topic, arr);
+  }
+
+  const date = new Date().toISOString().slice(0, 10);
+
+  for (const [topic, topicFacts] of byTopic.entries()) {
+    try {
+      const content = [
+        `Topic: ${topic}`,
+        `Source: ${sourceTag}`,
+        `Date: ${date}`,
+        '',
+        ...topicFacts.map((f) => `- ${f}`),
+      ].join('\n');
+
+      const notebookId = await findOrCreateNotebook(topic, env);
+      const uploadId = await uploadContent(content, `${topic}-facts.txt`, env);
+      await registerSource(notebookId, `facts-${date}-${sourceTag.slice(0, 12)}`, uploadId, env);
+
+      console.log(`[mindspring-nb] pushed ${topicFacts.length} fact(s) → notebook '${topic}' (${notebookId.slice(0, 8)})`);
+    } catch (err) {
+      console.warn(`[mindspring-nb] topic '${topic}' push failed:`, err instanceof Error ? err.message : String(err));
+    }
+  }
+}