kongbrain 0.4.1 → 0.4.2

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,26 @@ 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",
+  // 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 +160,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 +178,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 +239,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 +301,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 +333,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 +359,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 +588,10 @@ 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.
+   */
   async graphExpand(
     nodeIds: string[],
     queryVec: number[],
@@ -577,6 +599,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 +628,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 +674,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 +682,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 +1324,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 +1458,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 +1487,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;
-  }
-}