@soleri/core 8.1.0 → 9.0.1

package/src/runtime/runtime.ts

@@ -14,7 +14,6 @@ import { BrainIntelligence } from '../brain/intelligence.js';
 import { Planner } from '../planning/planner.js';
 import { Curator } from '../curator/curator.js';
 import { Governance } from '../governance/governance.js';
-import { CogneeClient } from '../cognee/client.js';
 import { LoopManager } from '../loop/loop-manager.js';
 import { IdentityManager } from '../control/identity-manager.js';
 import { IntentRouter } from '../control/intent-router.js';
@@ -22,7 +21,6 @@ import { KeyPool, loadKeyPoolConfig } from '../llm/key-pool.js';
 import { discoverAnthropicToken } from '../llm/oauth-discovery.js';
 import { loadIntelligenceData } from '../intelligence/loader.js';
 import { LLMClient } from '../llm/llm-client.js';
-import { CogneeSyncManager } from '../cognee/sync-manager.js';
 import { IntakePipeline } from '../intake/intake-pipeline.js';
 import { TextIngester } from '../intake/text-ingester.js';
 import { Telemetry } from '../telemetry/telemetry.js';
@@ -50,6 +48,8 @@ import { PipelineRunner } from '../queue/pipeline-runner.js';
 import { evaluateQuality } from '../curator/quality-gate.js';
 import { classifyEntry } from '../curator/classifier.js';
 import type { AgentRuntimeConfig, AgentRuntime } from './types.js';
+import { loadPersona } from '../persona/loader.js';
+import { generatePersonaInstructions } from '../persona/prompt-generator.js';
 
 /**
  * Create a fully initialized agent runtime.
@@ -95,25 +95,15 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   // Planner — multi-step task tracking
   const planner = new Planner(plansPath);
 
-  // Cognee — vector search client (opt-in, graceful degradation if Cognee is down)
-  let cognee: CogneeClient | null = null;
-  if (config.cognee) {
-    const cogneePartial: Partial<import('../cognee/types.js').CogneeConfig> = { dataset: agentId };
-    if (process.env.COGNEE_BASE_URL) cogneePartial.baseUrl = process.env.COGNEE_BASE_URL;
-    if (process.env.COGNEE_API_TOKEN) cogneePartial.apiToken = process.env.COGNEE_API_TOKEN;
-    if (process.env.COGNEE_DATASET) cogneePartial.dataset = process.env.COGNEE_DATASET;
-    cognee = new CogneeClient(cogneePartial);
-  }
-
   // Brain — intelligence layer (TF-IDF scoring, auto-tagging, dedup)
   // Pass vaultManager so intelligentSearch queries all connected sources (not just agent tier)
-  const brain = new Brain(vault, cognee ?? undefined, vaultManager);
+  const brain = new Brain(vault, vaultManager);
 
   // Brain Intelligence — pattern strengths, session knowledge, intelligence pipeline
   const brainIntelligence = new BrainIntelligence(vault, brain);
 
   // Curator — vault self-maintenance (dedup, contradictions, grooming, health)
-  const curator = new Curator(vault, cognee ?? undefined);
+  const curator = new Curator(vault);
 
   // Governance — policy engine + proposal tracker for gated knowledge capture
   const governance = new Governance(vault);
@@ -152,17 +142,6 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const anthropicKeyPool = new KeyPool(anthropicConfig);
   const llmClient = new LLMClient(openaiKeyPool, anthropicKeyPool, agentId);
 
-  // Cognee Sync Manager — queue-based dirty tracking with offline resilience (only when Cognee enabled)
-  let syncManager: CogneeSyncManager | null = null;
-  if (cognee) {
-    syncManager = new CogneeSyncManager(
-      vault.getProvider(),
-      cognee,
-      process.env.COGNEE_DATASET ?? agentId,
-    );
-    vault.setSyncManager(syncManager);
-  }
-
   // Link Manager — Zettelkasten auto-linking on vault ingestion
   const linkManager = new LinkManager(vault.getProvider());
   vault.setLinkManager(linkManager, { enabled: true, maxLinks: 3 });
@@ -184,7 +163,7 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const vaultBranching = new VaultBranching(vault);
 
   // Context Engine — entity extraction, knowledge retrieval, confidence scoring
-  const contextEngine = new ContextEngine(vault, brain, brainIntelligence, cognee);
+  const contextEngine = new ContextEngine(vault, brain, brainIntelligence);
 
   // Agency Manager — proactive file watching, pattern surfacing (disabled by default)
   const agencyManager = new AgencyManager(vault);
@@ -196,10 +175,6 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
   const health = new HealthRegistry();
   health.register('vault', 'healthy');
   health.register('brain', 'healthy');
-  health.register(
-    'cognee',
-    cognee ? (cognee.getStatus()?.available ? 'healthy' : 'degraded') : 'down',
-  );
   health.register(
     'llm',
     llmClient.isAvailable().openai || llmClient.isAvailable().anthropic ? 'healthy' : 'degraded',
@@ -228,7 +203,6 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     planner,
     curator,
     governance,
-    cognee,
     loop,
     identityManager,
     intentRouter,
@@ -237,7 +211,6 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
     telemetry,
     projectRegistry,
     templateManager,
-    syncManager,
     intakePipeline,
     textIngester,
     authPolicy: { mode: 'permissive', callerLevel: 'admin' },
@@ -335,26 +308,6 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
         const result = curator.consolidate({ dryRun: false, staleDaysThreshold: 90 });
         return { archived: result.staleEntries.length, result };
       });
-      pr.registerHandler('cognee-ingest', async (job) => {
-        if (!cognee) return { skipped: true, reason: 'cognee not available' };
-        const entry = vault.get(job.entryId ?? '');
-        if (!entry) return { skipped: true, reason: 'entry not found' };
-        try {
-          const result = await cognee.addEntries([entry]);
-          return { ingested: result.added };
-        } catch {
-          return { skipped: true, reason: 'cognee ingestion failed' };
-        }
-      });
-      pr.registerHandler('cognee-cognify', async (_job) => {
-        if (!cognee) return { skipped: true, reason: 'cognee not available' };
-        try {
-          const result = await cognee.cognify();
-          return result;
-        } catch {
-          return { skipped: true, reason: 'cognee cognify failed' };
-        }
-      });
       pr.registerHandler('verify-searchable', async (job) => {
         const entry = vault.get(job.entryId ?? '');
         if (!entry) return { skipped: true, reason: 'entry not found' };
@@ -364,10 +317,17 @@ export function createAgentRuntime(config: AgentRuntimeConfig): AgentRuntime {
       });
       return pr;
     })(),
+    persona: (() => {
+      const p = loadPersona(agentId, config.persona ?? undefined);
+      logger.info(`[Persona] Loaded: ${p.name} (${p.template})`);
+      return p;
+    })(),
+    personaInstructions: (() => {
+      const p = loadPersona(agentId, config.persona ?? undefined);
+      return generatePersonaInstructions(p);
+    })(),
     createdAt: Date.now(),
     close: () => {
-      syncManager?.close();
-      cognee?.resetPendingCognify();
       vaultManager.close();
     },
   };

package/src/runtime/types.ts

@@ -4,7 +4,6 @@ import type { BrainIntelligence } from '../brain/intelligence.js';
 import type { Planner } from '../planning/planner.js';
 import type { Curator } from '../curator/curator.js';
 import type { Governance } from '../governance/governance.js';
-import type { CogneeClient } from '../cognee/client.js';
 import type { KeyPool } from '../llm/key-pool.js';
 import type { LLMClient } from '../llm/llm-client.js';
 import type { IdentityManager } from '../control/identity-manager.js';
@@ -13,7 +12,6 @@ import type { LoopManager } from '../loop/loop-manager.js';
 import type { Telemetry } from '../telemetry/telemetry.js';
 import type { ProjectRegistry } from '../project/project-registry.js';
 import type { TemplateManager } from '../prompts/template-manager.js';
-import type { CogneeSyncManager } from '../cognee/sync-manager.js';
 import type { IntakePipeline } from '../intake/intake-pipeline.js';
 import type { Logger } from '../logging/logger.js';
 import type { LogLevel } from '../logging/types.js';
@@ -55,10 +53,10 @@ export interface AgentRuntimeConfig {
   logLevel?: LogLevel;
   /** Path to shared global vault. Default: ~/.soleri/vault.db */
   sharedVaultPath?: string;
-  /** Enable Cognee vector search integration. Default: false (opt-in). */
-  cognee?: boolean;
   /** Path to the agent's root directory (containing agent.yaml, instructions/, etc.). Optional — set by engine binary. */
   agentDir?: string;
+  /** Persona configuration from agent.yaml. If omitted, Italian Craftsperson default is used. */
+  persona?: Partial<import('../persona/types.js').PersonaConfig>;
 }
 
 /**
@@ -74,8 +72,6 @@ export interface AgentRuntime {
   planner: Planner;
   curator: Curator;
   governance: Governance;
-  /** Cognee vector search client. Null when Cognee integration is disabled. */
-  cognee: CogneeClient | null;
   loop: LoopManager;
   identityManager: IdentityManager;
   intentRouter: IntentRouter;
@@ -84,8 +80,6 @@ export interface AgentRuntime {
   telemetry: Telemetry;
   projectRegistry: ProjectRegistry;
   templateManager: TemplateManager;
-  /** Cognee sync manager. Null when Cognee integration is disabled. */
-  syncManager: CogneeSyncManager | null;
   intakePipeline: IntakePipeline;
   /** Mutable auth policy — controls facade dispatch enforcement. */
   authPolicy: AuthPolicy;
@@ -123,6 +117,10 @@ export interface AgentRuntime {
   jobQueue: JobQueue;
   /** Pipeline runner — background polling loop for job execution. */
   pipelineRunner: PipelineRunner;
+  /** Agent persona — defines character, voice, and cultural texture. */
+  persona: import('../persona/types.js').PersonaConfig;
+  /** Generated persona system instructions for LLM context. */
+  personaInstructions: import('../persona/types.js').PersonaSystemInstructions;
   /** Timestamp (ms since epoch) when this runtime was created. */
   createdAt: number;
   /** Close the vault database connection. Call on shutdown. */

package/src/runtime/vault-linking-ops.ts

@@ -400,6 +400,47 @@ export function createVaultLinkingOps(runtime: AgentRuntime): OpDefinition[] {
         };
       },
     },
+    {
+      name: 'backfill_links',
+      description:
+        'Generate Zettelkasten links for orphan entries using FTS5 suggestions. One-time backfill for vaults with entries but no links.',
+      auth: 'write',
+      schema: z.object({
+        threshold: z.coerce
+          .number()
+          .min(0)
+          .max(1)
+          .default(0.7)
+          .describe('Min suggestion score to create link (default: 0.7)'),
+        maxLinks: z.coerce
+          .number()
+          .int()
+          .min(1)
+          .max(10)
+          .default(3)
+          .describe('Max links per entry (default: 3)'),
+        dryRun: z.boolean().optional().default(false).describe('Preview without creating links'),
+        batchSize: z.coerce
+          .number()
+          .int()
+          .min(1)
+          .max(200)
+          .default(50)
+          .describe('Entries per batch (default: 50)'),
+      }),
+      handler: async (params) => {
+        const result = linkManager.backfillLinks({
+          threshold: params.threshold as number,
+          maxLinks: params.maxLinks as number,
+          dryRun: params.dryRun as boolean,
+          batchSize: params.batchSize as number,
+        });
+        return {
+          ...result,
+          ...(result.preview ? { previewSample: result.preview.slice(0, 20) } : {}),
+        };
+      },
+    },
     {
       name: 'link_stats',
       description:

package/src/runtime/vault-sharing-ops.ts

@@ -13,7 +13,12 @@ import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import { detectScope, type ScopeInput } from '../vault/scope-detector.js';
 import { GitVaultSync, type GitVaultSyncConfig } from '../vault/git-vault-sync.js';
-import type { IntelligenceEntry, IntelligenceBundle } from '../intelligence/types.js';
+import type {
+  IntelligenceEntry,
+  IntelligenceBundle,
+  IntelligenceBundleLink,
+} from '../intelligence/types.js';
+import { LinkManager } from '../vault/linking.js';
 
 export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
   const { vault, knowledgeReview } = runtime;
@@ -147,10 +152,38 @@ export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
           byDomain.get(d)!.push(entry);
         }
 
+        // Collect links for exported entries (Zettelkasten edge export)
+        const entryIds = new Set(entries.map((e) => e.id));
+        const linkManager = new LinkManager(vault.getProvider());
+        const allLinks = linkManager.getAllLinksForEntries([...entryIds]);
+        // Only include links where BOTH endpoints are in the export set
+        const exportLinks = allLinks.filter(
+          (l) => entryIds.has(l.sourceId) && entryIds.has(l.targetId),
+        );
+
+        // Build a domain→links map (group by source entry's domain)
+        const entryDomainMap = new Map(entries.map((e) => [e.id, e.domain]));
+        const linksByDomain = new Map<string, IntelligenceBundleLink[]>();
+        for (const link of exportLinks) {
+          const linkDomain = entryDomainMap.get(link.sourceId) ?? 'unknown';
+          if (!linksByDomain.has(linkDomain)) linksByDomain.set(linkDomain, []);
+          linksByDomain.get(linkDomain)!.push({
+            sourceId: link.sourceId,
+            targetId: link.targetId,
+            linkType: link.linkType,
+            note: link.note,
+          });
+        }
+
         const version = (params.version as string) ?? '1.0.0';
         const bundles: IntelligenceBundle[] = [];
         for (const [d, domainEntries] of byDomain) {
-          bundles.push({ domain: d, version, entries: domainEntries });
+          bundles.push({
+            domain: d,
+            version,
+            entries: domainEntries,
+            links: linksByDomain.get(d) ?? [],
+          });
         }
 
         return {
@@ -158,6 +191,7 @@ export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
           version,
           bundles,
           totalEntries: entries.length,
+          totalLinks: exportLinks.length,
           domains: [...byDomain.keys()],
         };
       },
@@ -187,10 +221,17 @@ export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
           domain: string;
           version: string;
           entries: IntelligenceEntry[];
+          links?: IntelligenceBundleLink[];
         }>;
         const forceTier = params.tier as 'agent' | 'project' | 'team' | undefined;
         let imported = 0;
         let duplicates = 0;
+        let linksCreated = 0;
+        let linksSkipped = 0;
+
+        // Track ID remapping: bundle entry ID → actual vault entry ID
+        const idRemap = new Map<string, string>();
+        const linkManager = new LinkManager(vault.getProvider());
 
         for (const bundle of bundles) {
           const entries = bundle.entries.map((e) => ({
@@ -198,13 +239,31 @@ export function createVaultSharingOps(runtime: AgentRuntime): OpDefinition[] {
             tier: forceTier ?? e.tier ?? 'project',
           }));
           const results = vault.seedDedup(entries);
-          for (const r of results) {
+          for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            const originalId = bundle.entries[i].id;
+            // For duplicates, map to the existing vault entry; for inserts, keep original ID
+            idRemap.set(originalId, r.existingId ?? r.id);
             if (r.action === 'inserted') imported++;
             else duplicates++;
           }
+
+          // Import links if present
+          if (bundle.links && bundle.links.length > 0) {
+            for (const link of bundle.links) {
+              const sourceId = idRemap.get(link.sourceId);
+              const targetId = idRemap.get(link.targetId);
+              if (sourceId && targetId) {
+                linkManager.addLink(sourceId, targetId, link.linkType, link.note);
+                linksCreated++;
+              } else {
+                linksSkipped++;
+              }
+            }
+          }
         }
 
-        return { imported, duplicates, total: imported + duplicates };
+        return { imported, duplicates, linksCreated, linksSkipped, total: imported + duplicates };
       },
     },
 

package/src/vault/linking.ts

@@ -169,6 +169,28 @@ export class LinkManager {
     return result;
   }
 
+  // ===========================================================================
+  // BULK QUERIES
+  // ===========================================================================
+
+  /**
+   * Get all links where either source or target is in the given ID set.
+   * Used for pack export — to find links within an export set.
+   */
+  getAllLinksForEntries(entryIds: string[]): VaultLink[] {
+    if (entryIds.length === 0) return [];
+    try {
+      const placeholders = entryIds.map(() => '?').join(',');
+      const rows = this.provider.all<VaultLinkRow>(
+        `SELECT * FROM vault_links WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`,
+        [...entryIds, ...entryIds],
+      );
+      return rows.map(rowToVaultLink);
+    } catch {
+      return [];
+    }
+  }
+
   // ===========================================================================
   // ORPHAN DETECTION
   // ===========================================================================
@@ -292,6 +314,78 @@ export class LinkManager {
     }
   }
 
+  // ===========================================================================
+  // BACKFILL — one-time link generation for existing entries
+  // ===========================================================================
+
+  /**
+   * Generate links for orphan entries using FTS5 suggestions.
+   * Processes orphans in batches and creates links above the threshold.
+   *
+   * @param opts.threshold    Minimum suggestion score to auto-create link (default: 0.7)
+   * @param opts.maxLinks     Max links per entry (default: 3)
+   * @param opts.dryRun       Preview without creating links (default: false)
+   * @param opts.batchSize    Entries per batch (default: 50)
+   * @param opts.onProgress   Progress callback
+   * @returns Stats: processed, linksCreated, durationMs
+   */
+  backfillLinks(opts?: {
+    threshold?: number;
+    maxLinks?: number;
+    dryRun?: boolean;
+    batchSize?: number;
+    onProgress?: (stats: { processed: number; total: number; linksCreated: number }) => void;
+  }): {
+    processed: number;
+    linksCreated: number;
+    durationMs: number;
+    preview?: Array<{ sourceId: string; targetId: string; linkType: string; score: number }>;
+  } {
+    const threshold = opts?.threshold ?? 0.7;
+    const maxLinks = opts?.maxLinks ?? 3;
+    const dryRun = opts?.dryRun ?? false;
+    const batchSize = opts?.batchSize ?? 50;
+    const start = Date.now();
+
+    const orphans = this.getOrphans(10000);
+    let processed = 0;
+    let linksCreated = 0;
+    const preview: Array<{ sourceId: string; targetId: string; linkType: string; score: number }> =
+      [];
+
+    for (let i = 0; i < orphans.length; i += batchSize) {
+      const batch = orphans.slice(i, i + batchSize);
+      for (const entry of batch) {
+        const suggestions = this.suggestLinks(entry.id, maxLinks + 2);
+        const qualifying = suggestions.filter((s) => s.score >= threshold).slice(0, maxLinks);
+
+        for (const s of qualifying) {
+          if (dryRun) {
+            preview.push({
+              sourceId: entry.id,
+              targetId: s.entryId,
+              linkType: s.suggestedType,
+              score: s.score,
+            });
+          } else {
+            this.addLink(entry.id, s.entryId, s.suggestedType);
+          }
+          linksCreated++;
+        }
+        processed++;
+      }
+
+      opts?.onProgress?.({ processed, total: orphans.length, linksCreated });
+    }
+
+    return {
+      processed,
+      linksCreated,
+      durationMs: Date.now() - start,
+      ...(dryRun ? { preview } : {}),
+    };
+  }
+
   // ===========================================================================
   // PRIVATE
   // ===========================================================================

package/src/vault/vault.ts

@@ -52,7 +52,6 @@ export interface MemoryStats {
 export class Vault {
   private provider: PersistenceProvider;
   private sqliteProvider: SQLitePersistenceProvider | null;
-  private syncManager: import('../cognee/sync-manager.js').CogneeSyncManager | null = null;
   private linkManager: LinkManager | null = null;
   private autoLinkEnabled = true;
   /** Minimum number of FTS5 suggestions to auto-link. Top N are linked. */
@@ -104,10 +103,6 @@ export class Vault {
     // current < FORMAT_VERSION → future: run migration scripts here
   }
 
-  setSyncManager(mgr: import('../cognee/sync-manager.js').CogneeSyncManager): void {
-    this.syncManager = mgr;
-  }
-
   setLinkManager(mgr: LinkManager, opts?: { enabled?: boolean; maxLinks?: number }): void {
     this.linkManager = mgr;
     if (opts?.enabled !== undefined) this.autoLinkEnabled = opts.enabled;
@@ -414,9 +409,6 @@ export class Vault {
           origin: entry.origin ?? 'agent',
         });
         count++;
-        if (this.syncManager) {
-          this.syncManager.enqueue('ingest', entry.id, entry);
-        }
       }
       // Auto-link after all entries are inserted (so they can link to each other).
       // Skip for large batches (>100) — use relink_vault for bulk imports.
@@ -608,9 +600,6 @@ export class Vault {
   }
   remove(id: string): boolean {
     const deleted = this.provider.run('DELETE FROM entries WHERE id = ?', [id]).changes > 0;
-    if (deleted && this.syncManager) {
-      this.syncManager.enqueue('delete', id);
-    }
     return deleted;
   }
 
@@ -684,9 +673,6 @@ export class Vault {
       let count = 0;
       for (const id of ids) {
         count += this.provider.run('DELETE FROM entries WHERE id = ?', [id]).changes;
-        if (this.syncManager) {
-          this.syncManager.enqueue('delete', id);
-        }
       }
       return count;
     });