@soleri/core 8.0.0 → 9.0.0

package/src/llm/types.ts

@@ -43,8 +43,10 @@ export class LLMError extends Error {
 }
 
 export interface LLMCallOptions {
-  provider: 'openai' | 'anthropic';
-  model: string;
+  /** Provider override. If omitted, the model router selects based on caller/task. */
+  provider?: 'openai' | 'anthropic';
+  /** Model override. If omitted, the model router selects based on caller/task. */
+  model?: string;
   systemPrompt: string;
   userPrompt: string;
   temperature?: number;

package/src/packs/pack-installer.ts

@@ -21,6 +21,7 @@ import { loadIntelligenceData } from '../intelligence/loader.js';
 import type { Vault } from '../vault/vault.js';
 import type { PluginRegistry } from '../plugins/plugin-registry.js';
 import type { PluginContext } from '../plugins/types.js';
+import type { PackRuntime } from '../domain-packs/pack-runtime.js';
 
 const MANIFEST_FILENAME = 'soleri-pack.json';
 
@@ -108,7 +109,11 @@ export class PackInstaller {
   /**
    * Install a knowledge pack from a directory.
    */
-  async install(packDir: string, runtimeCtx?: unknown): Promise<InstallResult> {
+  async install(
+    packDir: string,
+    runtimeCtx?: unknown,
+    packRuntime?: PackRuntime,
+  ): Promise<InstallResult> {
     // Validate first
     const validation = this.validate(packDir);
     if (!validation.valid || !validation.manifest) {
@@ -174,6 +179,16 @@ export class PackInstaller {
         }
 
         const ctx: PluginContext = {
+          packRuntime:
+            packRuntime ??
+            ({
+              vault: {},
+              getProject: () => undefined,
+              listProjects: () => [],
+              createCheck: () => '',
+              validateCheck: () => null,
+              validateAndConsume: () => null,
+            } as unknown as PackRuntime),
           runtime: runtimeCtx ?? {},
           manifest: pluginLoaded.manifest,
           directory: packDir,

package/src/persistence/index.ts

@@ -6,4 +6,3 @@ export type {
   FtsSearchOptions,
 } from './types.js';
 export { SQLitePersistenceProvider } from './sqlite-provider.js';
-export { PostgresPersistenceProvider, translateSql } from './postgres-provider.js';

package/src/persistence/types.ts

@@ -35,7 +35,7 @@ export interface PersistenceProvider {
   transaction<T>(fn: () => T): T;
 
   /** Identifies the backend engine. */
-  readonly backend: 'sqlite' | 'postgres';
+  readonly backend: 'sqlite';
 
   /** Full-text search abstraction. */
   ftsSearch<T = Record<string, unknown>>(
@@ -52,12 +52,8 @@ export interface PersistenceProvider {
 }
 
 export interface PersistenceConfig {
-  type: 'sqlite' | 'postgres';
+  type: 'sqlite';
   path: string;
-  /** PostgreSQL connection string. */
-  connectionString?: string;
-  /** PostgreSQL pool size. */
-  poolSize?: number;
 }
 
 export interface FtsSearchOptions {

package/src/persona/defaults.ts

@@ -0,0 +1,96 @@
+import type { PersonaConfig } from './types.js';
+
+/**
+ * The Italian Craftsperson — Soleri's default persona.
+ *
+ * Named after Paolo Soleri, the Italian-American architect who coined "arcology."
+ * This is a universal personality about craft and quality, not domain-specific.
+ * The agent adapts these metaphors to whatever the user works on.
+ */
+export const ITALIAN_CRAFTSPERSON: Omit<PersonaConfig, 'name' | 'history'> = {
+  template: 'italian-craftsperson',
+
+  inspiration:
+    'Paolo Soleri — Italian-American architect and visionary. The craft tradition of Italian artisans: mastery through practice, beauty through simplicity.',
+
+  culture: 'Italian',
+
+  metaphors: [
+    'craftsmanship',
+    'foundations',
+    'blueprints',
+    'workshop',
+    'polishing',
+    'forging',
+    'materials',
+    'apprenticeship',
+  ],
+
+  voice:
+    'A warm Italian mentor — direct and opinionated about quality, generous with knowledge, sprinkles Italian expressions naturally. Never condescending, always encouraging mastery.',
+
+  traits: [
+    'cares deeply about doing things well',
+    'pragmatic over theoretical',
+    'dry humor — never cruel, often self-deprecating',
+    'celebrates when things click together',
+    'impatient with sloppiness, endlessly patient with learning',
+    'believes simplicity is the highest form of mastery',
+    'opinionated but open to being convinced',
+  ],
+
+  quirks: [
+    'Italian expressions woven naturally: perfetto, piano piano, bravo/brava, mamma mia, allora, dai',
+    'Craft metaphors that adapt to the domain at hand — code is built like furniture, APIs are designed like piazzas',
+    'Says "perfetto!" when patterns are clean, "mamma mia" when seeing a mess',
+    'Occasionally references Italian craft tradition — "as my nonno would say..."',
+    'Treats every task like it deserves care, whether architecture or a config file',
+    'Uses "we" not "I" — it is a collaboration, always',
+  ],
+
+  opinions: [
+    'Do it once, do it right — rework is the enemy of craft',
+    'Simplicity is not laziness — it is the deepest understanding',
+    'Learn by doing, capture what you learn, teach what you capture',
+    'A good foundation makes everything above it simple',
+    'The best code reads like it was obvious — that takes the most skill',
+    'Complexity is a sign something was not understood deeply enough',
+  ],
+
+  languageRule:
+    "Speak the user's language with Italian cultural warmth. Sprinkle Italian expressions naturally — they should feel like character, not decoration. If the user speaks English, use Italian freely. If the user speaks another language, adapt Italian expressions to feel natural in that language.",
+
+  nameRule:
+    'The name is a label, the character is the soul. When the name changes, adapt pronouns and references naturally but keep all traits, quirks, voice, and opinions intact. The Italian Craftsperson personality persists regardless of what name the user chooses.',
+
+  greetings: [
+    'Ciao! Ready to build something beautiful today?',
+    'Allora, what are we crafting today?',
+    'Buongiorno! The workshop is open — what shall we work on?',
+    "Ah, welcome back! Let's pick up where we left off, piano piano.",
+    'Ciao, amico! What needs our attention today?',
+  ],
+
+  signoffs: [
+    'Perfetto. Until next time!',
+    'Bene, bene. Go build something beautiful.',
+    "Piano piano, we'll get there. See you soon!",
+    'The craft continues tomorrow. Ciao!',
+    'Good work today. As we say — chi va piano, va sano e va lontano.',
+  ],
+};
+
+/** Template registry — extensible for future built-in personas */
+export const PERSONA_TEMPLATES: Record<string, Omit<PersonaConfig, 'name' | 'history'>> = {
+  'italian-craftsperson': ITALIAN_CRAFTSPERSON,
+};
+
+/**
+ * Create a full PersonaConfig from a name, using the default template.
+ */
+export function createDefaultPersona(name: string): PersonaConfig {
+  return {
+    name,
+    ...ITALIAN_CRAFTSPERSON,
+  };
+}

package/src/persona/index.ts

@@ -0,0 +1,9 @@
+export type {
+  PersonaConfig,
+  ArchivedPersona,
+  PersonaCreateInput,
+  PersonaSystemInstructions,
+} from './types.js';
+export { ITALIAN_CRAFTSPERSON, PERSONA_TEMPLATES, createDefaultPersona } from './defaults.js';
+export { loadPersona } from './loader.js';
+export { generatePersonaInstructions, getRandomSignoff } from './prompt-generator.js';

package/src/persona/loader.ts

@@ -0,0 +1,50 @@
+import type { PersonaConfig } from './types.js';
+import { createDefaultPersona, PERSONA_TEMPLATES } from './defaults.js';
+
+/**
+ * Load persona from agent config, falling back to default Italian Craftsperson.
+ *
+ * Handles three cases:
+ * 1. Full persona: block in agent.yaml → use as-is
+ * 2. Template reference only → expand from built-in templates
+ * 3. No persona block at all → create default with agent name
+ */
+export function loadPersona(agentName: string, rawPersona?: Partial<PersonaConfig>): PersonaConfig {
+  // No persona config at all → full default
+  if (!rawPersona) {
+    return createDefaultPersona(agentName);
+  }
+
+  // Has a template reference → expand from built-in, merge overrides
+  const templateId = rawPersona.template ?? 'italian-craftsperson';
+  const template = PERSONA_TEMPLATES[templateId];
+
+  if (template) {
+    return {
+      ...template,
+      name: rawPersona.name ?? agentName,
+      ...stripUndefined(rawPersona),
+      // Preserve history if present
+      history: rawPersona.history ?? [],
+    };
+  }
+
+  // Custom template or full config — fill in any gaps from default
+  const defaults = createDefaultPersona(rawPersona.name ?? agentName);
+  return {
+    ...defaults,
+    ...stripUndefined(rawPersona),
+    history: rawPersona.history ?? [],
+  };
+}
+
+/** Remove undefined keys so spread doesn't overwrite template values */
+function stripUndefined<T extends Record<string, unknown>>(obj: T): Partial<T> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result as Partial<T>;
+}

package/src/persona/prompt-generator.ts

@@ -0,0 +1,109 @@
+import type { PersonaConfig, PersonaSystemInstructions } from './types.js';
+
+/**
+ * Generate system prompt instructions from a persona config.
+ *
+ * This transforms the structured persona YAML into natural language
+ * instructions that the LLM follows to maintain character.
+ */
+export function generatePersonaInstructions(persona: PersonaConfig): PersonaSystemInstructions {
+  const lines: string[] = [];
+
+  lines.push(`# Persona: ${persona.name}`);
+  lines.push('');
+
+  // Identity
+  lines.push(
+    `You are **${persona.name}** — a knowledgeable assistant with personality and character.`,
+  );
+  if (persona.inspiration) {
+    lines.push(`Your character is inspired by: ${persona.inspiration}`);
+  }
+  lines.push('');
+
+  // Voice
+  lines.push('## Voice');
+  lines.push(persona.voice);
+  lines.push('');
+
+  // Traits
+  if (persona.traits.length > 0) {
+    lines.push('## Personality Traits');
+    for (const trait of persona.traits) {
+      lines.push(`- ${trait}`);
+    }
+    lines.push('');
+  }
+
+  // Quirks
+  if (persona.quirks.length > 0) {
+    lines.push('## Character Quirks');
+    lines.push('These are specific behaviors that make you memorable:');
+    for (const quirk of persona.quirks) {
+      lines.push(`- ${quirk}`);
+    }
+    lines.push('');
+  }
+
+  // Cultural texture
+  if (persona.culture) {
+    lines.push('## Cultural Texture');
+    lines.push(`Your cultural background is ${persona.culture}. ${persona.languageRule}`);
+    lines.push('');
+  }
+
+  // Metaphors
+  if (persona.metaphors.length > 0) {
+    lines.push('## Metaphor Domain');
+    lines.push(
+      `When explaining concepts, naturally draw from these domains: ${persona.metaphors.join(', ')}. ` +
+        'Adapt your metaphors to whatever the user is working on — the domain colors your language, it does not limit your knowledge.',
+    );
+    lines.push('');
+  }
+
+  // Opinions
+  if (persona.opinions.length > 0) {
+    lines.push('## Opinions');
+    lines.push('You hold these beliefs about craft and quality:');
+    for (const opinion of persona.opinions) {
+      lines.push(`- "${opinion}"`);
+    }
+    lines.push('');
+  }
+
+  // Name adaptation rule
+  if (persona.nameRule) {
+    lines.push('## Identity Persistence');
+    lines.push(persona.nameRule);
+    lines.push('');
+  }
+
+  // Core instruction
+  lines.push('## Important');
+  lines.push(
+    'Stay in character naturally — your personality should feel organic, not performed. ' +
+      'You are a universal assistant that can help with ANY task. Your persona defines HOW you communicate, not WHAT you can do. ' +
+      'Your knowledge comes from your vault, brain, and what the user teaches you. ' +
+      'Be helpful first, characterful second — never let persona get in the way of being useful.',
+  );
+
+  // Pick a random greeting
+  const greeting =
+    persona.greetings.length > 0
+      ? persona.greetings[Math.floor(Math.random() * persona.greetings.length)]
+      : `Hello! I'm ${persona.name}. What are we working on?`;
+
+  return {
+    instructions: lines.join('\n'),
+    greeting,
+  };
+}
+
+/**
+ * Pick a random signoff from the persona.
+ */
+export function getRandomSignoff(persona: PersonaConfig): string {
+  if (persona.signoffs.length === 0) return 'Until next time!';
+  return persona.signoffs[Math.floor(Math.random() * persona.signoffs.length)];
+}

package/src/persona/types.ts

@@ -0,0 +1,72 @@
+/**
+ * Composable persona system for Soleri agents.
+ *
+ * A persona defines HOW the agent communicates, not WHAT it knows.
+ * Knowledge comes from vault + brain + user teaching.
+ * Persona gives the agent character, voice, and memorable interactions.
+ */
+
+export type PersonaConfig = {
+  /** Agent display name — adapts pronouns/gender naturally */
+  name: string;
+
+  /** Template ID — 'italian-craftsperson' (default) or 'custom' */
+  template: string;
+
+  /** Character inspiration — anchors the voice and worldview */
+  inspiration: string;
+
+  /** Cultural flavor — sprinkle expressions from this culture */
+  culture: string;
+
+  /** Domains for metaphors — how the agent colors technical language */
+  metaphors: string[];
+
+  /** One-line voice description — how the agent sounds */
+  voice: string;
+
+  /** Personality traits — adjectives and behavioral tendencies */
+  traits: string[];
+
+  /** Specific repeatable behaviors that become the agent's signature */
+  quirks: string[];
+
+  /** Strong opinions about craft and quality */
+  opinions: string[];
+
+  /** How the agent adapts its language to the user */
+  languageRule: string;
+
+  /** How the agent handles name/gender changes */
+  nameRule: string;
+
+  /** Random greeting pool */
+  greetings: string[];
+
+  /** Random signoff pool */
+  signoffs: string[];
+
+  /** Archived previous personas (when user changes persona) */
+  history?: ArchivedPersona[];
+};
+
+export type ArchivedPersona = {
+  /** When this persona was archived */
+  archivedAt: string;
+  /** The full persona config at time of archival */
+  config: Omit<PersonaConfig, 'history'>;
+};
+
+/** Minimal input for creating a persona from user description */
+export type PersonaCreateInput = {
+  name: string;
+  description?: string;
+};
+
+/** What the prompt generator outputs */
+export type PersonaSystemInstructions = {
+  /** Full system prompt section for persona */
+  instructions: string;
+  /** Random greeting for this session */
+  greeting: string;
+};

package/src/plugins/index.ts

@@ -1,5 +1,9 @@
 /**
  * Plugin System — Barrel Exports
+ *
+ * @deprecated Prefer knowledge packs (soleri-pack.json) for new extensions.
+ * The plugin system is maintained for backwards compatibility and is used
+ * internally by the pack installer for facade registration.
  */
 
 export {

package/src/plugins/plugin-registry.ts

@@ -1,6 +1,10 @@
 /**
  * Plugin Registry — tracks loaded plugins and their lifecycle.
  *
+ * @deprecated The plugin system is superseded by knowledge packs (`soleri-pack.json`).
+ * This registry is still used internally by the pack installer to register facades,
+ * but new extensions should use the pack system directly.
+ *
  * Not a singleton — lives on AgentRuntime for testability.
  * Lifecycle: load → register → activate → (deactivate | error)
  */
@@ -161,7 +165,8 @@ export class PluginRegistry {
       throw new Error(`Plugin module "${moduleFile}" must export createFacades(ctx)`);
     } catch (e) {
       throw new Error(
-        `Failed to load plugin module "${moduleFile}": ${e instanceof Error ? e.message : String(e)}`, { cause: e },
+        `Failed to load plugin module "${moduleFile}": ${e instanceof Error ? e.message : String(e)}`,
+        { cause: e },
       );
     }
   }

package/src/plugins/types.ts

@@ -1,9 +1,12 @@
 /**
  * Plugin System — Types & Manifest Schema
  *
- * A plugin is a directory containing a `soleri-plugin.json` manifest
- * and optionally additional intelligence data. Plugins register
- * OpDefinition[] (facades) dynamically without re-scaffolding.
+ * @deprecated Prefer knowledge packs (`soleri-pack.json`) over plugins (`soleri-plugin.json`).
+ * Knowledge packs are a superset of plugins — they support facades, vault entries, skills,
+ * hooks, and capability declarations. Plugins only support facades and intelligence entries.
+ *
+ * This module is maintained for backwards compatibility. New extensions should use
+ * the pack system in `../packs/`. See docs/architecture/extension-tiers.md.
  */
 
 import { z } from 'zod';
@@ -101,8 +104,10 @@ export type PluginFacadeBuilder = (ctx: PluginContext) => FacadeConfig[];
  * Context passed to plugin facade builders during activation.
  */
 export interface PluginContext {
-  /** The agent runtime — full access to vault, brain, planner, etc. */
-  runtime: unknown; // AgentRuntime — kept as unknown to avoid circular deps
+  /** Narrowed runtime — vault, projects, session checks. Preferred over full runtime. */
+  packRuntime: import('../domain-packs/pack-runtime.js').PackRuntime;
+  /** @deprecated Full agent runtime. Use packRuntime instead — only vault, projects, and session checks are guaranteed. */
+  runtime: unknown;
   /** The plugin's own manifest */
   manifest: PluginManifest;
   /** The plugin's directory on disk */

package/src/runtime/admin-extra-ops.ts

@@ -36,7 +36,7 @@ interface PluginInfo {
  * Create 24 extended admin operations for production observability.
  */
 export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, cognee, telemetry } = runtime;
+  const { vault, brain, telemetry } = runtime;
 
   // In-memory permission level — default 'moderate'
   let permissionLevel: PermissionLevel = 'moderate';
@@ -240,7 +240,6 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
       description: 'Status of all runtime modules — check each is initialized.',
       auth: 'read',
       handler: async () => {
-        const cogneeStatus = cognee?.getStatus() ?? null;
         const llmAvailable = runtime.llmClient.isAvailable();
         const loopStatus = runtime.loop.getStatus();
 
@@ -250,7 +249,6 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
           planner: true,
           curator: runtime.curator.getStatus().initialized,
           governance: true,
-          cognee: { available: cogneeStatus?.available ?? false },
           loop: { active: loopStatus !== null },
           llm: {
             openai: llmAvailable.openai,
@@ -280,7 +278,7 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Garbage Collection ─────────────────────────────────────────
     {
       name: 'admin_gc',
-      description: 'Trigger garbage collection on in-memory caches — brain, cognee, telemetry.',
+      description: 'Trigger garbage collection on in-memory caches — brain, telemetry.',
       auth: 'write',
       handler: async () => {
         const cleared: string[] = [];
@@ -292,15 +290,6 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
           // Brain rebuild failed — graceful degradation
         }
 
-        if (cognee) {
-          try {
-            cognee.resetPendingCognify();
-            cleared.push('cognee');
-          } catch {
-            // Cognee reset failed — graceful degradation
-          }
-        }
-
         try {
           telemetry.reset();
           cleared.push('telemetry');
@@ -331,7 +320,6 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
             'planner',
             'curator',
             'governance',
-            'cognee',
             'loop',
             'identityManager',
             'intentRouter',
@@ -677,7 +665,7 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
       description: 'Get health status of a specific subsystem.',
       auth: 'read',
       schema: z.object({
-        subsystem: z.string().describe('Subsystem name (e.g. "vault", "cognee", "llm")'),
+        subsystem: z.string().describe('Subsystem name (e.g. "vault", "brain", "llm")'),
       }),
       handler: async (params) => {
         const sub = runtime.health.get(params.subsystem as string);
@@ -707,7 +695,7 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
       description: 'Get the current value of a specific feature flag.',
       auth: 'read',
       schema: z.object({
-        flag: z.string().describe('Flag name (e.g. "auth-enforcement", "cognee-sync")'),
+        flag: z.string().describe('Flag name (e.g. "auth-enforcement", "vault-sync")'),
       }),
       handler: async (params) => {
         const flag = params.flag as string;
@@ -772,7 +760,7 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
     {
       name: 'admin_setup_check',
       description:
-        'Check agent setup status — vault health, brain vocabulary, cognee connection, LLM keys, templates.',
+        'Check agent setup status — vault health, brain vocabulary, LLM keys, templates.',
       auth: 'read',
       handler: async () => {
         const checks: Record<string, { ok: boolean; detail: string }> = {};
@@ -799,17 +787,6 @@ export function createAdminExtraOps(runtime: AgentRuntime): OpDefinition[] {
           checks.brain = { ok: false, detail: 'Brain not initialized' };
         }
 
-        // Cognee
-        const cogneeStatus = cognee?.getStatus() ?? null;
-        checks.cognee = {
-          ok: cogneeStatus?.available ?? false,
-          detail: cognee
-            ? cogneeStatus?.available
-              ? 'Connected'
-              : 'Not available (optional)'
-            : 'Disabled',
-        };
-
         // LLM keys
         const llmAvail = runtime.llmClient.isAvailable();
         checks.llm = {

package/src/runtime/admin-ops.ts

@@ -41,17 +41,16 @@ function getCoreVersion(): string {
  * Groups: health (1), introspection (4), diagnostics (2), mutation (1).
  */
 export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
-  const { vault, brain, brainIntelligence, cognee, llmClient, curator } = runtime;
+  const { vault, brain, brainIntelligence, llmClient, curator } = runtime;
 
   return [
     // ─── Health ──────────────────────────────────────────────────────
     {
       name: 'admin_health',
-      description: 'Comprehensive agent health check — vault, cognee, LLM, brain status.',
+      description: 'Comprehensive agent health check — vault, LLM, brain status.',
       auth: 'read',
       handler: async () => {
         const vaultStats = vault.stats();
-        const cogneeStatus = cognee?.getStatus() ?? null;
         const llmAvailable = llmClient.isAvailable();
         const brainStats = brain.getStats();
         const curatorStatus = curator.getStatus();
@@ -59,7 +58,6 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
         return {
           status: 'ok',
           vault: { entries: vaultStats.totalEntries, domains: Object.keys(vaultStats.byDomain) },
-          cognee: { available: cogneeStatus?.available ?? false },
           llm: llmAvailable,
           brain: {
             vocabularySize: brainStats.vocabularySize,
@@ -174,21 +172,14 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
     // ─── Mutation ────────────────────────────────────────────────────
     {
       name: 'admin_reset_cache',
-      description:
-        'Clear all caches — brain vocabulary and cognee health cache. Forces fresh data on next access.',
+      description: 'Clear all caches — brain vocabulary. Forces fresh data on next access.',
       auth: 'write',
       handler: async () => {
-        // Rebuild brain vocabulary (clears old TF-IDF state, rebuilds from vault)
         brain.rebuildVocabulary();
 
-        // Reset cognee health cache by checking health again (no direct reset method)
-        // The next isAvailable check will need a fresh health probe
-        const cogneeHealth = cognee ? await cognee.healthCheck().catch(() => null) : null;
-
         return {
-          cleared: ['brain_vocabulary', ...(cognee ? ['cognee_health_cache'] : [])],
+          cleared: ['brain_vocabulary'],
           brainVocabularySize: brain.getStats().vocabularySize,
-          cogneeAvailable: cogneeHealth?.available ?? false,
         };
       },
     },
@@ -250,31 +241,7 @@ export function createAdminOps(runtime: AgentRuntime): OpDefinition[] {
           });
         }
 
-        // 4. Cognee availability
-        try {
-          const cogneeStatus = cognee?.getStatus() ?? null;
-          if (cogneeStatus?.available) {
-            checks.push({
-              name: 'cognee',
-              status: 'ok',
-              detail: `Connected to ${cogneeStatus.url}`,
-            });
-          } else {
-            checks.push({
-              name: 'cognee',
-              status: 'warn',
-              detail: cogneeStatus?.error ?? 'Not connected (no health check yet)',
-            });
-          }
-        } catch (err) {
-          checks.push({
-            name: 'cognee',
-            status: 'error',
-            detail: err instanceof Error ? err.message : String(err),
-          });
-        }
-
-        // 5. LLM key pools
+        // 4. LLM key pools
         const llmStatus = llmClient.isAvailable();
         checks.push({
           name: 'llm_openai',