@soleri/core 8.0.0 → 9.0.0

package/src/runtime/capture-ops.ts

@@ -228,34 +228,52 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
           }
         }
 
-        // Auto-suggest links for captured entries (Zettelkasten enrichment)
-        let suggestedLinks: Array<{
+        // Auto-link captured entries (Zettelkasten enrichment)
+        // Creates links for suggestions above threshold; returns remaining as suggestions
+        const AUTO_LINK_THRESHOLD = 0.7;
+        const AUTO_LINK_MAX = 3;
+        let autoLinkedCount = 0;
+        const suggestedLinks: Array<{
           entryId: string;
           title: string;
           suggestedType: string;
           score: number;
+          autoLinked: boolean;
         }> = [];
         try {
           if (captured > 0) {
-            const firstCaptured = results.find((r) => r.action === 'capture');
-            if (firstCaptured) {
-              const { LinkManager } = await import('../vault/linking.js');
-              const lm = new LinkManager(vault.getProvider());
-              const suggestions = lm.suggestLinks(firstCaptured.id, 3);
-              suggestedLinks = suggestions
-                .filter(
-                  (s) => s.entryId !== firstCaptured.id && !s.entryId.endsWith(firstCaptured.id),
-                )
-                .map((s) => ({
+            const { LinkManager } = await import('../vault/linking.js');
+            const lm = new LinkManager(vault.getProvider());
+
+            // Process ALL captured entries, not just the first
+            const capturedEntries = results.filter((r) => r.action === 'capture');
+            for (const capturedEntry of capturedEntries) {
+              const suggestions = lm.suggestLinks(capturedEntry.id, AUTO_LINK_MAX + 2);
+              const filtered = suggestions.filter(
+                (s) => s.entryId !== capturedEntry.id && !s.entryId.endsWith(capturedEntry.id),
+              );
+
+              let linkedForThisEntry = 0;
+              for (const s of filtered) {
+                const aboveThreshold = s.score >= AUTO_LINK_THRESHOLD;
+                const canAutoLink = aboveThreshold && linkedForThisEntry < AUTO_LINK_MAX;
+                if (canAutoLink) {
+                  lm.addLink(capturedEntry.id, s.entryId, s.suggestedType);
+                  linkedForThisEntry++;
+                  autoLinkedCount++;
+                }
+                suggestedLinks.push({
                   entryId: s.entryId,
                   title: s.title,
                   suggestedType: s.suggestedType,
                   score: s.score,
-                }));
+                  autoLinked: canAutoLink,
+                });
+              }
             }
           }
         } catch {
-          /* never break capture for suggestions */
+          /* never break capture for linking failures */
         }
 
         return {
@@ -263,6 +281,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
           proposed,
           rejected,
           duplicated,
+          autoLinkedCount,
           results,
           ...(suggestedLinks.length > 0 ? { suggestedLinks } : {}),
         };

package/src/runtime/claude-md-helpers.ts

@@ -9,7 +9,6 @@
  */
 
 import type { AgentRuntimeConfig } from './types.js';
-import type { OpDefinition } from '../facades/types.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
 
@@ -198,7 +197,7 @@ const ENGINE_RULES_END = '<!-- /soleri:engine-rules -->';
 /**
  * Check if engine rules are present in content.
  */
-export function hasEngineRules(content: string): boolean {
+function hasEngineRules(content: string): boolean {
   return content.includes(ENGINE_RULES_START) && content.includes(ENGINE_RULES_END);
 }
 
@@ -217,20 +216,3 @@ export function injectEngineRulesBlock(content: string, engineRulesContent: stri
   // Append
   return content.trimEnd() + '\n\n' + engineRulesContent + '\n';
 }
-
-/**
- * Extract facade summaries from an ops array (for tools table generation).
- */
-export function extractFacadeSummaries(
-  agentId: string,
-  opsMap: Map<string, OpDefinition[]>,
-): FacadeSummary[] {
-  const summaries: FacadeSummary[] = [];
-  for (const [suffix, ops] of opsMap) {
-    summaries.push({
-      name: `${agentId}_${suffix}`,
-      ops: ops.map((o) => o.name),
-    });
-  }
-  return summaries;
-}

package/src/runtime/facades/admin-facade.ts

@@ -58,8 +58,7 @@ export function createAdminFacadeOps(runtime: AgentRuntime): OpDefinition[] {
       }),
       handler: async (params) => {
         return llmClient.complete({
-          provider: 'openai',
-          model: (params.model as string) ?? '',
+          model: (params.model as string) || undefined,
           systemPrompt: params.systemPrompt as string,
           userPrompt: params.userPrompt as string,
           temperature: params.temperature as number | undefined,

package/src/runtime/facades/index.ts

@@ -1,5 +1,5 @@
 /**
- * Semantic facade assembler — creates 10 domain-specific facades
+ * Semantic facade assembler — creates domain-specific facades
  * matching Salvador's engine-level architecture.
  *
  * Each facade becomes its own MCP tool with op dispatch.
@@ -16,7 +16,6 @@ import { createCuratorFacadeOps } from './curator-facade.js';
 import { createLoopFacadeOps } from './loop-facade.js';
 import { createOrchestrateFacadeOps } from './orchestrate-facade.js';
 import { createControlFacadeOps } from './control-facade.js';
-import { createCogneeFacadeOps } from './cognee-facade.js';
 import { createContextFacadeOps } from './context-facade.js';
 import { createAgencyFacadeOps } from './agency-facade.js';
 import { createChatFacadeOps } from './chat-facade.js';
@@ -88,14 +87,5 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
     },
   ];
 
-  // Cognee facade — only registered when Cognee integration is enabled
-  if (runtime.cognee) {
-    facades.push({
-      name: `${agentId}_cognee`,
-      description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
-      ops: createCogneeFacadeOps(runtime),
-    });
-  }
-
   return facades;
 }

package/src/runtime/pack-ops.ts

@@ -8,6 +8,16 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 
+export type HotRegisterTool = (toolName: string, description: string, ops: OpDefinition[]) => void;
+
+/** Mutable slot — set after engine registration to enable hot reload. */
+let _hotRegister: HotRegisterTool | null = null;
+
+/** Set the hot-register callback after registerEngine() completes. */
+export function setHotRegister(fn: HotRegisterTool): void {
+  _hotRegister = fn;
+}
+
 export function createPackOps(runtime: AgentRuntime): OpDefinition[] {
   const { packInstaller } = runtime;
 
@@ -36,7 +46,22 @@ export function createPackOps(runtime: AgentRuntime): OpDefinition[] {
         packDir: z.string().describe('Path to the knowledge pack directory.'),
       }),
       handler: async (params) => {
-        return packInstaller.install(params.packDir as string, runtime);
+        const result = await packInstaller.install(params.packDir as string, runtime);
+        // Hot register facades as MCP tools if callback available
+        if (_hotRegister && result.installed && result.facades > 0) {
+          const plugin = runtime.pluginRegistry.get(result.id);
+          if (plugin?.facades) {
+            for (const facade of plugin.facades) {
+              _hotRegister(
+                `${runtime.config.agentId}_${facade.name}`,
+                facade.description,
+                facade.ops,
+              );
+            }
+          }
+          (result as unknown as Record<string, unknown>).hotReloaded = true;
+        }
+        return result;
       },
     },
 

package/src/runtime/plugin-ops.ts

@@ -8,6 +8,7 @@ import { z } from 'zod';
 import type { OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
 import { loadPlugins, validateDependencies, sortByDependencies } from '../plugins/index.js';
+import { createPackRuntime } from '../domain-packs/pack-runtime.js';
 
 export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]): OpDefinition[] {
   const { pluginRegistry, config } = runtime;
@@ -157,6 +158,7 @@ export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]):
           if (!plugin) return { error: `Plugin not found: ${pluginId}` };
 
           const result = await pluginRegistry.activate(pluginId, {
+            packRuntime: createPackRuntime(runtime),
             runtime,
             manifest: plugin.manifest,
             directory: plugin.directory,
@@ -179,6 +181,7 @@ export function createPluginOps(runtime: AgentRuntime, opSink?: OpDefinition[]):
         const results = await Promise.all(
           pending.map(async (plugin) => {
             const activated = await pluginRegistry.activate(plugin.id, {
+              packRuntime: createPackRuntime(runtime),
               runtime,
               manifest: plugin.manifest,
               directory: plugin.directory,

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/session-briefing.ts

@@ -42,6 +42,20 @@ export function createSessionBriefingOps(runtime: AgentRuntime): OpDefinition[]
         const sections: BriefingSection[] = [];
         let dataPoints = 0;
 
+        // 0. Day-one welcome (vault has few non-playbook entries)
+        try {
+          const stats = vault.stats();
+          const nonPlaybook = stats.totalEntries - (stats.byType?.playbook ?? 0);
+          if (nonPlaybook < 10) {
+            sections.push({
+              label: 'Welcome',
+              content: `Vault has ${nonPlaybook} knowledge entries. Capture patterns as you work — the brain learns from every session. Use op:capture_knowledge to persist insights.`,
+            });
+          }
+        } catch {
+          // Vault stats unavailable — skip
+        }
+
         // 1. Last session
         try {
           const sessions = brainIntelligence.listSessions({ limit: 1, active: false });

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

@@ -328,13 +328,11 @@ export function createVaultLinkingOps(runtime: AgentRuntime): OpDefinition[] {
 
           try {
             const result = await llmClient.complete({
-              provider: llmClient.isAvailable().anthropic ? 'anthropic' : 'openai',
-              model: llmClient.isAvailable().anthropic ? 'claude-sonnet-4-20250514' : 'gpt-4o-mini',
               systemPrompt: EVAL_SYSTEM_PROMPT,
               userPrompt: pairsText,
               maxTokens: 2000,
-              caller: 'relink_vault',
-              task: 'link-evaluation',
+              caller: 'vault-linking',
+              task: 'evaluate-links',
             });
             llmCalls++;
 
@@ -402,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 };
       },
     },