@soleri/core 2.11.0 → 7.0.0

package/src/runtime/capture-ops.ts

@@ -136,6 +136,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                     counterExample: entry.counterExample,
                     why: entry.why,
                     tier: finalTier,
+                    origin: 'user',
                   });
                   const scopeMeta = scopeResult
                     ? {
@@ -227,7 +228,44 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
           }
         }
 
-        return { captured, proposed, rejected, duplicated, results };
+        // Auto-suggest links for captured entries (Zettelkasten enrichment)
+        let suggestedLinks: Array<{
+          entryId: string;
+          title: string;
+          suggestedType: string;
+          score: number;
+        }> = [];
+        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) => ({
+                  entryId: s.entryId,
+                  title: s.title,
+                  suggestedType: s.suggestedType,
+                  score: s.score,
+                }));
+            }
+          }
+        } catch {
+          /* never break capture for suggestions */
+        }
+
+        return {
+          captured,
+          proposed,
+          rejected,
+          duplicated,
+          results,
+          ...(suggestedLinks.length > 0 ? { suggestedLinks } : {}),
+        };
       },
     },
 
@@ -307,6 +345,7 @@ export function createCaptureOps(runtime: AgentRuntime): OpDefinition[] {
                   description,
                   tags,
                   tier: finalTier,
+                  origin: 'user',
                 });
                 if (captureResult.blocked) {
                   return {

package/src/runtime/domain-ops.ts

@@ -1,13 +1,18 @@
 /**
- * Domain facade factory — creates the standard 5-op domain facade pattern.
+ * Domain facade factory — creates domain facades with optional pack support.
  *
- * Every domain gets: get_patterns, search, get_entry, capture, remove.
- * This replaces per-domain generated facade files.
+ * Without packs: every domain gets the standard 5 ops (get_patterns, search,
+ * get_entry, capture, remove).
+ *
+ * With packs: pack ops are PRIMARY, standard 5 ops are FALLBACK for any op
+ * name not defined by the pack. Pack standalone facades are registered as
+ * additional MCP tools.
  */
 
 import { z } from 'zod';
 import type { FacadeConfig, OpDefinition } from '../facades/types.js';
 import type { AgentRuntime } from './types.js';
+import type { DomainPack } from '../domain-packs/types.js';
 
 function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1);
@@ -59,11 +64,30 @@ export function createDomainFacade(
         limit: z.number().optional(),
       }),
       handler: async (params) => {
-        return brain.intelligentSearch(params.query as string, {
+        const limit = (params.limit as number) ?? 10;
+        const results = await brain.intelligentSearch(params.query as string, {
           domain,
           tags: params.tags as string[] | undefined,
-          limit: (params.limit as number) ?? 10,
+          limit,
         });
+        // Fallback: when brain returns empty, try vault FTS directly
+        if (results.length === 0) {
+          const ftsResults = vault.search(params.query as string, { domain, limit });
+          return ftsResults.map((r) => ({
+            entry: r.entry,
+            score: 0,
+            breakdown: {
+              semantic: 0,
+              vector: 0,
+              severity: 0,
+              temporalDecay: 0,
+              tagOverlap: 0,
+              domainMatch: 0,
+              total: 0,
+            },
+          }));
+        }
+        return results;
       },
     },
     {
@@ -181,16 +205,77 @@ export function createDomainFacade(
 }
 
 /**
- * Create domain facades for all domains.
+ * Create domain facades for all domains, with optional pack support.
+ *
+ * When packs are provided:
+ * - For each domain, check if any pack claims it via pack.domains[]
+ * - If a pack claims the domain: pack ops are PRIMARY, standard 5 ops are
+ *   FALLBACK (only for op names not defined by the pack)
+ * - Pack standalone facades (pack.facades[]) are registered as additional
+ *   MCP tools with agentId prefix
+ * - Domains not claimed by any pack get the standard 5 ops (OCP)
+ *
+ * When packs is undefined or empty: identical to previous behavior.
  *
  * @param runtime - The agent runtime
  * @param agentId - Agent identifier
  * @param domains - Array of domain names
+ * @param packs - Optional array of loaded domain packs
  */
 export function createDomainFacades(
   runtime: AgentRuntime,
   agentId: string,
   domains: string[],
+  packs?: DomainPack[],
 ): FacadeConfig[] {
-  return domains.map((d) => createDomainFacade(runtime, agentId, d));
+  // Build a map: domain name → pack that claims it
+  const packByDomain = new Map<string, DomainPack>();
+  if (packs) {
+    for (const pack of packs) {
+      for (const domain of pack.domains) {
+        packByDomain.set(domain, pack);
+      }
+    }
+  }
+
+  // Create domain facades (with pack merge when applicable)
+  const domainFacades = domains.map((domain) => {
+    const pack = packByDomain.get(domain);
+    if (!pack) {
+      // No pack claims this domain — standard 5-op facade (OCP)
+      return createDomainFacade(runtime, agentId, domain);
+    }
+
+    // Pack claims this domain — merge ops
+    const standardFacade = createDomainFacade(runtime, agentId, domain);
+    const packOpNames = new Set(pack.ops.map((op) => op.name));
+
+    // Pack ops are primary; standard ops are fallback for unclaimed names
+    const mergedOps: OpDefinition[] = [
+      ...pack.ops,
+      ...standardFacade.ops.filter((op) => !packOpNames.has(op.name)),
+    ];
+
+    return {
+      ...standardFacade,
+      ops: mergedOps,
+    };
+  });
+
+  // Collect standalone facades from packs (prefixed with agentId)
+  const standaloneFacades: FacadeConfig[] = [];
+  if (packs) {
+    for (const pack of packs) {
+      if (pack.facades) {
+        for (const facade of pack.facades) {
+          standaloneFacades.push({
+            ...facade,
+            name: `${agentId}_${facade.name}`,
+          });
+        }
+      }
+    }
+  }
+
+  return [...domainFacades, ...standaloneFacades];
 }

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

@@ -11,7 +11,9 @@ import type { CogneeSearchType } from '../../cognee/types.js';
 import { createCogneeSyncOps } from '../cognee-sync-ops.js';
 
 export function createCogneeFacadeOps(runtime: AgentRuntime): OpDefinition[] {
-  const { cognee, vault, syncManager } = runtime;
+  // Only called when runtime.cognee is non-null (guarded in createSemanticFacades)
+  const cognee = runtime.cognee!;
+  const { vault, syncManager } = runtime;
 
   return [
     // ─── Cognee (inline from core-ops.ts) ───────────────────────

package/src/runtime/facades/index.ts

@@ -22,7 +22,7 @@ import { createAgencyFacadeOps } from './agency-facade.js';
 import { createChatFacadeOps } from './chat-facade.js';
 
 export function createSemanticFacades(runtime: AgentRuntime, agentId: string): FacadeConfig[] {
-  return [
+  const facades: FacadeConfig[] = [
     {
       name: `${agentId}_vault`,
       description: 'Knowledge management — search, CRUD, import/export, intake, archival.',
@@ -69,11 +69,6 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
       description: 'Agent behavior — identity, intent routing, morphing, guidelines, governance.',
       ops: createControlFacadeOps(runtime),
     },
-    {
-      name: `${agentId}_cognee`,
-      description: 'Knowledge graph — Cognee search, sync, export, graph stats.',
-      ops: createCogneeFacadeOps(runtime),
-    },
     {
       name: `${agentId}_context`,
       description: 'Context analysis — entity extraction, knowledge retrieval, confidence scoring.',
@@ -92,4 +87,15 @@ export function createSemanticFacades(runtime: AgentRuntime, agentId: string): F
       ops: createChatFacadeOps(runtime),
     },
   ];
+
+  // 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/facades/vault-facade.ts

@@ -12,6 +12,7 @@ import { createVaultExtraOps } from '../vault-extra-ops.js';
 import { createCaptureOps } from '../capture-ops.js';
 import { createIntakeOps } from '../intake-ops.js';
 import { createVaultSharingOps } from '../vault-sharing-ops.js';
+import { createVaultLinkingOps } from '../vault-linking-ops.js';
 import { ObsidianSync } from '../../vault/obsidian-sync.js';
 
 export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
@@ -479,5 +480,6 @@ export function createVaultFacadeOps(runtime: AgentRuntime): OpDefinition[] {
     ...createCaptureOps(runtime),
     ...createIntakeOps(intakePipeline),
     ...createVaultSharingOps(runtime),
+    ...createVaultLinkingOps(runtime),
   ];
 }