@almadar/agent 1.1.3 → 1.1.4

package/dist/index.js

@@ -5,7 +5,7 @@ import { exec, spawn } from 'child_process';
 import * as path from 'path';
 import { promisify } from 'util';
 import * as fs4 from 'fs/promises';
-import { isStructuredOutputAvailable, getStructuredOutputClient, LLMClient, ANTHROPIC_MODELS, createAnthropicClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
+import { isStructuredOutputAvailable, getStructuredOutputClient, LLMClient, createRequirementsClient, ANTHROPIC_MODELS, createAnthropicClient, OPENAI_MODELS, createOpenAIClient, DEEPSEEK_MODELS, createDeepSeekClient } from '@almadar/llm';
 import * as domain_language_star from '@almadar/core/domain-language';
 import * as fs3 from 'fs';
 import crypto, { randomUUID } from 'crypto';
@@ -4693,10 +4693,30 @@ ${skillSummaries}
 
 ${skillContents}`;
   }
+  let userPreferences = null;
+  let projectContext = null;
+  if (options.memoryManager && options.userId) {
+    try {
+      userPreferences = await options.memoryManager.getUserPreferences(options.userId);
+      if (userPreferences && verbose) {
+        console.log(`[SkillAgent] Loaded user preferences: ${userPreferences.namingConvention} naming, ${userPreferences.preferredPatterns.length} patterns`);
+      }
+      if (options.appId) {
+        projectContext = await options.memoryManager.getProjectContext(options.appId);
+        if (projectContext && verbose) {
+          console.log(`[SkillAgent] Loaded project context: ${projectContext.existingEntities.length} entities`);
+        }
+      }
+    } catch (error) {
+      console.warn("[SkillAgent] Failed to load memory:", error);
+    }
+  }
+  const memoryContext = buildMemoryContext(userPreferences, projectContext);
   const systemPrompt = [
     BASE_SYSTEM_PROMPT,
     "\n## Skill Instructions\n\n" + skillInstructions,
-    references ? "\n## Reference Documentation\n\n" + references : ""
+    references ? "\n## Reference Documentation\n\n" + references : "",
+    memoryContext ? "\n## User Context\n\n" + memoryContext : ""
   ].filter(Boolean).join("\n");
   const threadId = providedThreadId || v4();
   const llmClient = createLLMClient(provider, model, verbose);
@@ -4799,9 +4819,54 @@ ${skillContents}`;
     workDir,
     setOrbitalEventCallback,
     setOrbitalCompleteCallback,
-    setDomainCompleteCallback
+    setDomainCompleteCallback,
+    userPreferences,
+    projectContext,
+    memoryManager: options.memoryManager
   };
 }
+function buildMemoryContext(userPreferences, projectContext) {
+  const sections = [];
+  if (userPreferences) {
+    const prefs = [];
+    if (userPreferences.namingConvention) {
+      prefs.push(`- Preferred naming: ${userPreferences.namingConvention}`);
+    }
+    if (userPreferences.validationStyle) {
+      prefs.push(`- Validation style: ${userPreferences.validationStyle}`);
+    }
+    if (userPreferences.preferredPatterns.length > 0) {
+      prefs.push(`- Preferred patterns: ${userPreferences.preferredPatterns.join(", ")}`);
+    }
+    if (userPreferences.commonEntities.length > 0) {
+      prefs.push(`- Commonly used entities: ${userPreferences.commonEntities.join(", ")}`);
+    }
+    if (prefs.length > 0) {
+      sections.push(`### User Preferences
+${prefs.join("\n")}`);
+    }
+  }
+  if (projectContext) {
+    const ctx = [];
+    if (projectContext.projectName) {
+      ctx.push(`- Project: ${projectContext.projectName}`);
+    }
+    if (projectContext.domain) {
+      ctx.push(`- Domain: ${projectContext.domain}`);
+    }
+    if (projectContext.existingEntities.length > 0) {
+      ctx.push(`- Existing entities: ${projectContext.existingEntities.join(", ")}`);
+    }
+    if (projectContext.conventions.length > 0) {
+      ctx.push(`- Project conventions: ${projectContext.conventions.join(", ")}`);
+    }
+    if (ctx.length > 0) {
+      sections.push(`### Project Context
+${ctx.join("\n")}`);
+    }
+  }
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
 async function resumeSkillAgent(threadId, options) {
   const sessions = options.sessionManager ?? getDefaultSessionManager();
   const metadata = sessions.get(threadId);
@@ -5310,11 +5375,602 @@ function extractFileOperation(event) {
   }
   return null;
 }
+
+// src/memory/memory-orbital.ts
+var UserPreferenceEntity = {
+  name: "UserPreference",
+  persistence: "persistent",
+  fields: [
+    { name: "id", type: "string", required: true },
+    { name: "userId", type: "string", required: true },
+    { name: "namingConvention", type: "enum", values: ["PascalCase", "camelCase", "snake_case"], default: "PascalCase" },
+    { name: "validationStyle", type: "enum", values: ["strict", "minimal", "none"], default: "strict" },
+    { name: "preferredPatterns", type: "array", items: { name: "pattern", type: "string" }, default: [] },
+    { name: "commonEntities", type: "array", items: { name: "entity", type: "string" }, default: [] },
+    { name: "commonTraits", type: "array", items: { name: "trait", type: "string" }, default: [] },
+    { name: "learnedAt", type: "timestamp" },
+    { name: "confidence", type: "number", default: 0.5 }
+  ]
+};
+var GenerationSessionEntity = {
+  name: "GenerationSession",
+  persistence: "persistent",
+  fields: [
+    { name: "id", type: "string", required: true },
+    { name: "userId", type: "string", required: true },
+    { name: "threadId", type: "string", required: true },
+    { name: "prompt", type: "string", required: true },
+    { name: "skill", type: "string", required: true },
+    { name: "entities", type: "array", items: { name: "entity", type: "string" }, default: [] },
+    { name: "patterns", type: "array", items: { name: "pattern", type: "string" }, default: [] },
+    { name: "createdAt", type: "timestamp", required: true },
+    { name: "completedAt", type: "timestamp" },
+    { name: "success", type: "boolean", default: false }
+  ]
+};
+var ProjectContextEntity = {
+  name: "ProjectContext",
+  persistence: "persistent",
+  fields: [
+    { name: "id", type: "string", required: true },
+    { name: "appId", type: "string", required: true },
+    { name: "userId", type: "string", required: true },
+    { name: "projectName", type: "string" },
+    { name: "description", type: "string" },
+    { name: "existingEntities", type: "array", items: { name: "entity", type: "string" }, default: [] },
+    { name: "conventions", type: "array", items: { name: "convention", type: "string" }, default: [] },
+    { name: "domain", type: "enum", values: ["business", "ecommerce", "cms", "dashboard", "workflow"], default: "business" },
+    { name: "lastUpdatedAt", type: "timestamp", required: true }
+  ]
+};
+var MemoryOrbitalSchema = {
+  name: "AgentMemory",
+  version: "1.0.0",
+  description: "Memory system for KFlow DeepAgent - stores user preferences, generation history, and project context",
+  orbitals: [
+    {
+      name: "UserPreferenceMemory",
+      entity: UserPreferenceEntity,
+      traits: [],
+      pages: []
+    },
+    {
+      name: "GenerationHistoryMemory",
+      entity: GenerationSessionEntity,
+      traits: [],
+      pages: []
+    },
+    {
+      name: "ProjectContextMemory",
+      entity: ProjectContextEntity,
+      traits: [],
+      pages: []
+    }
+  ]
+};
+
+// src/memory/MemoryManager.ts
+var MemoryManager = class {
+  constructor(options) {
+    this.db = options.db;
+    this.usersCollection = options.usersCollection ?? "agent_memory_users";
+    this.generationsCollection = options.generationsCollection ?? "agent_memory_generations";
+    this.projectsCollection = options.projectsCollection ?? "agent_memory_projects";
+    this.patternsCollection = options.patternsCollection ?? "agent_memory_patterns";
+    this.feedbackCollection = options.feedbackCollection ?? "agent_memory_feedback";
+  }
+  // ============================================================================
+  // User Preferences
+  // ============================================================================
+  /**
+   * Get user preferences with defaults
+   */
+  async getUserPreferences(userId) {
+    const doc = await this.db.collection(this.usersCollection).doc(userId).get();
+    if (!doc.exists) return null;
+    return this.parsePreference(doc.data());
+  }
+  /**
+   * Update user preferences
+   */
+  async updateUserPreferences(userId, preferences) {
+    const existing = await this.getUserPreferences(userId);
+    const merged = {
+      id: existing?.id ?? `pref_${Date.now()}`,
+      userId,
+      namingConvention: preferences.namingConvention ?? existing?.namingConvention ?? "PascalCase",
+      validationStyle: preferences.validationStyle ?? existing?.validationStyle ?? "strict",
+      preferredPatterns: [
+        ...existing?.preferredPatterns ?? [],
+        ...preferences.preferredPatterns ?? []
+      ],
+      commonEntities: [
+        ...existing?.commonEntities ?? [],
+        ...preferences.commonEntities ?? []
+      ],
+      commonTraits: [
+        ...existing?.commonTraits ?? [],
+        ...preferences.commonTraits ?? []
+      ],
+      learnedAt: existing?.learnedAt ?? /* @__PURE__ */ new Date(),
+      confidence: preferences.confidence ?? existing?.confidence ?? 0.5
+    };
+    await this.db.collection(this.usersCollection).doc(userId).set(this.serializePreference(merged));
+  }
+  // ============================================================================
+  // Generation Session History
+  // ============================================================================
+  /**
+   * Record a new generation session
+   */
+  async recordGeneration(userId, session) {
+    const sessionId = `gen_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const fullSession = {
+      id: sessionId,
+      userId,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...session
+    };
+    await this.db.collection(this.generationsCollection).doc(sessionId).set(this.serializeSession(fullSession));
+    return sessionId;
+  }
+  /**
+   * Get a specific generation session
+   */
+  async getGenerationSession(sessionId) {
+    const doc = await this.db.collection(this.generationsCollection).doc(sessionId).get();
+    if (!doc.exists) return null;
+    return this.parseSession(doc.data());
+  }
+  /**
+   * Get generation history for a user
+   */
+  async getUserGenerationHistory(userId, limit = 50) {
+    const snapshot = await this.db.collection(this.generationsCollection).where("userId", "==", userId).orderBy("createdAt", "desc").limit(limit).get();
+    return snapshot.docs.map((doc) => this.parseSession(doc.data()));
+  }
+  /**
+   * Update generation session status
+   */
+  async updateGenerationStatus(sessionId, status, validationResult) {
+    const doc = await this.db.collection(this.generationsCollection).doc(sessionId).get();
+    if (!doc.exists) return;
+    const data = doc.data();
+    await this.db.collection(this.generationsCollection).doc(sessionId).set({
+      ...data,
+      success: status,
+      completedAt: /* @__PURE__ */ new Date(),
+      ...validationResult && { validationResult }
+    });
+  }
+  // ============================================================================
+  // Project Context
+  // ============================================================================
+  /**
+   * Get project context
+   */
+  async getProjectContext(appId) {
+    const doc = await this.db.collection(this.projectsCollection).doc(appId).get();
+    if (!doc.exists) return null;
+    return this.parseContext(doc.data());
+  }
+  /**
+   * Update project context with new information
+   */
+  async updateProjectContext(appId, update) {
+    const existing = await this.getProjectContext(appId);
+    if (!existing) {
+      if (!update.userId) {
+        throw new Error("userId is required when creating new project context");
+      }
+      const newContext = {
+        id: `ctx_${Date.now()}`,
+        appId,
+        userId: update.userId,
+        existingEntities: update.existingEntities ?? [],
+        conventions: update.conventions ?? [],
+        domain: update.domain ?? "business",
+        lastUpdatedAt: /* @__PURE__ */ new Date(),
+        ...update.projectName && { projectName: update.projectName },
+        ...update.description && { description: update.description }
+      };
+      await this.db.collection(this.projectsCollection).doc(appId).set(this.serializeContext(newContext));
+      return;
+    }
+    const merged = {
+      ...existing,
+      existingEntities: [
+        ...existing.existingEntities,
+        ...update.existingEntities ?? []
+      ],
+      conventions: [
+        ...existing.conventions,
+        ...update.conventions ?? []
+      ],
+      lastUpdatedAt: /* @__PURE__ */ new Date(),
+      ...update.projectName && { projectName: update.projectName },
+      ...update.description && { description: update.description },
+      ...update.domain && { domain: update.domain }
+    };
+    await this.db.collection(this.projectsCollection).doc(appId).set(this.serializeContext(merged));
+  }
+  // ============================================================================
+  // Pattern Affinity
+  // ============================================================================
+  /**
+   * Update pattern affinity based on usage
+   */
+  async updatePatternAffinity(userId, patternId, outcome, context) {
+    const affinityId = `${userId}_${patternId}`;
+    const existing = await this.db.collection(this.patternsCollection).doc(affinityId).get();
+    if (!existing.exists) {
+      const affinity = {
+        userId,
+        patternId,
+        usageCount: 1,
+        successCount: outcome === "success" ? 1 : 0,
+        failureCount: outcome === "failure" ? 1 : 0,
+        contexts: context ? [context] : [],
+        lastUsedAt: /* @__PURE__ */ new Date(),
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      await this.db.collection(this.patternsCollection).doc(affinityId).set(affinity);
+    } else {
+      const data = existing.data();
+      const affinity = {
+        ...data,
+        usageCount: data.usageCount + 1,
+        successCount: data.successCount + (outcome === "success" ? 1 : 0),
+        failureCount: data.failureCount + (outcome === "failure" ? 1 : 0),
+        contexts: context ? [...data.contexts ?? [], context] : data.contexts,
+        lastUsedAt: /* @__PURE__ */ new Date()
+      };
+      await this.db.collection(this.patternsCollection).doc(affinityId).set(affinity);
+    }
+  }
+  /**
+   * Get pattern affinity for a user
+   */
+  async getPatternAffinity(userId, patternId) {
+    const affinityId = `${userId}_${patternId}`;
+    const doc = await this.db.collection(this.patternsCollection).doc(affinityId).get();
+    if (!doc.exists) return null;
+    return doc.data();
+  }
+  /**
+   * Get all patterns used by a user
+   */
+  async getUserPatterns(userId) {
+    const snapshot = await this.db.collection(this.patternsCollection).where("userId", "==", userId).orderBy("usageCount", "desc").get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  // ============================================================================
+  // User Feedback
+  // ============================================================================
+  /**
+   * Record user feedback on a generation
+   */
+  async recordFeedback(sessionId, feedback) {
+    const feedbackId = `fb_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const fullFeedback = {
+      feedbackId,
+      sessionId,
+      ...feedback,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    await this.db.collection(this.feedbackCollection).doc(feedbackId).set(fullFeedback);
+  }
+  /**
+   * Get feedback for a session
+   */
+  async getSessionFeedback(sessionId) {
+    const snapshot = await this.db.collection(this.feedbackCollection).where("sessionId", "==", sessionId).orderBy("timestamp", "desc").get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  // ============================================================================
+  // Serialization Helpers
+  // ============================================================================
+  parsePreference(data) {
+    const timestampToDate = (ts) => {
+      if (ts instanceof Date) return ts;
+      if (typeof ts === "object" && ts !== null && "toDate" in ts) {
+        return ts.toDate();
+      }
+      return new Date(ts);
+    };
+    return {
+      id: data.id,
+      userId: data.userId,
+      namingConvention: data.namingConvention,
+      validationStyle: data.validationStyle,
+      preferredPatterns: data.preferredPatterns ?? [],
+      commonEntities: data.commonEntities ?? [],
+      commonTraits: data.commonTraits ?? [],
+      learnedAt: timestampToDate(data.learnedAt),
+      confidence: data.confidence ?? 0.5
+    };
+  }
+  serializePreference(pref) {
+    return { ...pref };
+  }
+  parseSession(data) {
+    const timestampToDate = (ts) => {
+      if (ts instanceof Date) return ts;
+      if (typeof ts === "object" && ts !== null && "toDate" in ts) {
+        return ts.toDate();
+      }
+      return new Date(ts);
+    };
+    return {
+      id: data.id,
+      userId: data.userId,
+      threadId: data.threadId,
+      prompt: data.prompt,
+      skill: data.skill,
+      generatedSchema: data.generatedSchema,
+      entities: data.entities ?? [],
+      patterns: data.patterns ?? [],
+      validationResult: data.validationResult,
+      createdAt: timestampToDate(data.createdAt),
+      completedAt: data.completedAt ? timestampToDate(data.completedAt) : void 0,
+      success: data.success
+    };
+  }
+  serializeSession(session) {
+    return { ...session };
+  }
+  parseContext(data) {
+    const timestampToDate = (ts) => {
+      if (ts instanceof Date) return ts;
+      if (typeof ts === "object" && ts !== null && "toDate" in ts) {
+        return ts.toDate();
+      }
+      return new Date(ts);
+    };
+    return {
+      id: data.id,
+      appId: data.appId,
+      userId: data.userId,
+      projectName: data.projectName,
+      description: data.description,
+      existingEntities: data.existingEntities ?? [],
+      conventions: data.conventions ?? [],
+      domain: data.domain,
+      lastUpdatedAt: timestampToDate(data.lastUpdatedAt)
+    };
+  }
+  serializeContext(context) {
+    return { ...context };
+  }
+};
+var PreferenceLearner = class {
+  constructor(options) {
+    this.llmClient = options.llmClient ?? createRequirementsClient();
+    this.memoryManager = options.memoryManager;
+    this.confidenceThreshold = options.confidenceThreshold ?? 0.7;
+  }
+  /**
+   * Analyze a session and infer user preferences
+   */
+  async analyzeSession(session) {
+    const prompt = this.buildAnalysisPrompt(session);
+    const content = await this.llmClient.call({
+      systemPrompt: "You analyze generation sessions and infer user preferences. Respond with JSON.",
+      userPrompt: prompt
+    });
+    return this.parseAnalysisResponse(content);
+  }
+  /**
+   * Learn from a session and update preferences if confidence is high
+   */
+  async learnFromSession(session) {
+    let preferences = await this.memoryManager.getUserPreferences(session.userId);
+    if (!preferences) {
+      preferences = {
+        id: session.userId,
+        userId: session.userId,
+        namingConvention: "PascalCase",
+        validationStyle: "strict",
+        preferredPatterns: [],
+        commonEntities: [],
+        commonTraits: [],
+        learnedAt: /* @__PURE__ */ new Date(),
+        confidence: 0.5
+      };
+    }
+    const analysis = await this.analyzeSession(session);
+    let updated = false;
+    for (const inference of analysis.inferences) {
+      if (inference.confidence >= this.confidenceThreshold) {
+        switch (inference.field) {
+          case "namingConvention":
+            if (this.isValidNamingConvention(inference.value)) {
+              preferences.namingConvention = inference.value;
+              updated = true;
+            }
+            break;
+          case "validationStyle":
+            if (this.isValidValidationStyle(inference.value)) {
+              preferences.validationStyle = inference.value;
+              updated = true;
+            }
+            break;
+          case "preferredPatterns":
+            if (Array.isArray(inference.value)) {
+              preferences.preferredPatterns = [
+                .../* @__PURE__ */ new Set([...preferences.preferredPatterns, ...inference.value])
+              ].slice(0, 10);
+              updated = true;
+            }
+            break;
+          case "commonEntities":
+            if (Array.isArray(inference.value)) {
+              preferences.commonEntities = [
+                .../* @__PURE__ */ new Set([...preferences.commonEntities, ...inference.value])
+              ].slice(0, 20);
+              updated = true;
+            }
+            break;
+        }
+      }
+    }
+    if (updated) {
+      preferences.confidence = Math.min(1, preferences.confidence + 0.05);
+      await this.memoryManager.updateUserPreferences(session.userId, preferences);
+    }
+    return updated ? preferences : null;
+  }
+  /**
+   * Batch learn from multiple sessions
+   */
+  async batchLearn(sessions) {
+    if (sessions.length === 0) return null;
+    const userId = sessions[0].userId;
+    let preferences = await this.memoryManager.getUserPreferences(userId);
+    if (!preferences) {
+      preferences = {
+        id: userId,
+        userId,
+        namingConvention: "PascalCase",
+        validationStyle: "strict",
+        preferredPatterns: [],
+        commonEntities: [],
+        commonTraits: [],
+        learnedAt: /* @__PURE__ */ new Date(),
+        confidence: 0.5
+      };
+    }
+    const allPatterns = /* @__PURE__ */ new Set();
+    const allEntities = /* @__PURE__ */ new Set();
+    for (const session of sessions) {
+      session.patterns.forEach((p) => allPatterns.add(p));
+      session.entities.forEach((e) => allEntities.add(e));
+    }
+    preferences.preferredPatterns = [...allPatterns].slice(0, 10);
+    preferences.commonEntities = [...allEntities].slice(0, 20);
+    preferences.confidence = Math.min(1, 0.5 + sessions.length * 0.05);
+    const aggregatePrompt = this.buildAggregatePrompt(sessions);
+    const content = await this.llmClient.call({
+      systemPrompt: "You analyze generation sessions and infer user preferences. Respond with JSON.",
+      userPrompt: aggregatePrompt
+    });
+    const analysis = this.parseAnalysisResponse(content);
+    for (const inference of analysis.inferences) {
+      if (inference.confidence >= this.confidenceThreshold) {
+        if (inference.field === "namingConvention" && this.isValidNamingConvention(inference.value)) {
+          preferences.namingConvention = inference.value;
+        }
+        if (inference.field === "validationStyle" && this.isValidValidationStyle(inference.value)) {
+          preferences.validationStyle = inference.value;
+        }
+      }
+    }
+    await this.memoryManager.updateUserPreferences(userId, preferences);
+    return preferences;
+  }
+  // ==========================================================================
+  // Prompt Building
+  // ==========================================================================
+  buildAnalysisPrompt(session) {
+    return `Analyze this generation session and infer the user's preferences.
+
+Session Details:
+- Prompt: "${session.prompt}"
+- Generated Entities: ${session.entities.join(", ")}
+- Used Patterns: ${session.patterns.join(", ")}
+- Skill: ${session.skill}
+
+Schema Excerpt:
+${JSON.stringify(session.generatedSchema, null, 2).slice(0, 2e3)}
+
+Analyze and infer:
+1. Naming convention preference (PascalCase, camelCase, snake_case)
+2. Validation style (strict, minimal, none)
+3. Preferred UI patterns
+4. Common entity types
+
+Respond in JSON format:
+{
+  "inferences": [
+    {
+      "field": "namingConvention",
+      "value": "PascalCase",
+      "confidence": 0.85,
+      "reasoning": "User consistently uses PascalCase for entity names"
+    }
+  ],
+  "isHighConfidence": true
+}`;
+  }
+  buildAggregatePrompt(sessions) {
+    const summaries = sessions.slice(0, 10).map((s) => ({
+      prompt: s.prompt.slice(0, 100),
+      entities: s.entities,
+      patterns: s.patterns
+    }));
+    return `Analyze these ${sessions.length} generation sessions and infer the user's aggregate preferences.
+
+Session Summaries:
+${JSON.stringify(summaries, null, 2)}
+
+Infer the user's overall:
+1. Naming convention preference (PascalCase, camelCase, snake_case)
+2. Validation style (strict, minimal, none)
+
+Respond in JSON format:
+{
+  "inferences": [
+    {
+      "field": "namingConvention",
+      "value": "PascalCase",
+      "confidence": 0.9,
+      "reasoning": "Used PascalCase in 8 out of 10 sessions"
+    }
+  ],
+  "isHighConfidence": true
+}`;
+  }
+  // ==========================================================================
+  // Response Parsing
+  // ==========================================================================
+  parseAnalysisResponse(content) {
+    try {
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        return { inferences: [], isHighConfidence: false };
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (Array.isArray(parsed.inferences)) {
+        return {
+          inferences: parsed.inferences.filter(
+            (inf) => inf.field && inf.value !== void 0 && typeof inf.confidence === "number"
+          ),
+          isHighConfidence: parsed.isHighConfidence ?? false
+        };
+      }
+      return { inferences: [], isHighConfidence: false };
+    } catch {
+      return { inferences: [], isHighConfidence: false };
+    }
+  }
+  // ==========================================================================
+  // Validation Helpers
+  // ==========================================================================
+  isValidNamingConvention(value) {
+    return typeof value === "string" && ["PascalCase", "camelCase", "snake_case"].includes(value);
+  }
+  isValidValidationStyle(value) {
+    return typeof value === "string" && ["strict", "minimal", "none"].includes(value);
+  }
+};
+function createPreferenceLearner(options) {
+  return new PreferenceLearner(options);
+}
 var export_applySectionUpdate = domain_language_exports.applySectionUpdate;
 var export_convertDomainToSchema = domain_language_exports.convertDomainToSchema;
 var export_convertSchemaToDomain = domain_language_exports.convertSchemaToDomain;
 var export_deleteSection = domain_language_exports.deleteSection;
 
-export { ContinueRequestSchema, DEFAULT_COMPACTION_CONFIG, EVENT_BUDGETS, ExtractedRequirementsSchema, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, GenerateRequestSchema, MemorySessionBackend, MetricsCollector, ResumeRequestSchema, SessionManager, analyzeFailures, export_applySectionUpdate as applySectionUpdate, combineOrbitals, combineOrbitalsToSchema, export_convertDomainToSchema as convertDomainToSchema, export_convertSchemaToDomain as convertSchemaToDomain, createAgentTools, createApplyChunkTool, createCombineSchemasTool, createCompactSystemPrompt, createConstructCombinedDomainTool, createDomainOrbitalTools, createErrorFixerSubagent, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createOrbitalSubagentTool, createQuerySchemaStructureTool, createSSEEvent, createSchemaChunkingTools, createSchemaGeneratorSubagent, createSkillAgent, createSubagentConfigs, createSubagentEventWrapper, createSubagents, createSummaryPrompt, createSystemPrompt, createTestAnalyzerSubagent, createTraitEventWrapper, createTraitSubagentTool, createValidateSchemaTool, export_deleteSection as deleteSection, estimateCacheSavings, estimateCombineComplexity, estimateTokens, extractFileOperation, extractInterruptData, formatSSEEvent, formatSummary, generateFullOrbital, getBudgetWarningMessage, getEventBudget, getInterruptConfig, hasInterrupt, isCompleteEvent, isErrorEvent, isExecutionEvent, isFileOperation, isSSECompleteEvent, isSSEErrorEvent, isSSEGenerationLogEvent, isSSEInterruptEvent, isSSEMessageEvent, isSSEStartEvent, isSSESubagentEvent, isSSETodoDetailEvent, isSSETodoUpdateEvent, isSSEToolCallEvent, isSchemaEvent, isStartEvent, isTodoUpdate, needsCompaction, parseDeepAgentEvent, parseSSEEvent, resumeSkillAgent, transformAgentEvent, transformAgentEventMulti, validateCommandPaths };
+export { ContinueRequestSchema, DEFAULT_COMPACTION_CONFIG, EVENT_BUDGETS, ExtractedRequirementsSchema, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, GenerateRequestSchema, MemoryManager, MemoryOrbitalSchema, MemorySessionBackend, MetricsCollector, PreferenceLearner, ResumeRequestSchema, SessionManager, analyzeFailures, export_applySectionUpdate as applySectionUpdate, combineOrbitals, combineOrbitalsToSchema, export_convertDomainToSchema as convertDomainToSchema, export_convertSchemaToDomain as convertSchemaToDomain, createAgentTools, createApplyChunkTool, createCombineSchemasTool, createCompactSystemPrompt, createConstructCombinedDomainTool, createDomainOrbitalTools, createErrorFixerSubagent, createExecuteTool, createExtractChunkTool, createFinishTaskTool, createGenerateOrbitalDomainTool, createGenerateSchemaTool, createOrbitalSubagentTool, createPreferenceLearner, createQuerySchemaStructureTool, createSSEEvent, createSchemaChunkingTools, createSchemaGeneratorSubagent, createSkillAgent, createSubagentConfigs, createSubagentEventWrapper, createSubagents, createSummaryPrompt, createSystemPrompt, createTestAnalyzerSubagent, createTraitEventWrapper, createTraitSubagentTool, createValidateSchemaTool, export_deleteSection as deleteSection, estimateCacheSavings, estimateCombineComplexity, estimateTokens, extractFileOperation, extractInterruptData, formatSSEEvent, formatSummary, generateFullOrbital, getBudgetWarningMessage, getEventBudget, getInterruptConfig, hasInterrupt, isCompleteEvent, isErrorEvent, isExecutionEvent, isFileOperation, isSSECompleteEvent, isSSEErrorEvent, isSSEGenerationLogEvent, isSSEInterruptEvent, isSSEMessageEvent, isSSEStartEvent, isSSESubagentEvent, isSSETodoDetailEvent, isSSETodoUpdateEvent, isSSEToolCallEvent, isSchemaEvent, isStartEvent, isTodoUpdate, needsCompaction, parseDeepAgentEvent, parseSSEEvent, resumeSkillAgent, transformAgentEvent, transformAgentEventMulti, validateCommandPaths };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map