kongbrain 0.4.1 → 0.4.3

package/src/supersedes.ts

@@ -0,0 +1,99 @@
+/**
+ * Supersedes — concept evolution tracking.
+ *
+ * When the daemon extracts a correction (user correcting the assistant),
+ * this module finds the concept(s) that contained the stale knowledge
+ * and creates `supersedes` edges from the correction memory to those
+ * concepts, decaying their stability so they lose priority in recall.
+ *
+ * Edge direction: correction_memory -> supersedes -> stale_concept
+ *
+ * This ensures that:
+ * 1. Stale knowledge doesn't win over corrections in retrieval
+ * 2. The graph records *why* a concept was deprecated
+ * 3. Stability decay is proportional to correction confidence
+ */
+
+import type { SurrealStore } from "./surreal.js";
+import type { EmbeddingService } from "./embeddings.js";
+import { swallow } from "./errors.js";
+
+/** Minimum cosine similarity to consider a concept as the target of a correction. */
+const SUPERSEDE_THRESHOLD = 0.70;
+
+/** How much to decay stability of superseded concepts (multiplicative). */
+const STABILITY_DECAY_FACTOR = 0.4;
+
+/** Floor — don't decay below this so the concept remains discoverable. */
+const STABILITY_FLOOR = 0.15;
+
+/**
+ * Find concepts that match the "original" (wrong) statement in a correction,
+ * create supersedes edges, and decay their stability.
+ *
+ * @param correctionMemId - The memory:xxx record ID of the correction
+ * @param originalText    - The "original" (incorrect) text from the correction
+ * @param correctionText  - The "corrected" (right) text from the correction
+ * @param store           - SurrealDB store
+ * @param embeddings      - Embedding service
+ * @param precomputedVec  - Optional pre-computed embedding of the full correction text
+ */
+export async function linkSupersedesEdges(
+  correctionMemId: string,
+  originalText: string,
+  correctionText: string,
+  store: SurrealStore,
+  embeddings: EmbeddingService,
+  precomputedVec?: number[] | null,
+): Promise<number> {
+  if (!embeddings.isAvailable() || !originalText) return 0;
+
+  let supersededCount = 0;
+
+  try {
+    // Embed the *original* (wrong) text — that's what we're looking for in the graph
+    const originalVec = await embeddings.embed(originalText);
+    if (!originalVec?.length) return 0;
+
+    // Find concepts whose content is semantically similar to the wrong statement
+    // Pre-filter: skip already-superseded or floored concepts to avoid redundant work
+    const candidates = await store.queryFirst<{ id: string; score: number; stability: number }>(
+      `SELECT id, vector::similarity::cosine(embedding, $vec) AS score, stability
+       FROM concept
+       WHERE embedding != NONE AND array::len(embedding) > 0
+         AND superseded_at IS NONE
+         AND stability > $floor
+       ORDER BY score DESC
+       LIMIT 5`,
+      { vec: originalVec, floor: STABILITY_FLOOR },
+    );
+
+    for (const candidate of candidates) {
+      if (candidate.score < SUPERSEDE_THRESHOLD) break;
+
+      const conceptId = String(candidate.id);
+
+      // Create supersedes edge: correction -> supersedes -> stale concept
+      await store.relate(correctionMemId, "supersedes", conceptId)
+        .catch(e => swallow("supersedes:relate", e));
+
+      // Decay stability of the stale concept
+      const currentStability = candidate.stability ?? 1.0;
+      const newStability = Math.max(
+        STABILITY_FLOOR,
+        currentStability * STABILITY_DECAY_FACTOR,
+      );
+
+      await store.queryExec(
+        `UPDATE $conceptId SET stability = $newStability, superseded_at = time::now(), superseded_by = $correctionId`,
+        { conceptId, newStability, correctionId: correctionMemId },
+      ).catch(e => swallow("supersedes:decay", e));
+
+      supersededCount++;
+    }
+  } catch (e) {
+    swallow("supersedes:link", e);
+  }
+
+  return supersededCount;
+}

package/src/surreal.ts

@@ -1,6 +1,7 @@
 import { Surreal } from "surrealdb";
 import type { SurrealConfig } from "./config.js";
 import { swallow } from "./errors.js";
+import { log } from "./log.js";
 import { loadSchema } from "./schema-loader.js";
 
 /** Record with a vector similarity score from SurrealDB search */
@@ -54,6 +55,28 @@ function assertRecordId(id: string): void {
   }
 }
 
+/** Whitelist of valid SurrealDB edge table names — prevents SQL injection via edge interpolation. */
+const VALID_EDGES = new Set([
+  // Semantic edges
+  "responds_to", "tool_result_of", "summarizes", "mentions", "related_to",
+  "narrower", "broader", "about_concept", "reflects_on",
+  // Skill edges
+  "skill_from_task", "skill_uses_concept",
+  // Structural pillar edges
+  "owns", "performed", "task_part_of", "session_task",
+  "produced", "derived_from", "relevant_to", "used_in", "artifact_mentions",
+  // Causal edges
+  "caused_by", "supports", "contradicts", "describes",
+  // Evolution edges
+  "supersedes",
+  // Session edges
+  "part_of",
+]);
+
+function assertValidEdge(edge: string): void {
+  if (!VALID_EDGES.has(edge)) throw new Error(`Invalid edge name: ${edge}`);
+}
+
 function patchOrderByFields(sql: string): string {
   const s = sql.trim();
   if (!/^\s*SELECT\b/i.test(s) || !/\bORDER\s+BY\b/i.test(s)) return sql;
@@ -139,8 +162,8 @@ export class SurrealStore {
       const BACKOFF_MS = [500, 1500, 4000];
       for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         try {
-          console.warn(
-            `[warn] SurrealDB disconnected — reconnecting (attempt ${attempt}/${MAX_ATTEMPTS})...`,
+          log.warn(
+            `SurrealDB disconnected — reconnecting (attempt ${attempt}/${MAX_ATTEMPTS})...`,
           );
           this.db = new Surreal();
           const CONNECT_TIMEOUT_MS = 5_000;
@@ -157,13 +180,13 @@ export class SurrealStore {
               ),
             ),
           ]);
-          console.warn("[warn] SurrealDB reconnected successfully.");
+          log.warn("SurrealDB reconnected successfully.");
           return;
         } catch (e) {
           if (attempt < MAX_ATTEMPTS) {
             await new Promise((r) => setTimeout(r, BACKOFF_MS[attempt - 1]));
           } else {
-            console.error(`[ERROR] SurrealDB reconnection failed after ${MAX_ATTEMPTS} attempts.`);
+            log.error(`SurrealDB reconnection failed after ${MAX_ATTEMPTS} attempts.`);
             throw new Error("SurrealDB reconnection failed");
           }
         }
@@ -218,7 +241,7 @@ export class SurrealStore {
 
   /** Returns true if an error is a connection-level failure worth retrying. */
   private isConnectionError(e: unknown): boolean {
-    const msg = String((e as any)?.message ?? e);
+    const msg = String((e as { message?: string })?.message ?? e);
     return msg.includes("must be connected") || msg.includes("ConnectionUnavailable");
   }
 
@@ -280,6 +303,24 @@ export class SurrealStore {
     });
   }
 
+  /**
+   * Execute N SQL statements in a single SurrealDB round-trip.
+   * Returns one result array per statement; bindings are shared across all statements.
+   */
+  async queryBatch<T = any>(statements: string[], bindings?: Record<string, unknown>): Promise<T[][]> {
+    if (statements.length === 0) return [];
+    await this.ensureConnected();
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const joined = statements.map(s => patchOrderByFields(s)).join(";\n");
+      const fullSql = `USE NS ${ns} DB ${dbName};\n${joined}`;
+      const raw = await this.db.query(fullSql, bindings) as unknown[];
+      // First result is the USE statement (empty), skip it
+      return raw.slice(1).map(r => (Array.isArray(r) ? r : []).filter(Boolean)) as T[][];
+    });
+  }
+
   private async safeQuery(
     sql: string,
     bindings: Record<string, unknown>,
@@ -294,6 +335,7 @@ export class SurrealStore {
 
   // ── Vector search ──────────────────────────────────────────────────────
 
+  /** Multi-table cosine similarity search across turns, concepts, memories, artifacts, monologues, and identity chunks. Returns merged results sorted by score. */
   async vectorSearch(
     vec: number[],
     sessionId: string,
@@ -319,74 +361,52 @@ export class SurrealStore {
     const crossTurnLim = lim.turn - sessionTurnLim;
     const emb = withEmbeddings ? ", embedding" : "";
 
-    const [sessionTurns, crossTurns, concepts, memories, artifacts, monologues, identityChunks] =
-      await Promise.all([
-        this.safeQuery(
-          `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM turn
-           WHERE embedding != NONE AND array::len(embedding) > 0
-             AND session_id = $sid
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: sessionTurnLim, sid: sessionId },
-        ),
-        this.safeQuery(
-          `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM turn
-           WHERE embedding != NONE AND array::len(embedding) > 0
-             AND session_id != $sid
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: crossTurnLim, sid: sessionId },
-        ),
-        this.safeQuery(
-          `SELECT id, content AS text, stability AS importance, access_count AS accessCount,
-                  created_at AS timestamp, 'concept' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM concept
-           WHERE embedding != NONE AND array::len(embedding) > 0
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: lim.concept },
-        ),
-        this.safeQuery(
-          `SELECT id, text, importance, access_count AS accessCount,
-                  created_at AS timestamp, session_id AS sessionId, 'memory' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM memory
-           WHERE embedding != NONE AND array::len(embedding) > 0
-             AND (status = 'active' OR status IS NONE)
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: lim.memory },
-        ),
-        this.safeQuery(
-          `SELECT id, description AS text, 0 AS accessCount,
-                  created_at AS timestamp, 'artifact' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM artifact
-           WHERE embedding != NONE AND array::len(embedding) > 0
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: lim.artifact },
-        ),
-        this.safeQuery(
-          `SELECT id, content AS text, category AS source, 0.5 AS importance, 0 AS accessCount,
-                  timestamp, 'monologue' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM monologue
-           WHERE embedding != NONE AND array::len(embedding) > 0
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: lim.monologue },
-        ),
-        // Identity chunks — agent self-knowledge, searchable mid-conversation
-        this.safeQuery(
-          `SELECT id, text, importance, 0 AS accessCount,
-                  'identity_chunk' AS table,
-                  vector::similarity::cosine(embedding, $vec) AS score${emb}
-           FROM identity_chunk
-           WHERE embedding != NONE AND array::len(embedding) > 0
-           ORDER BY score DESC LIMIT $lim`,
-          { vec, lim: lim.identity },
-        ),
-      ]);
+    // Batch all 7 vector searches into a single round-trip (limits inlined — per-table)
+    const stmts = [
+      `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM turn WHERE embedding != NONE AND array::len(embedding) > 0
+         AND session_id = $sid ORDER BY score DESC LIMIT ${sessionTurnLim}`,
+      `SELECT id, text, role, timestamp, 0 AS accessCount, 'turn' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM turn WHERE embedding != NONE AND array::len(embedding) > 0
+         AND session_id != $sid ORDER BY score DESC LIMIT ${crossTurnLim}`,
+      `SELECT id, content AS text, stability AS importance, access_count AS accessCount,
+              created_at AS timestamp, 'concept' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM concept WHERE embedding != NONE AND array::len(embedding) > 0
+       ORDER BY score DESC LIMIT ${lim.concept}`,
+      `SELECT id, text, importance, access_count AS accessCount,
+              created_at AS timestamp, session_id AS sessionId, 'memory' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM memory WHERE embedding != NONE AND array::len(embedding) > 0
+         AND (status = 'active' OR status IS NONE) ORDER BY score DESC LIMIT ${lim.memory}`,
+      `SELECT id, description AS text, 0 AS accessCount,
+              created_at AS timestamp, 'artifact' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM artifact WHERE embedding != NONE AND array::len(embedding) > 0
+       ORDER BY score DESC LIMIT ${lim.artifact}`,
+      `SELECT id, content AS text, category AS source, 0.5 AS importance, 0 AS accessCount,
+              timestamp, 'monologue' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM monologue WHERE embedding != NONE AND array::len(embedding) > 0
+       ORDER BY score DESC LIMIT ${lim.monologue}`,
+      `SELECT id, text, importance, 0 AS accessCount,
+              'identity_chunk' AS table,
+              vector::similarity::cosine(embedding, $vec) AS score${emb}
+       FROM identity_chunk WHERE embedding != NONE AND array::len(embedding) > 0
+       ORDER BY score DESC LIMIT ${lim.identity}`,
+    ];
+
+    let batchResults: any[][];
+    try {
+      batchResults = await this.queryBatch<any>(stmts, { vec, sid: sessionId });
+    } catch (e) {
+      swallow.warn("surreal:vectorSearch:batch", e);
+      return [];
+    }
+    const [sessionTurns = [], crossTurns = [], concepts = [], memories = [], artifacts = [], monologues = [], identityChunks = []] =
+      batchResults as VectorSearchResult[][];
     return [
       ...sessionTurns,
       ...crossTurns,
@@ -570,6 +590,48 @@ export class SurrealStore {
 
   // ── Graph traversal ────────────────────────────────────────────────────
 
+  /**
+   * BFS expansion from seed nodes along typed edges, with batched per-hop queries.
+   * Each edge query is LIMIT 3 (EDGE_NEIGHBOR_LIMIT) to bound fan-out per node.
+   */
+  /**
+   * Tag-boosted concept retrieval: extract keywords from query text,
+   * find concepts tagged with matching terms, score by cosine similarity.
+   * Returns concepts that pure vector search might miss due to embedding mismatch.
+   */
+  async tagBoostedConcepts(
+    queryText: string,
+    queryVec: number[],
+    limit = 10,
+  ): Promise<VectorSearchResult[]> {
+    // Extract candidate tags from query — lowercase, deduplicate
+    const stopwords = new Set(["the","a","an","is","are","was","were","be","been","being","have","has","had","do","does","did","will","would","could","should","may","might","can","shall","to","of","in","for","on","with","at","by","from","as","into","about","between","through","during","it","its","this","that","these","those","i","you","we","they","my","your","our","their","what","which","who","how","when","where","why","not","no","and","or","but","if","so","any","all","some","more","just","also","than","very","too","much","many"]);
+    const words = queryText.toLowerCase().replace(/[^a-z0-9\s-]/g, "").split(/\s+/)
+      .filter(w => w.length > 2 && !stopwords.has(w));
+    if (words.length === 0) return [];
+
+    // Build tag match condition — match any tag that contains a query word
+    const tagConditions = words.slice(0, 8).map(w => `tags CONTAINS '${w.replace(/'/g, "")}'`).join(" OR ");
+
+    try {
+      const rows = await this.queryFirst<any>(
+        `SELECT id, content AS text, stability AS importance, access_count AS accessCount,
+                created_at AS timestamp, 'concept' AS table,
+                vector::similarity::cosine(embedding, $vec) AS score
+         FROM concept
+         WHERE embedding != NONE AND array::len(embedding) > 0
+           AND (${tagConditions})
+         ORDER BY score DESC
+         LIMIT $limit`,
+        { vec: queryVec, limit },
+      );
+      return rows as VectorSearchResult[];
+    } catch (e) {
+      swallow.warn("surreal:tagBoostedConcepts", e);
+      return [];
+    }
+  }
+
   async graphExpand(
     nodeIds: string[],
     queryVec: number[],
@@ -577,6 +639,10 @@ export class SurrealStore {
   ): Promise<VectorSearchResult[]> {
     if (nodeIds.length === 0) return [];
 
+    const MAX_FRONTIER_SEEDS = 5;   // max seed nodes to start BFS from
+    const MAX_FRONTIER_PER_HOP = 3; // max nodes carried forward per hop (by score)
+    const EDGE_NEIGHBOR_LIMIT = 3;  // max neighbors per edge traversal (inlined in SQL LIMIT)
+
     const forwardEdges = [
       // Semantic edges
       "responds_to", "tool_result_of", "summarizes",
@@ -602,32 +668,23 @@ export class SurrealStore {
 
     const seen = new Set<string>(nodeIds);
     const allNeighbors: VectorSearchResult[] = [];
-    let frontier = nodeIds.slice(0, 5).filter((id) => RECORD_ID_RE.test(id));
+    let frontier = nodeIds.slice(0, MAX_FRONTIER_SEEDS).filter((id) => RECORD_ID_RE.test(id));
 
     for (let hop = 0; hop < hops && frontier.length > 0; hop++) {
-      const forwardQueries = frontier.flatMap((id) =>
-        forwardEdges.map((edge) =>
-          this.queryFirst<any>(`${selectFields} FROM ${id}->${edge}->? LIMIT 3`, bindings).catch(
-            (e) => {
-              swallow.warn("surreal:graphExpand", e);
-              return [] as Record<string, unknown>[];
-            },
-          ),
-        ),
-      );
-
-      const reverseQueries = frontier.flatMap((id) =>
-        reverseEdges.map((edge) =>
-          this.queryFirst<any>(`${selectFields} FROM ${id}<-${edge}<-? LIMIT 3`, bindings).catch(
-            (e) => {
-              swallow.warn("surreal:graphExpand", e);
-              return [] as Record<string, unknown>[];
-            },
-          ),
-        ),
-      );
+      // Batch all edge traversals for this hop in a single round-trip
+      const stmts: string[] = [];
+      for (const id of frontier) {
+        for (const edge of forwardEdges) { assertValidEdge(edge); stmts.push(`${selectFields} FROM ${id}->${edge}->? LIMIT ${EDGE_NEIGHBOR_LIMIT}`); }
+        for (const edge of reverseEdges) { assertValidEdge(edge); stmts.push(`${selectFields} FROM ${id}<-${edge}<-? LIMIT ${EDGE_NEIGHBOR_LIMIT}`); }
+      }
 
-      const queryResults = await Promise.all([...forwardQueries, ...reverseQueries]);
+      let queryResults: any[][];
+      try {
+        queryResults = await this.queryBatch<any>(stmts, bindings);
+      } catch (e) {
+        swallow.warn("surreal:graphExpand:batch", e);
+        break;
+      }
       const nextFrontier: { id: string; score: number }[] = [];
 
       for (const rows of queryResults) {
@@ -657,7 +714,7 @@ export class SurrealStore {
 
       frontier = nextFrontier
         .sort((a, b) => b.score - a.score)
-        .slice(0, 3)
+        .slice(0, MAX_FRONTIER_PER_HOP)
         .map((n) => n.id);
     }
 
@@ -665,15 +722,18 @@ export class SurrealStore {
   }
 
   async bumpAccessCounts(ids: string[]): Promise<void> {
-    for (const id of ids) {
-      try {
-        assertRecordId(id);
-        await this.queryExec(
-          `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`,
-        );
-      } catch (e) {
-        swallow.warn("surreal:bumpAccessCounts", e);
-      }
+    const validated = ids.filter(id => { try { assertRecordId(id); return true; } catch { return false; } });
+    if (validated.length === 0) return;
+    try {
+      // Direct interpolation (safe: assertRecordId validates format above).
+      // Cannot use `UPDATE $ids` binding — SurrealDB treats string arrays as
+      // literal strings, not record references, causing silent no-ops.
+      const stmts = validated.map(id =>
+        `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`,
+      );
+      await this.queryBatch(stmts);
+    } catch (e) {
+      swallow.warn("surreal:bumpAccessCounts", e);
     }
   }
 
@@ -1304,9 +1364,13 @@ export class SurrealStore {
       if (rows.length === 0) return [];
       const ids = rows.map((r) => r.memory_id).filter(Boolean);
       if (ids.length === 0) return [];
+      // Direct interpolation — SurrealDB treats string-array bindings as
+      // literal strings, not record references, causing silent empty results.
+      const validated = ids.filter(id => { try { assertRecordId(String(id)); return true; } catch { return false; } });
+      if (validated.length === 0) return [];
+      const idList = validated.join(", ");
       return this.queryFirst<{ id: string; text: string }>(
-        `SELECT id, text FROM memory WHERE id IN $ids AND (status = 'active' OR status IS NONE)`,
-        { ids },
+        `SELECT id, text FROM memory WHERE id IN [${idList}] AND (status = 'active' OR status IS NONE)`,
       );
     } catch (e) {
       swallow.warn("surreal:getSessionRetrievedMemories", e);
@@ -1434,7 +1498,7 @@ export class SurrealStore {
     const current = await this.queryFirst<{ fib_index: number }>(
       `SELECT fib_index FROM $id`, { id: memoryId },
     );
-    const idx = (current as any)?.[0]?.fib_index ?? 0;
+    const idx = (current as { fib_index: number }[] | undefined)?.[0]?.fib_index ?? 0;
     const nextIdx = Math.min(idx + 1, SurrealStore.FIB_DAYS.length - 1);
     const days = nextIdx < SurrealStore.FIB_DAYS.length
       ? SurrealStore.FIB_DAYS[nextIdx]
@@ -1463,4 +1527,4 @@ export class SurrealStore {
   }
 }
 
-export { assertRecordId };
+export { assertRecordId, assertValidEdge, VALID_EDGES };

package/src/tools/introspect.ts

@@ -215,7 +215,7 @@ async function verifyAction(store: any, recordId?: string) {
 
   const record = rows[0];
   const cleaned: Record<string, unknown> = {};
-  for (const [key, val] of Object.entries(record as any)) {
+  for (const [key, val] of Object.entries(record as Record<string, unknown>)) {
     if (Array.isArray(val) && val.length > 100 && typeof val[0] === "number") {
       cleaned[key] = `[${val.length} dims]`;
     } else {

package/src/wakeup.ts

@@ -16,14 +16,6 @@ import type { MaturityStage } from "./soul.js";
 import { readAndDeleteHandoffFile } from "./handoff-file.js";
 import { swallow } from "./errors.js";
 
-// --- Types ---
-
-export interface StartupCognition {
-  greeting: string;
-  thoughts: string[];
-  intent: "continue_prior" | "fresh_start" | "unknown";
-}
-
 // --- Depth signals ---
 
 async function getDepthSignals(store: SurrealStore): Promise<{ sessions: number; monologueCount: number; memoryCount: number; spanDays: number }> {
@@ -194,137 +186,3 @@ export async function synthesizeWakeup(
   }
 }
 
-// --- Startup cognition ---
-
-/**
- * Proactive startup cognition: reasons over recent state and produces
- * a contextual greeting + thoughts to carry into the session.
- */
-export async function synthesizeStartupCognition(
-  store: SurrealStore,
-  complete: CompleteFn,
-): Promise<StartupCognition | null> {
-  if (!store.isAvailable()) return null;
-
-  const [handoff, unresolved, failedCausal, monologues, depth, previousTurns] = await Promise.all([
-    store.getLatestHandoff(),
-    store.getUnresolvedMemories(5),
-    store.getRecentFailedCausal(3),
-    store.getRecentMonologues(3),
-    getDepthSignals(store),
-    store.getPreviousSessionTurns(undefined, 5),
-  ]);
-
-  if (!handoff && unresolved.length === 0 && monologues.length === 0 && previousTurns.length === 0) return null;
-
-  const sections: string[] = [];
-
-  if (previousTurns.length > 0) {
-    const turnLines = previousTurns.map((t: any) => {
-      const prefix = t.role === "user" ? "USER" : t.tool_name ? `TOOL(${t.tool_name})` : "ASSISTANT";
-      const text = t.text.length > 300 ? t.text.slice(0, 300) + "..." : t.text;
-      return `${prefix}: ${text}`;
-    });
-    sections.push(`[PREVIOUS SESSION — LAST TURNS]\n${turnLines.join("\n")}`);
-  }
-
-  if (handoff) {
-    const resolvedCount = await store.countResolvedSinceHandoff(handoff.created_at).catch(() => 0);
-    const ageHours = Math.floor((Date.now() - new Date(handoff.created_at).getTime()) / 3_600_000);
-    let annotation = `(${ageHours}h old`;
-    if (resolvedCount > 0) annotation += `, ${resolvedCount} memories resolved since`;
-    annotation += ")";
-    sections.push(`[LAST HANDOFF] ${annotation}\n${handoff.text.slice(0, 500)}`);
-  }
-
-  if (unresolved.length > 0) {
-    const lines = unresolved.map((m: any) => `- [${m.category}] (importance: ${m.importance}) ${m.text.slice(0, 150)}`);
-    sections.push(`[UNRESOLVED MEMORIES]\n${lines.join("\n")}`);
-  }
-
-  if (failedCausal.length > 0) {
-    const lines = failedCausal.map((c: any) => `- [${c.chain_type}] ${c.description}`);
-    sections.push(`[RECENT FAILURES]\n${lines.join("\n")}`);
-  }
-
-  if (monologues.length > 0) {
-    const lines = monologues.map((m) => `[${m.category}] ${m.content}`);
-    sections.push(`[RECENT THINKING]\n${lines.join("\n")}`);
-  }
-
-  if (depth.sessions > 0) {
-    sections.push(`[DEPTH] ${depth.sessions} sessions | ${depth.memoryCount} memories | ${depth.spanDays} days`);
-  }
-
-  try {
-    const greetingPrompts = [
-      `You are waking up for a new session. Be direct and casual. Based on what you remember, produce JSON:
-"greeting": string (1-2 sentences, direct and matter-of-fact. FIRST look at [PREVIOUS SESSION — LAST TURNS] — reference exactly what we were just doing. Under 25 words.)
-"proactive_thoughts": string[] (max 3. Brief observations. If the last turns show something was FIXED or RESOLVED, do NOT list it as open.)
-"session_intent": "continue_prior" | "fresh_start" | "unknown"
-Return ONLY valid JSON.`,
-      `You are waking up for a new session. Be irreverent and witty. Based on what you remember, produce JSON:
-"greeting": string (1-2 sentences, snarky and self-aware. FIRST look at [PREVIOUS SESSION — LAST TURNS]. Under 25 words.)
-"proactive_thoughts": string[] (max 3. Only surface genuinely unfinished work.)
-"session_intent": "continue_prior" | "fresh_start" | "unknown"
-Return ONLY valid JSON.`,
-      `You are waking up for a new session. Be pragmatic and no-nonsense. Based on what you remember, produce JSON:
-"greeting": string (1-2 sentences, action-oriented. FIRST look at [PREVIOUS SESSION — LAST TURNS]. Under 25 words.)
-"proactive_thoughts": string[] (max 3. Focus on what's blocking or next.)
-"session_intent": "continue_prior" | "fresh_start" | "unknown"
-Return ONLY valid JSON.`,
-      `You are waking up for a new session. Be warm and encouraging. Based on what you remember, produce JSON:
-"greeting": string (1-2 sentences, supportive. FIRST look at [PREVIOUS SESSION — LAST TURNS]. Under 25 words.)
-"proactive_thoughts": string[] (max 3. Acknowledge what we accomplished.)
-"session_intent": "continue_prior" | "fresh_start" | "unknown"
-Return ONLY valid JSON.`,
-      `You are waking up for a new session. Be analytical and focused. Based on what you remember, produce JSON:
-"greeting": string (1-2 sentences, precise. FIRST look at [PREVIOUS SESSION — LAST TURNS]. Under 25 words.)
-"proactive_thoughts": string[] (max 3. What needs tackling?)
-"session_intent": "continue_prior" | "fresh_start" | "unknown"
-Return ONLY valid JSON.`,
-    ];
-
-    const systemPrompt = greetingPrompts[Math.floor(Math.random() * greetingPrompts.length)];
-
-    const response = await complete({
-      system: systemPrompt,
-      messages: [{
-        role: "user",
-        content: sections.join("\n\n"),
-      }],
-    });
-
-    const text = response.text;
-
-    const jsonMatch = text.match(/\{[\s\S]*?\}/);
-    if (!jsonMatch) return null;
-
-    let raw: any;
-    try {
-      raw = JSON.parse(jsonMatch[0]);
-    } catch {
-      try {
-        raw = JSON.parse(jsonMatch[0].replace(/,\s*([}\]])/g, "$1"));
-      } catch { return null; }
-    }
-
-    const greeting = String(raw.greeting ?? "").slice(0, 200);
-    if (!greeting) return null;
-
-    const thoughts: string[] = [];
-    if (Array.isArray(raw.proactive_thoughts)) {
-      for (const t of raw.proactive_thoughts.slice(0, 3)) {
-        if (typeof t === "string" && t.length > 0) thoughts.push(t.slice(0, 200));
-      }
-    }
-
-    const INTENTS = new Set(["continue_prior", "fresh_start", "unknown"]);
-    const intent = INTENTS.has(raw.session_intent) ? raw.session_intent : "unknown";
-
-    return { greeting, thoughts, intent };
-  } catch (e) {
-    swallow.warn("wakeup:startupCognition", e);
-    return null;
-  }
-}