@soleri/core 8.1.0 → 9.0.1

package/src/brain/brain.ts

@@ -10,7 +10,6 @@ import {
   cosineSimilarity,
   jaccardSimilarity,
 } from '../text/similarity.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type {
   ScoringWeights,
   ScoreBreakdown,
@@ -44,15 +43,6 @@ const DEFAULT_WEIGHTS: ScoringWeights = {
   domainMatch: 0.15,
 };
 
-const COGNEE_WEIGHTS: ScoringWeights = {
-  semantic: 0.25,
-  vector: 0.35,
-  severity: 0.1,
-  temporalDecay: 0.1,
-  tagOverlap: 0.1,
-  domainMatch: 0.1,
-};
-
 const WEIGHT_BOUND = 0.15;
 const FEEDBACK_THRESHOLD = 30;
 const DUPLICATE_BLOCK_THRESHOLD = 0.8;
@@ -62,14 +52,12 @@ const RECENCY_HALF_LIFE_DAYS = 365;
 export class Brain {
   private vault: Vault;
   private vaultManager: VaultManager | undefined;
-  private cognee: CogneeClient | undefined;
   private vocabulary: Map<string, number> = new Map();
   private weights: ScoringWeights = { ...DEFAULT_WEIGHTS };
 
-  constructor(vault: Vault, cognee?: CogneeClient, vaultManager?: VaultManager) {
+  constructor(vault: Vault, vaultManager?: VaultManager) {
     this.vault = vault;
     this.vaultManager = vaultManager;
-    this.cognee = cognee;
     this.rebuildVocabulary();
     this.recomputeWeights();
   }
@@ -102,97 +90,6 @@ export class Brain {
       });
     }
 
-    // Cognee vector search (parallel, with timeout fallback)
-    let cogneeScoreMap: Map<string, number> = new Map();
-    const cogneeAvailable = this.cognee?.isAvailable ?? false;
-    if (cogneeAvailable && this.cognee) {
-      try {
-        const cogneeResults = await this.cognee.search(query, { limit: Math.max(limit * 2, 20) });
-
-        // Build title → entryIds reverse index from FTS results for text-based matching.
-        // Cognee assigns its own UUIDs to chunks and may strip embedded metadata during
-        // chunking, so we need multiple strategies to cross-reference results.
-        // Multiple entries can share a title, so map to arrays of IDs.
-        const titleToIds = new Map<string, string[]>();
-        for (const r of rawResults) {
-          const key = r.entry.title.toLowerCase().trim();
-          const ids = titleToIds.get(key) ?? [];
-          ids.push(r.entry.id);
-          titleToIds.set(key, ids);
-        }
-
-        const vaultIdPattern = /\[vault-id:([^\]]+)\]/;
-        const unmatchedCogneeResults: Array<{ text: string; score: number }> = [];
-
-        for (const cr of cogneeResults) {
-          const text = cr.text ?? '';
-
-          // Strategy 1: Extract vault ID from [vault-id:XXX] prefix (if Cognee preserved it)
-          const vaultIdMatch = text.match(vaultIdPattern);
-          if (vaultIdMatch) {
-            const vaultId = vaultIdMatch[1];
-            cogneeScoreMap.set(vaultId, Math.max(cogneeScoreMap.get(vaultId) ?? 0, cr.score));
-            continue;
-          }
-
-          // Strategy 2: Match first line of chunk text against known entry titles.
-          // serializeEntry() puts the title on the first line after the [vault-id:] prefix,
-          // and Cognee's chunking typically preserves this as the chunk start.
-          const firstLine = text.split('\n')[0]?.trim().toLowerCase() ?? '';
-          const matchedIds = firstLine ? titleToIds.get(firstLine) : undefined;
-          if (matchedIds) {
-            for (const id of matchedIds) {
-              cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, cr.score));
-            }
-            continue;
-          }
-
-          // Strategy 3: Check if any known title appears as a substring in the chunk.
-          // Handles cases where the title isn't on the first line (mid-document chunks).
-          const textLower = text.toLowerCase();
-          let found = false;
-          for (const [title, ids] of titleToIds) {
-            if (title.length >= 8 && textLower.includes(title)) {
-              for (const id of ids) {
-                cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, cr.score));
-              }
-              found = true;
-              break;
-            }
-          }
-          if (!found && text.length > 0) {
-            unmatchedCogneeResults.push({ text, score: cr.score });
-          }
-        }
-
-        // Strategy 4: For Cognee-only semantic matches (not in FTS results),
-        // use the first line as a vault FTS query to find the source entry.
-        // Preserve caller filters (domain/type/severity) to avoid reintroducing
-        // entries the original query excluded.
-        for (const unmatched of unmatchedCogneeResults) {
-          const searchTerm = unmatched.text.split('\n')[0]?.trim();
-          if (!searchTerm || searchTerm.length < 3) continue;
-          const vaultHits = this.vault.search(searchTerm, {
-            domain: options?.domain,
-            type: options?.type,
-            severity: options?.severity,
-            limit: 1,
-          });
-          if (vaultHits.length > 0) {
-            const id = vaultHits[0].entry.id;
-            cogneeScoreMap.set(id, Math.max(cogneeScoreMap.get(id) ?? 0, unmatched.score));
-            // Also add to FTS results pool if not already present
-            if (!rawResults.some((r) => r.entry.id === id)) {
-              rawResults.push(vaultHits[0]);
-            }
-          }
-        }
-      } catch {
-        // Cognee failed — fall back to FTS5 only
-        cogneeScoreMap = new Map();
-      }
-    }
-
     if (rawResults.length === 0) return [];
 
     const seedCount = rawResults.length;
@@ -201,22 +98,9 @@ export class Brain {
     const queryDomain = options?.domain;
     const now = Math.floor(Date.now() / 1000);
 
-    // Use cognee-aware weights only if at least one ranked candidate has a vector score
-    const hasVectorCandidate = rawResults.some((r) => cogneeScoreMap.has(r.entry.id));
-    const activeWeights = hasVectorCandidate ? this.getCogneeWeights() : this.weights;
-
     const ranked = rawResults.map((result) => {
       const entry = result.entry;
-      const vectorScore = cogneeScoreMap.get(entry.id) ?? 0;
-      const breakdown = this.scoreEntry(
-        entry,
-        queryTokens,
-        queryTags,
-        queryDomain,
-        now,
-        vectorScore,
-        activeWeights,
-      );
+      const breakdown = this.scoreEntry(entry, queryTokens, queryTags, queryDomain, now);
       return { entry, score: breakdown.total, breakdown };
     });
 
@@ -335,11 +219,6 @@ export class Brain {
     this.vault.add(fullEntry);
     this.updateVocabularyIncremental(fullEntry);
 
-    // Fire-and-forget Cognee sync
-    if (this.cognee?.isAvailable) {
-      this.cognee.addEntries([fullEntry]).catch(() => {});
-    }
-
     const result: CaptureResult = {
       captured: true,
       id: entry.id,
@@ -465,32 +344,6 @@ export class Brain {
     });
   }
 
-  async syncToCognee(): Promise<{ synced: number; cognified: boolean }> {
-    if (!this.cognee?.isAvailable) return { synced: 0, cognified: false };
-
-    const batchSize = 1000;
-    let offset = 0;
-    let totalSynced = 0;
-
-    while (true) {
-      const batch = this.vault.list({ limit: batchSize, offset });
-      if (batch.length === 0) break;
-
-      const { added } = await this.cognee.addEntries(batch);
-      totalSynced += added;
-      offset += batch.length;
-
-      if (batch.length < batchSize) break;
-    }
-
-    if (totalSynced === 0) return { synced: 0, cognified: false };
-
-    let cognified = false;
-    const cognifyResult = await this.cognee.cognify();
-    cognified = cognifyResult.status === 'ok';
-    return { synced: totalSynced, cognified };
-  }
-
   rebuildVocabulary(): void {
     // Collect entries from all connected sources when VaultManager is available
     let entries: IntelligenceEntry[];
@@ -616,10 +469,8 @@ export class Brain {
     queryTags: string[],
     queryDomain: string | undefined,
     now: number,
-    vectorScore: number = 0,
-    activeWeights?: ScoringWeights,
   ): ScoreBreakdown {
-    const w = activeWeights ?? this.weights;
+    const w = this.weights;
 
     let semantic = 0;
     if (this.vocabulary.size > 0 && queryTokens.length > 0) {
@@ -643,7 +494,7 @@ export class Brain {
 
     const domainMatch = queryDomain && entry.domain === queryDomain ? 1.0 : 0;
 
-    const vector = vectorScore;
+    const vector = 0;
 
     const total =
       w.semantic * semantic +
@@ -747,10 +598,6 @@ export class Brain {
     tx();
   }
 
-  private getCogneeWeights(): ScoringWeights {
-    return { ...COGNEE_WEIGHTS };
-  }
-
   private recomputeWeights(): void {
     const db = this.vault.getDb();
     // Exclude 'failed' from weight computation — system errors don't indicate relevance

package/src/context/context-engine.ts

@@ -3,17 +3,15 @@
  *
  * Orchestrates three signals to enrich intent classification:
  * 1. Entity extraction (regex-based, domain-agnostic)
- * 2. Knowledge retrieval (vault FTS + Cognee vector + brain recommendations)
+ * 2. Knowledge retrieval (vault FTS + brain recommendations)
  * 3. Confidence scoring (combines entity + knowledge signals)
  *
- * Graceful degradation: if Cognee is unavailable, vault-only.
  * If vault is empty, keyword confidence from IntentRouter is unchanged.
  */
 
 import type { Vault } from '../vault/vault.js';
 import type { Brain } from '../brain/brain.js';
 import type { BrainIntelligence } from '../brain/intelligence.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type {
   EntityType,
   ExtractedEntity,
@@ -105,20 +103,17 @@ export class ContextEngine {
   private vault: Vault;
   private brain: Brain;
   private brainIntelligence: BrainIntelligence;
-  private cognee: CogneeClient | null;
   private config: Required<ContextEngineConfig>;
 
   constructor(
     vault: Vault,
     brain: Brain,
     brainIntelligence: BrainIntelligence,
-    cognee: CogneeClient | null,
     config?: ContextEngineConfig,
   ) {
     this.vault = vault;
     this.brain = brain;
     this.brainIntelligence = brainIntelligence;
-    this.cognee = cognee;
     this.config = {
       vaultSearchLimit: config?.vaultSearchLimit ?? 10,
       cogneeSearchLimit: config?.cogneeSearchLimit ?? 10,
@@ -167,7 +162,6 @@ export class ContextEngine {
   async retrieveKnowledge(prompt: string, domain?: string): Promise<KnowledgeRetrievalResult> {
     const items: KnowledgeItem[] = [];
     let vaultHits = 0;
-    let cogneeHits = 0;
     let brainHits = 0;
 
     // 1. Vault FTS search
@@ -208,29 +202,7 @@ export class ContextEngine {
       // Vault search failed — continue with other sources
     }
 
-    // 2. Cognee vector search (async, graceful degradation)
-    if (this.cognee) {
-      try {
-        const cogneeResults = await this.cognee.search(prompt, {
-          limit: this.config.cogneeSearchLimit,
-        });
-        for (const r of cogneeResults) {
-          // Avoid duplicates from vault
-          if (items.some((i) => i.id === r.id)) continue;
-          items.push({
-            id: r.id,
-            title: r.text.slice(0, 100),
-            score: r.score,
-            source: 'cognee',
-          });
-          cogneeHits++;
-        }
-      } catch {
-        // Cognee unavailable — continue without
-      }
-    }
-
-    // 3. Brain recommendations
+    // 2. Brain recommendations
     try {
       const recommendations = this.brainIntelligence.recommend({
         domain,
@@ -255,7 +227,7 @@ export class ContextEngine {
     items.sort((a, b) => b.score - a.score);
     const filtered = items.filter((i) => i.score >= this.config.minScoreThreshold);
 
-    return { items: filtered, vaultHits, cogneeHits, brainHits };
+    return { items: filtered, vaultHits, cogneeHits: 0, brainHits };
   }
 
   // ─── Context Analysis ───────────────────────────────────────────

package/src/curator/curator.ts

@@ -1,6 +1,5 @@
 import type { Vault } from '../vault/vault.js';
 import type { IntelligenceEntry } from '../intelligence/types.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type { PersistenceProvider } from '../persistence/types.js';
 import {
   tokenize,
@@ -51,12 +50,10 @@ const DEFAULT_TAG_ALIASES: Array<[string, string]> = [
 
 export class Curator {
   private vault: Vault;
-  private cognee: CogneeClient | undefined;
   private provider: PersistenceProvider;
 
-  constructor(vault: Vault, cognee?: CogneeClient) {
+  constructor(vault: Vault) {
     this.vault = vault;
-    this.cognee = cognee;
     this.provider = vault.getProvider();
     this.initializeTables();
     this.seedDefaultAliases();
@@ -378,8 +375,7 @@ export class Curator {
 
   async detectContradictionsHybrid(threshold?: number): Promise<{
     contradictions: Contradiction[];
-    cogneeAvailable: boolean;
-    method: 'hybrid' | 'tfidf-only';
+    method: 'tfidf-only';
   }> {
     const effectiveThreshold = threshold ?? DEFAULT_CONTRADICTION_THRESHOLD;
     const entries = this.vault.list({ limit: 100000 });
@@ -387,14 +383,12 @@ export class Curator {
     const patterns = entries.filter((e) => e.type === 'pattern');
 
     if (antipatterns.length === 0 || patterns.length === 0) {
-      return { contradictions: [], cogneeAvailable: false, method: 'tfidf-only' };
+      return { contradictions: [], method: 'tfidf-only' };
     }
 
     const vocabulary = this.buildVocabulary(entries);
     const detected: Contradiction[] = [];
 
-    const cogneeAvailable = this.cognee?.isAvailable ?? false;
-
     for (const ap of antipatterns) {
       let candidates: IntelligenceEntry[];
       try {
@@ -410,23 +404,7 @@ export class Curator {
       for (const pattern of candidates) {
         const pText = [pattern.title, pattern.description, pattern.context ?? ''].join(' ');
         const pVec = calculateTfIdf(tokenize(pText), vocabulary);
-        const tfidfScore = cosineSimilarity(apVec, pVec);
-
-        let finalScore = tfidfScore;
-        if (cogneeAvailable && this.cognee) {
-          try {
-            const cogneeResults = await this.cognee.search(`${ap.title} ${pattern.title}`, {
-              limit: 5,
-            });
-            const cogneeScore =
-              cogneeResults.length > 0
-                ? cogneeResults.reduce((sum, r) => sum + r.score, 0) / cogneeResults.length
-                : 0;
-            finalScore = 0.6 * tfidfScore + 0.4 * cogneeScore;
-          } catch {
-            finalScore = tfidfScore;
-          }
-        }
+        const finalScore = cosineSimilarity(apVec, pVec);
 
         if (finalScore >= effectiveThreshold) {
           const result = this.provider.run(
@@ -446,8 +424,7 @@ export class Curator {
 
     return {
       contradictions: detected,
-      cogneeAvailable,
-      method: cogneeAvailable ? 'hybrid' : 'tfidf-only',
+      method: 'tfidf-only',
     };
   }
 

package/src/engine/bin/soleri-engine.ts

@@ -71,12 +71,13 @@ async function main(): Promise<void> {
     ? resolve((engineConfig.vault as string).replace(/^~/, homedir()))
     : join(homedir(), `.${agentId}`, 'vault.db');
 
-  // 3. Create runtime
+  // 3. Create runtime (with persona from agent.yaml if present)
+  const personaConfig = config.persona as Record<string, unknown> | undefined;
   const runtime = createAgentRuntime({
     agentId,
     vaultPath,
     agentDir,
-    cognee: (engineConfig.cognee as boolean) ?? false,
+    persona: personaConfig as import('../../persona/types.js').PersonaConfig | undefined,
   });
 
   console.error(`${tag} Vault: ${vaultPath}`);
@@ -175,14 +176,14 @@ async function main(): Promise<void> {
     version: '1.0.0',
   });
 
-  // 11. Register persona prompt
-  server.prompt('persona', 'Get agent persona and principles', () => ({
+  // 11. Register persona prompt (uses composable persona system)
+  server.prompt('persona', 'Get agent persona and character instructions', () => ({
     messages: [
       {
         role: 'user' as const,
         content: {
           type: 'text' as const,
-          text: `You are ${identity.name}. ${identity.role}.\n\nPrinciples:\n${identity.principles.map((p) => `- ${p}`).join('\n')}\n\nTone: ${identity.tone}`,
+          text: runtime.personaInstructions.instructions,
         },
       },
     ],

package/src/engine/core-ops.ts

@@ -101,26 +101,32 @@ export function createCoreOps(
 
         // Build activation context
         const s = runtime.vault.stats();
+        const persona = runtime.persona;
+        const personaInstructions = runtime.personaInstructions;
         return {
           activated: true,
           agent: {
             id: identity.id,
-            name: identity.name,
+            name: persona.name,
             role: identity.role,
             description: identity.description,
             format: 'filetree',
           },
           persona: {
-            tone: identity.tone,
-            principles: identity.principles,
-            greeting: identity.greeting ?? `Hello! I am ${identity.name}.`,
+            template: persona.template,
+            name: persona.name,
+            culture: persona.culture,
+            voice: persona.voice,
+            traits: persona.traits,
+            quirks: persona.quirks,
+            greeting: personaInstructions.greeting,
+            instructions: personaInstructions.instructions,
           },
           vault: {
             connected: true,
             entries: s.totalEntries,
             domains: Object.keys(s.byDomain),
           },
-          domains: identity.domains,
         };
       },
     },
@@ -162,7 +168,6 @@ export function createCoreOps(
             byType: s.byType,
           },
           engine: {
-            cognee: runtime.cognee !== null && runtime.cognee !== undefined,
             brain: true,
             curator: true,
             planner: true,

package/src/engine/module-manifest.ts

@@ -84,16 +84,10 @@ export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
     description: 'Chat transport — session management, response chunking, authentication.',
     keyOps: ['chat_send', 'chat_history', 'chat_session'],
   },
-  {
-    suffix: 'cognee',
-    description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
-    keyOps: ['cognee_search', 'cognee_add', 'cognee_cognify'],
-    conditional: true,
-  },
 ];
 
 /** Core facade ops (always present, not in ENGINE_MODULES) */
 export const CORE_KEY_OPS = ['health', 'identity', 'register', 'activate'];
 
 /** Engine major version — used for compatibility checks against domain packs. */
-export const ENGINE_MAJOR_VERSION = 8;
+export const ENGINE_MAJOR_VERSION = 9;

package/src/engine/register-engine.ts

@@ -32,7 +32,6 @@ import { createCuratorFacadeOps } from '../runtime/facades/curator-facade.js';
 import { createLoopFacadeOps } from '../runtime/facades/loop-facade.js';
 import { createOrchestrateFacadeOps } from '../runtime/facades/orchestrate-facade.js';
 import { createControlFacadeOps } from '../runtime/facades/control-facade.js';
-import { createCogneeFacadeOps } from '../runtime/facades/cognee-facade.js';
 import { createContextFacadeOps } from '../runtime/facades/context-facade.js';
 import { createAgencyFacadeOps } from '../runtime/facades/agency-facade.js';
 import { createChatFacadeOps } from '../runtime/facades/chat-facade.js';
@@ -144,12 +143,6 @@ export const ENGINE_MODULES: ModuleDef[] = [
     description: 'Chat transport — session management, response chunking, authentication.',
     createOps: createChatFacadeOps,
   },
-  {
-    suffix: 'cognee',
-    description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
-    createOps: createCogneeFacadeOps,
-    condition: (rt) => rt.cognee !== null && rt.cognee !== undefined,
-  },
 ];
 
 // ─── Core Registration ────────────────────────────────────────────────

package/src/index.ts

@@ -1,5 +1,9 @@
 // ─── Intelligence ────────────────────────────────────────────────────
-export type { IntelligenceEntry, IntelligenceBundle } from './intelligence/types.js';
+export type {
+  IntelligenceEntry,
+  IntelligenceBundle,
+  IntelligenceBundleLink,
+} from './intelligence/types.js';
 export { loadIntelligenceData, loadPacks } from './intelligence/loader.js';
 
 // ─── Vault ───────────────────────────────────────────────────────────
@@ -249,21 +253,6 @@ export type {
   BrowserToolResult,
 } from './chat/index.js';
 
-// ─── Cognee ─────────────────────────────────────────────────────────
-export { CogneeClient } from './cognee/client.js';
-export type {
-  CogneeConfig,
-  CogneeSearchResult,
-  CogneeSearchType,
-  CogneeStatus,
-  CogneeAddResult,
-  CogneeCognifyResult,
-} from './cognee/types.js';
-
-// ─── Cognee Sync ──────────────────────────────────────────────────────
-export { CogneeSyncManager } from './cognee/sync-manager.js';
-export type { SyncOp, SyncStatus, SyncQueueItem, SyncManagerStats } from './cognee/sync-manager.js';
-
 // ─── Intake Pipeline ──────────────────────────────────────────────────
 export { IntakePipeline } from './intake/intake-pipeline.js';
 export { classifyChunk, VALID_TYPES, CLASSIFICATION_PROMPT } from './intake/content-classifier.js';
@@ -489,6 +478,21 @@ export type {
   IntegrityResult,
 } from './health/index.js';
 
+// ─── Persona ──────────────────────────────────────────────────────────
+export type {
+  PersonaConfig,
+  ArchivedPersona,
+  PersonaCreateInput,
+  PersonaSystemInstructions,
+} from './persona/types.js';
+export {
+  ITALIAN_CRAFTSPERSON,
+  PERSONA_TEMPLATES,
+  createDefaultPersona,
+} from './persona/defaults.js';
+export { loadPersona } from './persona/loader.js';
+export { generatePersonaInstructions, getRandomSignoff } from './persona/prompt-generator.js';
+
 // ─── Runtime Factory ────────────────────────────────────────────────
 export { createAgentRuntime } from './runtime/runtime.js';
 export { createSemanticFacades } from './runtime/facades/index.js';

package/src/intelligence/types.ts

@@ -17,8 +17,16 @@ export interface IntelligenceEntry {
   validUntil?: number; // unix epoch — when entry expires (null = never)
 }
 
+export interface IntelligenceBundleLink {
+  sourceId: string;
+  targetId: string;
+  linkType: 'supports' | 'contradicts' | 'extends' | 'sequences';
+  note?: string;
+}
+
 export interface IntelligenceBundle {
   domain: string;
   version: string;
   entries: IntelligenceEntry[];
+  links?: IntelligenceBundleLink[];
 }