@soleri/core 8.1.0 → 9.0.0

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

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