@soleri/core 8.1.0 → 9.0.1

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/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',

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/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;
 }