@almadar/agent 1.1.4 → 1.2.1

package/dist/index.js

@@ -18,6 +18,7 @@ import { MemorySaver } from '@langchain/langgraph';
 export { Command } from '@langchain/langgraph';
 import { v4 } from 'uuid';
 import { BaseCheckpointSaver, BaseStore } from '@langchain/langgraph-checkpoint';
+import { EventEmitter } from 'events';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -4431,9 +4432,13 @@ var SessionManager = class {
   constructor(options = {}) {
     this.firestoreCheckpointer = null;
     this.firestoreSessionStore = null;
+    this.memoryManager = null;
+    this.compactionConfig = null;
     this.mode = options.mode ?? "memory";
     this.memoryBackend = new MemorySessionBackend();
     this.memoryCheckpointers = /* @__PURE__ */ new Map();
+    this.memoryManager = options.memoryManager ?? null;
+    this.compactionConfig = options.compactionConfig ?? null;
     if (this.mode === "firestore" && options.firestoreDb) {
       this.firestoreCheckpointer = new FirestoreCheckpointer({ db: options.firestoreDb });
       this.firestoreSessionStore = new FirestoreSessionStore({ db: options.firestoreDb });
@@ -4533,6 +4538,260 @@ var SessionManager = class {
     }
     return this.memoryBackend.list();
   }
+  // ============================================================================
+  // Session → Memory Sync (GAP-002D)
+  // ============================================================================
+  /**
+   * Sync a completed session to orbital memory.
+   * This enables the agent to learn from past sessions.
+   *
+   * @param threadId - The session thread ID
+   * @param userId - The user ID for memory association
+   * @param sessionData - Additional session data to record
+   * @returns Promise that resolves when sync is complete
+   */
+  async syncSessionToMemory(threadId, userId, sessionData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping session sync");
+      return;
+    }
+    const metadata = this.get(threadId);
+    if (!metadata) {
+      console.warn(`[SessionManager] Session ${threadId} not found, skipping sync`);
+      return;
+    }
+    try {
+      await this.memoryManager.recordGeneration(userId, {
+        threadId,
+        prompt: sessionData.inputDescription,
+        skill: metadata.skill,
+        generatedSchema: sessionData.generatedOrbital ? { name: sessionData.generatedOrbital } : void 0,
+        patterns: sessionData.patternsUsed ?? [],
+        entities: sessionData.entities ?? [],
+        success: sessionData.success,
+        completedAt: /* @__PURE__ */ new Date()
+      });
+      if (sessionData.patternsUsed && sessionData.patternsUsed.length > 0) {
+        await this.memoryManager.updateUserPreferences(userId, {
+          preferredPatterns: sessionData.patternsUsed,
+          commonEntities: sessionData.entities
+        });
+      }
+      if (sessionData.entities && sessionData.entities.length > 0) {
+        await this.memoryManager.updateProjectContext(sessionData.appId, {
+          userId,
+          existingEntities: sessionData.entities
+        });
+      }
+      console.log(`[SessionManager] Session ${threadId} synced to memory for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to sync session to memory:", error);
+    }
+  }
+  // ============================================================================
+  // Interrupt → Memory Sync (GAP-003: Interrupt Memory)
+  // ============================================================================
+  /**
+   * Record an interrupt decision to memory.
+   * This enables learning from HITL (Human-in-the-Loop) decisions.
+   *
+   * @param sessionId - The session thread ID
+   * @param userId - The user who made the decision
+   * @param interruptData - The interrupt decision data
+   * @returns Promise that resolves when sync is complete
+   */
+  async recordInterruptDecision(sessionId, userId, interruptData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping interrupt sync");
+      return;
+    }
+    try {
+      await this.memoryManager.recordInterruptDecision(sessionId, userId, interruptData);
+      console.log(`[SessionManager] Interrupt recorded for user ${userId}: ${interruptData.toolName} ${interruptData.decision}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record interrupt:", error);
+    }
+  }
+  /**
+   * Get interrupt history for a session.
+   */
+  async getSessionInterrupts(sessionId) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getSessionInterrupts(sessionId);
+  }
+  /**
+   * Check if a tool should be auto-approved for a user.
+   */
+  async shouldAutoApproveTool(userId, toolName) {
+    if (!this.memoryManager) {
+      return false;
+    }
+    return this.memoryManager.shouldAutoApproveTool(userId, toolName);
+  }
+  // ============================================================================
+  // Checkpoint Management (GAP-004: Checkpoint → Memory)
+  // ============================================================================
+  /**
+   * Record a checkpoint to memory for learning.
+   *
+   * @param userId - The user who owns this checkpoint
+   * @param checkpointData - Checkpoint information
+   * @returns Promise that resolves when checkpoint is recorded
+   */
+  async recordCheckpoint(userId, checkpointData) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping checkpoint record");
+      return;
+    }
+    try {
+      await this.memoryManager.recordCheckpoint(userId, checkpointData);
+      console.log(`[SessionManager] Checkpoint ${checkpointData.checkpointId} recorded for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record checkpoint:", error);
+    }
+  }
+  /**
+   * Record a rollback to a checkpoint.
+   *
+   * @param userId - The user who performed the rollback
+   * @param checkpointId - The checkpoint rolled back to
+   * @param reason - Optional reason for rollback
+   * @returns Promise that resolves when rollback is recorded
+   */
+  async recordRollback(userId, checkpointId, reason) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping rollback record");
+      return;
+    }
+    try {
+      await this.memoryManager.recordRollback(userId, checkpointId, reason);
+      console.log(`[SessionManager] Rollback to ${checkpointId} recorded for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record rollback:", error);
+    }
+  }
+  /**
+   * Mark a checkpoint as successful (terminal state).
+   *
+   * @param userId - The user who owns this checkpoint
+   * @param checkpointId - The checkpoint that was successful
+   * @returns Promise that resolves when success is recorded
+   */
+  async markCheckpointSuccessful(userId, checkpointId) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping success mark");
+      return;
+    }
+    try {
+      await this.memoryManager.markCheckpointSuccessful(userId, checkpointId);
+      console.log(`[SessionManager] Checkpoint ${checkpointId} marked as successful for user ${userId}`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to mark checkpoint as successful:", error);
+    }
+  }
+  /**
+   * Get checkpoint history for a thread.
+   *
+   * @param threadId - The thread to get checkpoints for
+   * @returns Array of checkpoint records
+   */
+  async getThreadCheckpoints(threadId) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getThreadCheckpoints(threadId);
+  }
+  /**
+   * Get frequently rolled-back checkpoints (problem areas).
+   *
+   * @param userId - The user to get problem checkpoints for
+   * @param minRollbackCount - Minimum rollback count (default: 2)
+   * @returns Array of checkpoint records with rollback issues
+   */
+  async getProblemCheckpoints(userId, minRollbackCount = 2) {
+    if (!this.memoryManager) {
+      return [];
+    }
+    return this.memoryManager.getProblemCheckpoints(userId, minRollbackCount);
+  }
+  // ============================================================================
+  // Context Compaction (GAP-005)
+  // ============================================================================
+  /**
+   * Get the context compaction configuration.
+   * @returns The compaction configuration or null if not configured.
+   */
+  getCompactionConfig() {
+    return this.compactionConfig;
+  }
+  /**
+   * Check if a session's messages need compaction based on token count.
+   * Uses character-based estimation for quick checks.
+   *
+   * @param messages - Array of messages to check
+   * @returns True if compaction is recommended
+   */
+  shouldCompactMessages(messages) {
+    if (!this.compactionConfig) {
+      return false;
+    }
+    const totalChars = messages.reduce((sum, msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return sum + content.length;
+    }, 0);
+    const estimatedTokens = totalChars / 4;
+    const threshold = this.compactionConfig.maxTokens ?? 15e4;
+    return estimatedTokens > threshold * 0.8;
+  }
+  /**
+   * Record a compaction event for a session.
+   * This helps track when and why compaction occurs.
+   *
+   * @param threadId - The session thread ID
+   * @param originalMessageCount - Number of messages before compaction
+   * @param compactedMessageCount - Number of messages after compaction
+   * @param reason - Reason for compaction
+   */
+  async recordCompaction(threadId, originalMessageCount, compactedMessageCount, reason) {
+    if (!this.memoryManager) {
+      console.warn("[SessionManager] No memory manager configured, skipping compaction record");
+      return;
+    }
+    try {
+      const metadata = this.get(threadId);
+      if (metadata) {
+        const compactionInfo = {
+          timestamp: Date.now(),
+          originalMessageCount,
+          compactedMessageCount,
+          reason: reason ?? "token_limit"
+        };
+        const meta = metadata;
+        const existingCompactions = meta.compactions ?? [];
+        meta.compactions = [...existingCompactions, compactionInfo];
+        this.store(threadId, metadata);
+      }
+      console.log(`[SessionManager] Compaction recorded for ${threadId}: ${originalMessageCount} \u2192 ${compactedMessageCount} messages`);
+    } catch (error) {
+      console.error("[SessionManager] Failed to record compaction:", error);
+    }
+  }
+  /**
+   * Get compaction history for a session.
+   *
+   * @param threadId - The session thread ID
+   * @returns Array of compaction events
+   */
+  getCompactionHistory(threadId) {
+    const metadata = this.get(threadId);
+    if (!metadata) {
+      return [];
+    }
+    const meta = metadata;
+    return meta.compactions ?? [];
+  }
 };
 
 // src/agent/interrupt-config.ts
@@ -5458,6 +5717,9 @@ var MemoryManager = class {
     this.projectsCollection = options.projectsCollection ?? "agent_memory_projects";
     this.patternsCollection = options.patternsCollection ?? "agent_memory_patterns";
     this.feedbackCollection = options.feedbackCollection ?? "agent_memory_feedback";
+    this.interruptsCollection = options.interruptsCollection ?? "agent_memory_interrupts";
+    this.toolPreferencesCollection = options.toolPreferencesCollection ?? "agent_memory_tool_preferences";
+    this.checkpointsCollection = options.checkpointsCollection ?? "agent_memory_checkpoints";
   }
   // ============================================================================
   // User Preferences
@@ -5742,6 +6004,178 @@ var MemoryManager = class {
   serializeContext(context) {
     return { ...context };
   }
+  // ============================================================================
+  // Interrupt Tracking (GAP-003: Interrupt Memory)
+  // ============================================================================
+  /**
+   * Record an interrupt decision for learning
+   */
+  async recordInterruptDecision(sessionId, userId, interruptData) {
+    const interruptId = `int_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const record = {
+      interruptId,
+      sessionId,
+      userId,
+      toolName: interruptData.toolName,
+      toolArgs: interruptData.toolArgs,
+      decision: interruptData.decision,
+      modifiedArgs: interruptData.modifiedArgs,
+      reason: interruptData.reason,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    await this.db.collection(this.interruptsCollection).doc(interruptId).set(record);
+    await this.updateToolApprovalPreference(userId, interruptData.toolName, interruptData.decision);
+  }
+  /**
+   * Get interrupt history for a session
+   */
+  async getSessionInterrupts(sessionId) {
+    const snapshot = await this.db.collection(this.interruptsCollection).where("sessionId", "==", sessionId).orderBy("timestamp", "desc").get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Get interrupt history for a user
+   */
+  async getUserInterrupts(userId, limit = 50) {
+    const snapshot = await this.db.collection(this.interruptsCollection).where("userId", "==", userId).orderBy("timestamp", "desc").limit(limit).get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Get tool approval preference for a user
+   */
+  async getToolApprovalPreference(userId, toolName) {
+    const prefId = `${userId}_${toolName}`;
+    const doc = await this.db.collection(this.toolPreferencesCollection).doc(prefId).get();
+    if (!doc.exists) return null;
+    return doc.data();
+  }
+  /**
+   * Update tool approval preference based on interrupt decisions
+   */
+  async updateToolApprovalPreference(userId, toolName, decision) {
+    const prefId = `${userId}_${toolName}`;
+    const existing = await this.db.collection(this.toolPreferencesCollection).doc(prefId).get();
+    if (!existing.exists) {
+      const pref = {
+        userId,
+        toolName,
+        autoApprove: decision === "approved",
+        confidence: decision === "approved" ? 0.5 : 0,
+        approvedCount: decision === "approved" ? 1 : 0,
+        rejectedCount: decision === "rejected" ? 1 : 0,
+        lastDecisionAt: /* @__PURE__ */ new Date()
+      };
+      await this.db.collection(this.toolPreferencesCollection).doc(prefId).set(pref);
+    } else {
+      const data = existing.data();
+      const approvedCount = data.approvedCount + (decision === "approved" ? 1 : 0);
+      const rejectedCount = data.rejectedCount + (decision === "rejected" ? 1 : 0);
+      const total = approvedCount + rejectedCount;
+      const approvalRate = approvedCount / total;
+      const pref = {
+        ...data,
+        approvedCount,
+        rejectedCount,
+        // Auto-approve if approval rate > 80% and at least 5 decisions
+        autoApprove: total >= 5 && approvalRate > 0.8,
+        confidence: Math.min(0.95, total * 0.1),
+        lastDecisionAt: /* @__PURE__ */ new Date()
+      };
+      await this.db.collection(this.toolPreferencesCollection).doc(prefId).set(pref);
+    }
+  }
+  /**
+   * Get all tool approval preferences for a user
+   */
+  async getUserToolPreferences(userId) {
+    const snapshot = await this.db.collection(this.toolPreferencesCollection).where("userId", "==", userId).get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Check if a tool should be auto-approved for a user
+   */
+  async shouldAutoApproveTool(userId, toolName) {
+    const pref = await this.getToolApprovalPreference(userId, toolName);
+    return pref?.autoApprove ?? false;
+  }
+  // ============================================================================
+  // Checkpoint Tracking (GAP-004: Checkpoint → Memory)
+  // ============================================================================
+  /**
+   * Record a checkpoint for learning
+   */
+  async recordCheckpoint(userId, checkpointData) {
+    const record = {
+      checkpointId: checkpointData.checkpointId,
+      threadId: checkpointData.threadId,
+      userId,
+      parentCheckpointId: checkpointData.parentCheckpointId,
+      metadata: checkpointData.metadata ?? {},
+      createdAt: /* @__PURE__ */ new Date(),
+      rollbackCount: 0,
+      wasSuccessful: false
+    };
+    const docId = `${userId}_${checkpointData.checkpointId}`;
+    await this.db.collection(this.checkpointsCollection).doc(docId).set(record);
+  }
+  /**
+   * Record a rollback to a checkpoint
+   */
+  async recordRollback(userId, checkpointId, reason) {
+    const docId = `${userId}_${checkpointId}`;
+    const doc = await this.db.collection(this.checkpointsCollection).doc(docId).get();
+    if (doc.exists) {
+      const data = doc.data();
+      await this.db.collection(this.checkpointsCollection).doc(docId).set({
+        ...data,
+        rollbackCount: data.rollbackCount + 1,
+        lastRollbackReason: reason,
+        lastRollbackAt: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  /**
+   * Mark a checkpoint as successful (terminal state)
+   */
+  async markCheckpointSuccessful(userId, checkpointId) {
+    const docId = `${userId}_${checkpointId}`;
+    const doc = await this.db.collection(this.checkpointsCollection).doc(docId).get();
+    if (doc.exists) {
+      const data = doc.data();
+      await this.db.collection(this.checkpointsCollection).doc(docId).set({
+        ...data,
+        wasSuccessful: true
+      });
+    }
+  }
+  /**
+   * Get checkpoint history for a user
+   */
+  async getUserCheckpoints(userId, limit = 50) {
+    const snapshot = await this.db.collection(this.checkpointsCollection).where("userId", "==", userId).orderBy("createdAt", "desc").limit(limit).get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Get checkpoints for a thread
+   */
+  async getThreadCheckpoints(threadId) {
+    const snapshot = await this.db.collection(this.checkpointsCollection).where("threadId", "==", threadId).orderBy("createdAt", "desc").get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Get frequently rolled-back checkpoints (problem areas)
+   */
+  async getProblemCheckpoints(userId, minRollbackCount = 2) {
+    const snapshot = await this.db.collection(this.checkpointsCollection).where("userId", "==", userId).where("rollbackCount", ">=", minRollbackCount).orderBy("rollbackCount", "desc").get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
+  /**
+   * Get successful checkpoint patterns for learning
+   */
+  async getSuccessfulCheckpoints(userId, limit = 20) {
+    const snapshot = await this.db.collection(this.checkpointsCollection).where("userId", "==", userId).where("wasSuccessful", "==", true).orderBy("createdAt", "desc").limit(limit).get();
+    return snapshot.docs.map((doc) => doc.data());
+  }
 };
 var PreferenceLearner = class {
   constructor(options) {
@@ -5966,11 +6400,987 @@ Respond in JSON format:
 function createPreferenceLearner(options) {
   return new PreferenceLearner(options);
 }
+
+// src/memory/agentic-search.ts
+var AgenticSearchEngine = class {
+  constructor(memoryManager) {
+    this.memoryManager = memoryManager;
+  }
+  /**
+   * Perform agentic search through memory
+   */
+  async search(params) {
+    const startTime = Date.now();
+    const strategy = params.strategy ?? "hybrid";
+    const depth = params.depth ?? 3;
+    const limit = params.limit ?? 10;
+    let results = [];
+    switch (strategy) {
+      case "temporal":
+        results = await this.temporalSearch(params, depth, limit);
+        break;
+      case "semantic":
+        results = await this.semanticSearch(params, depth, limit);
+        break;
+      case "pattern":
+        results = await this.patternSearch(params, depth, limit);
+        break;
+      case "hybrid":
+      default:
+        results = await this.hybridSearch(params, depth, limit);
+        break;
+    }
+    results.sort((a, b) => b.relevance - a.relevance);
+    const insights = this.generateInsights(results, params.query);
+    const duration = Date.now() - startTime;
+    return {
+      results: results.slice(0, limit),
+      insights,
+      metadata: {
+        strategy,
+        depth,
+        duration,
+        totalResults: results.length
+      }
+    };
+  }
+  // ============================================================================
+  // Search Strategies
+  // ============================================================================
+  /**
+   * Temporal search - "What did I do last week?"
+   * Navigates memory by time relationships
+   */
+  async temporalSearch(params, _depth, limit) {
+    const results = [];
+    const isRecentQuery = /recent|last|latest|newest/i.test(params.query);
+    /week|month|day|ago/i.test(params.query);
+    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit * 2);
+    for (const session of sessions) {
+      let relevance = 0.5;
+      let reasoning = "Recent generation session";
+      if (isRecentQuery) {
+        const daysAgo = (Date.now() - session.createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+        relevance = Math.max(0.1, 1 - daysAgo / 30);
+        reasoning = `Created ${Math.round(daysAgo)} days ago`;
+      }
+      const sessionText = `${session.prompt} ${session.entities.join(" ")} ${session.patterns.join(" ")}`.toLowerCase();
+      const queryTerms = params.query.toLowerCase().split(/\s+/);
+      const termMatches = queryTerms.filter((term) => sessionText.includes(term)).length;
+      relevance += termMatches * 0.1;
+      if (relevance > 0.3) {
+        results.push({
+          type: "session",
+          data: session,
+          relevance: Math.min(1, relevance),
+          reasoning,
+          source: "generation_history",
+          timestamp: session.createdAt
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Semantic search - "How did I handle user roles?"
+   * Reasoning-based understanding of structure
+   */
+  async semanticSearch(params, _depth, limit) {
+    const results = [];
+    const concepts = this.extractConcepts(params.query);
+    const prefs = await this.memoryManager.getUserPreferences(params.userId);
+    if (prefs) {
+      let relevance = 0.3;
+      const matchedConcepts = [];
+      if (concepts.naming && prefs.namingConvention) {
+        relevance += 0.2;
+        matchedConcepts.push(`uses ${prefs.namingConvention}`);
+      }
+      if (concepts.patterns && prefs.preferredPatterns.length > 0) {
+        const matched = prefs.preferredPatterns.filter(
+          (p) => concepts.patterns?.some((cp) => p.toLowerCase().includes(cp.toLowerCase()))
+        );
+        relevance += matched.length * 0.1;
+        matchedConcepts.push(`patterns: ${matched.join(", ")}`);
+      }
+      if (concepts.entities && prefs.commonEntities.length > 0) {
+        const matched = prefs.commonEntities.filter(
+          (e) => concepts.entities?.some((ce) => e.toLowerCase().includes(ce.toLowerCase()))
+        );
+        relevance += matched.length * 0.1;
+        matchedConcepts.push(`entities: ${matched.join(", ")}`);
+      }
+      if (relevance > 0.4) {
+        results.push({
+          type: "preference",
+          data: prefs,
+          relevance: Math.min(1, relevance),
+          reasoning: `User preferences match query concepts: ${matchedConcepts.join("; ")}`,
+          source: "user_preferences",
+          timestamp: prefs.learnedAt
+        });
+      }
+    }
+    if (params.appId) {
+      const project = await this.memoryManager.getProjectContext(params.appId);
+      if (project) {
+        let relevance = 0.3;
+        const projectText = `${project.projectName ?? ""} ${project.description ?? ""} ${project.existingEntities.join(" ")}`.toLowerCase();
+        const queryTerms = params.query.toLowerCase().split(/\s+/);
+        const termMatches = queryTerms.filter((term) => projectText.includes(term)).length;
+        relevance += termMatches * 0.15;
+        if (relevance > 0.4) {
+          results.push({
+            type: "project",
+            data: project,
+            relevance: Math.min(1, relevance),
+            reasoning: `Project context contains ${termMatches} matching terms`,
+            source: "project_context",
+            timestamp: project.lastUpdatedAt
+          });
+        }
+      }
+    }
+    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit);
+    for (const session of sessions) {
+      const sessionText = `${session.prompt} ${session.entities.join(" ")}`.toLowerCase();
+      let relevance = 0.3;
+      if (concepts.entities) {
+        const entityMatches = session.entities.filter(
+          (e) => concepts.entities?.some((ce) => e.toLowerCase().includes(ce.toLowerCase()))
+        );
+        relevance += entityMatches.length * 0.15;
+      }
+      if (concepts.patterns) {
+        const patternMatches = session.patterns.filter(
+          (p) => concepts.patterns?.some((cp) => p.toLowerCase().includes(cp.toLowerCase()))
+        );
+        relevance += patternMatches.length * 0.1;
+      }
+      const queryTerms = params.query.toLowerCase().split(/\s+/);
+      const termMatches = queryTerms.filter((term) => sessionText.includes(term)).length;
+      relevance += termMatches * 0.05;
+      if (relevance > 0.4) {
+        results.push({
+          type: "session",
+          data: session,
+          relevance: Math.min(1, relevance),
+          reasoning: `Session contains relevant entities, patterns, or keywords`,
+          source: "generation_history",
+          timestamp: session.createdAt
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Pattern search - "Show me all list views I've built"
+   * Searches for specific patterns and effects
+   */
+  async patternSearch(params, _depth, limit) {
+    const results = [];
+    const patternTerms = ["list", "form", "detail", "card", "table", "chart", "map", "calendar"];
+    const matchedTerms = patternTerms.filter(
+      (term) => params.query.toLowerCase().includes(term)
+    );
+    const patterns = await this.memoryManager.getUserPatterns(params.userId);
+    for (const pattern of patterns) {
+      let relevance = 0.3;
+      let reasoning = `Pattern usage: ${pattern.usageCount} times`;
+      if (matchedTerms.some((term) => pattern.patternId.toLowerCase().includes(term))) {
+        relevance += 0.3;
+        reasoning += ", matches query pattern type";
+      }
+      const successRate = pattern.usageCount > 0 ? pattern.successCount / pattern.usageCount : 0;
+      relevance += successRate * 0.2;
+      if (relevance > 0.4) {
+        results.push({
+          type: "pattern",
+          data: pattern,
+          relevance: Math.min(1, relevance),
+          reasoning: `${reasoning}, ${Math.round(successRate * 100)}% success rate`,
+          source: "pattern_affinity",
+          timestamp: pattern.lastUsedAt
+        });
+      }
+    }
+    const sessions = await this.memoryManager.getUserGenerationHistory(params.userId, limit);
+    for (const session of sessions) {
+      const matchingPatterns = session.patterns.filter(
+        (p) => matchedTerms.some((term) => p.toLowerCase().includes(term))
+      );
+      if (matchingPatterns.length > 0) {
+        results.push({
+          type: "session",
+          data: session,
+          relevance: 0.5 + matchingPatterns.length * 0.1,
+          reasoning: `Session uses patterns: ${matchingPatterns.join(", ")}`,
+          source: "generation_history",
+          timestamp: session.createdAt
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Hybrid search - combines all strategies
+   */
+  async hybridSearch(params, depth, limit) {
+    const [temporal, semantic, pattern] = await Promise.all([
+      this.temporalSearch(params, depth, Math.ceil(limit / 2)),
+      this.semanticSearch(params, depth, Math.ceil(limit / 2)),
+      this.patternSearch(params, depth, Math.ceil(limit / 2))
+    ]);
+    const seen = /* @__PURE__ */ new Set();
+    const combined = [];
+    for (const result of [...temporal, ...semantic, ...pattern]) {
+      const key = `${result.type}-${JSON.stringify(result.data)}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        combined.push(result);
+      }
+    }
+    return combined;
+  }
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+  /**
+   * Extract semantic concepts from query
+   */
+  extractConcepts(query) {
+    const lower = query.toLowerCase();
+    return {
+      naming: /naming|case|pascal|camel|snake/i.test(lower),
+      validation: /validat|schema|required|optional/i.test(lower),
+      patterns: ["entity", "list", "form", "detail", "card"].filter((p) => lower.includes(p)),
+      entities: this.extractEntityNames(lower),
+      actions: ["create", "update", "delete", "list", "view"].filter((a) => lower.includes(a))
+    };
+  }
+  /**
+   * Extract potential entity names from query
+   */
+  extractEntityNames(query) {
+    const words = query.split(/\s+/);
+    const entities = [];
+    for (const word of words) {
+      const clean = word.replace(/[^a-zA-Z]/g, "");
+      if (clean.length > 2 && clean[0] === clean[0].toUpperCase()) {
+        entities.push(clean);
+      }
+    }
+    return entities;
+  }
+  /**
+   * Generate insights from search results
+   */
+  generateInsights(results, query) {
+    const summary = `Found ${results.length} relevant memory items for "${query}"`;
+    const patternResults = results.filter((r) => r.type === "pattern");
+    const patterns = patternResults.length > 0 ? patternResults.slice(0, 3).map((r) => r.data.patternId) : ["No dominant patterns identified"];
+    const sessions = results.filter((r) => r.type === "session");
+    const trends = [];
+    if (sessions.length > 0) {
+      const timestamps = sessions.filter((s) => s.timestamp).map((s) => s.timestamp.getTime()).sort((a, b) => b - a);
+      if (timestamps.length >= 2) {
+        const avgGap = (timestamps[0] - timestamps[timestamps.length - 1]) / (timestamps.length - 1);
+        const daysGap = avgGap / (1e3 * 60 * 60 * 24);
+        if (daysGap < 7) {
+          trends.push("High activity - multiple sessions per week");
+        } else if (daysGap > 30) {
+          trends.push("Sporadic usage - sessions spread out over time");
+        }
+      }
+    }
+    const suggestions = [];
+    if (patterns.length > 0 && !patterns[0].includes("No dominant")) {
+      suggestions.push(`Consider reusing pattern: ${patterns[0]}`);
+    }
+    const projectResults = results.filter((r) => r.type === "project");
+    if (projectResults.length > 0) {
+      suggestions.push("Review existing project conventions for consistency");
+    }
+    const interruptResults = results.filter((r) => r.type === "interrupt");
+    if (interruptResults.length > 3) {
+      suggestions.push("High interrupt frequency - consider adjusting auto-approval settings");
+    }
+    if (suggestions.length === 0) {
+      suggestions.push("No specific suggestions based on current memory");
+    }
+    return { summary, patterns, trends, suggestions };
+  }
+};
+function createAgenticSearchEngine(memoryManager) {
+  return new AgenticSearchEngine(memoryManager);
+}
+
+// src/observability.ts
+var ObservabilityCollector = class {
+  constructor(options = {}) {
+    this.events = [];
+    this.sessions = /* @__PURE__ */ new Map();
+    this.maxEvents = options.maxEvents ?? 1e4;
+  }
+  /**
+   * Record an observable event
+   */
+  recordEvent(event) {
+    const fullEvent = {
+      ...event,
+      timestamp: Date.now()
+    };
+    this.events.push(fullEvent);
+    if (this.events.length > this.maxEvents) {
+      this.events = this.events.slice(-this.maxEvents);
+    }
+    this.updateSessionTelemetry(fullEvent);
+  }
+  /**
+   * Start session tracking
+   */
+  startSession(sessionId, userId) {
+    this.sessions.set(sessionId, {
+      sessionId,
+      userId,
+      startedAt: Date.now(),
+      toolCallCount: 0,
+      llmCallCount: 0,
+      interruptCount: 0,
+      checkpointCount: 0,
+      totalTokens: 0,
+      errors: [],
+      status: "running"
+    });
+    this.recordEvent({
+      type: "session_start",
+      sessionId,
+      userId,
+      payload: { startedAt: Date.now() }
+    });
+  }
+  /**
+   * End session tracking
+   */
+  endSession(sessionId, status = "completed") {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.endedAt = Date.now();
+      session.status = status;
+      this.recordEvent({
+        type: "session_end",
+        sessionId,
+        userId: session.userId,
+        payload: {
+          status,
+          duration: session.endedAt - session.startedAt,
+          toolCalls: session.toolCallCount,
+          llmCalls: session.llmCallCount
+        },
+        duration: session.endedAt - session.startedAt
+      });
+    }
+  }
+  /**
+   * Record tool call
+   */
+  recordToolCall(sessionId, toolName, args, duration) {
+    this.recordEvent({
+      type: "tool_call",
+      sessionId,
+      payload: { tool: toolName, args },
+      duration
+    });
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.toolCallCount++;
+    }
+  }
+  /**
+   * Record LLM call
+   */
+  recordLLMCall(sessionId, model, tokens, duration) {
+    this.recordEvent({
+      type: "llm_call",
+      sessionId,
+      payload: { model, tokens },
+      duration
+    });
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.llmCallCount++;
+      session.totalTokens += tokens.input + tokens.output;
+    }
+  }
+  /**
+   * Record error
+   */
+  recordError(sessionId, error, context) {
+    this.recordEvent({
+      type: "error",
+      sessionId,
+      payload: { ...context, message: error.message },
+      error: {
+        message: error.message,
+        code: error.code,
+        stack: error.stack
+      }
+    });
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.errors.push({
+        timestamp: Date.now(),
+        message: error.message,
+        type: error.constructor.name
+      });
+    }
+  }
+  /**
+   * Get events by type
+   */
+  getEvents(type, sessionId) {
+    let filtered = this.events;
+    if (type) {
+      filtered = filtered.filter((e) => e.type === type);
+    }
+    if (sessionId) {
+      filtered = filtered.filter((e) => e.sessionId === sessionId);
+    }
+    return filtered;
+  }
+  /**
+   * Get session telemetry
+   */
+  getSessionTelemetry(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions() {
+    return Array.from(this.sessions.values()).filter((s) => s.status === "running");
+  }
+  /**
+   * Get performance snapshot
+   */
+  getPerformanceSnapshot() {
+    const now = Date.now();
+    const sessions = Array.from(this.sessions.values());
+    const activeSessions = sessions.filter((s) => s.status === "running");
+    const last24h = sessions.filter((s) => s.startedAt > now - 24 * 60 * 60 * 1e3);
+    const completed24h = last24h.filter((s) => s.status === "completed");
+    const failed24h = last24h.filter((s) => s.status === "failed");
+    const successRate24h = last24h.length > 0 ? completed24h.length / last24h.length * 100 : 0;
+    const errorRate24h = last24h.length > 0 ? failed24h.length / last24h.length * 100 : 0;
+    const completedSessions = sessions.filter((s) => s.endedAt);
+    const avgSessionDuration = completedSessions.length > 0 ? completedSessions.reduce((sum, s) => sum + ((s.endedAt || now) - s.startedAt), 0) / completedSessions.length : 0;
+    const sessionsWithTokens = sessions.filter((s) => s.totalTokens > 0);
+    const avgTokensPerSession = sessionsWithTokens.length > 0 ? sessionsWithTokens.reduce((sum, s) => sum + s.totalTokens, 0) / sessionsWithTokens.length : 0;
+    return {
+      timestamp: now,
+      activeSessions: activeSessions.length,
+      totalSessions: sessions.length,
+      avgSessionDuration,
+      successRate24h,
+      errorRate24h,
+      avgTokensPerSession
+    };
+  }
+  /**
+   * Perform health check
+   */
+  async healthCheck() {
+    const checks = [];
+    const now = Date.now();
+    checks.push({
+      component: "event_buffer",
+      status: this.events.length < this.maxEvents * 0.9 ? "healthy" : "degraded",
+      responseTime: 0,
+      checkedAt: now
+    });
+    const activeSessions = this.getActiveSessions();
+    const staleSessions = activeSessions.filter(
+      (s) => now - s.startedAt > 30 * 60 * 1e3
+      // 30 minutes
+    );
+    checks.push({
+      component: "sessions",
+      status: staleSessions.length < 10 ? "healthy" : "degraded",
+      responseTime: 0,
+      checkedAt: now,
+      error: staleSessions.length > 0 ? `${staleSessions.length} stale sessions` : void 0
+    });
+    return checks;
+  }
+  /**
+   * Export metrics for external systems
+   */
+  exportMetrics() {
+    return {
+      events: this.events.slice(-1e3),
+      // Last 1000 events
+      sessions: Array.from(this.sessions.values()),
+      snapshot: this.getPerformanceSnapshot(),
+      health: []
+      // Populated by healthCheck
+    };
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.events = [];
+    this.sessions.clear();
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  updateSessionTelemetry(event) {
+    const session = this.sessions.get(event.sessionId);
+    if (!session) return;
+    switch (event.type) {
+      case "interrupt":
+        session.interruptCount++;
+        break;
+      case "checkpoint_save":
+        session.checkpointCount++;
+        break;
+    }
+  }
+};
+var globalCollector = null;
+function getObservabilityCollector() {
+  if (!globalCollector) {
+    globalCollector = new ObservabilityCollector();
+  }
+  return globalCollector;
+}
+function resetObservabilityCollector() {
+  globalCollector = null;
+}
+function recordEvent(event) {
+  getObservabilityCollector().recordEvent(event);
+}
+function startObservabilitySession(sessionId, userId) {
+  getObservabilityCollector().startSession(sessionId, userId);
+}
+function endObservabilitySession(sessionId, status) {
+  getObservabilityCollector().endSession(sessionId, status);
+}
+function getPerformanceSnapshot() {
+  return getObservabilityCollector().getPerformanceSnapshot();
+}
+
+// src/multi-user.ts
+var MultiUserManager = class {
+  constructor() {
+    this.sessionOwnership = /* @__PURE__ */ new Map();
+    // threadId -> userId
+    this.userSessions = /* @__PURE__ */ new Map();
+  }
+  // userId -> Set<threadId>
+  /**
+   * Check if a user owns a session
+   */
+  isSessionOwner(threadId, userId) {
+    const owner = this.sessionOwnership.get(threadId);
+    return owner === userId;
+  }
+  /**
+   * Check if a user can access a session
+   */
+  canAccessSession(threadId, userContext) {
+    const owner = this.sessionOwnership.get(threadId);
+    if (!owner) {
+      return { allowed: true };
+    }
+    if (owner === userContext.userId) {
+      return { allowed: true };
+    }
+    if (userContext.roles?.includes("admin")) {
+      return { allowed: true };
+    }
+    if (userContext.sessionScope?.includes(threadId)) {
+      return { allowed: true };
+    }
+    return {
+      allowed: false,
+      reason: "Session does not belong to user",
+      requiredRole: "owner or admin"
+    };
+  }
+  /**
+   * Assign session ownership
+   */
+  assignSessionOwnership(threadId, userId) {
+    const previousOwner = this.sessionOwnership.get(threadId);
+    if (previousOwner) {
+      const previousSessions = this.userSessions.get(previousOwner);
+      if (previousSessions) {
+        previousSessions.delete(threadId);
+      }
+    }
+    this.sessionOwnership.set(threadId, userId);
+    if (!this.userSessions.has(userId)) {
+      this.userSessions.set(userId, /* @__PURE__ */ new Set());
+    }
+    this.userSessions.get(userId).add(threadId);
+  }
+  /**
+   * Get all sessions for a user
+   */
+  getUserSessions(userId) {
+    const sessions = this.userSessions.get(userId);
+    return sessions ? Array.from(sessions) : [];
+  }
+  /**
+   * Get session owner
+   */
+  getSessionOwner(threadId) {
+    return this.sessionOwnership.get(threadId);
+  }
+  /**
+   * Remove session ownership
+   */
+  removeSession(threadId) {
+    const owner = this.sessionOwnership.get(threadId);
+    if (owner) {
+      const sessions = this.userSessions.get(owner);
+      if (sessions) {
+        sessions.delete(threadId);
+      }
+    }
+    this.sessionOwnership.delete(threadId);
+  }
+  /**
+   * Check if user has any sessions
+   */
+  hasSessions(userId) {
+    const sessions = this.userSessions.get(userId);
+    return sessions ? sessions.size > 0 : false;
+  }
+  /**
+   * Get user session count
+   */
+  getSessionCount(userId) {
+    const sessions = this.userSessions.get(userId);
+    return sessions ? sessions.size : 0;
+  }
+  /**
+   * Transfer session ownership
+   */
+  transferOwnership(threadId, fromUserId, toUserId) {
+    const owner = this.sessionOwnership.get(threadId);
+    if (owner !== fromUserId) {
+      return {
+        allowed: false,
+        reason: "Only the owner can transfer session ownership"
+      };
+    }
+    this.assignSessionOwnership(threadId, toUserId);
+    return { allowed: true };
+  }
+  /**
+   * Share session with another user
+   */
+  shareSession(threadId, ownerId, targetUserId, permission = "read") {
+    const owner = this.sessionOwnership.get(threadId);
+    if (owner !== ownerId) {
+      return {
+        allowed: false,
+        reason: "Only the owner can share a session"
+      };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Get all user IDs with sessions
+   */
+  getAllUsers() {
+    return Array.from(this.userSessions.keys());
+  }
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.sessionOwnership.clear();
+    this.userSessions.clear();
+  }
+  /**
+   * Create scoped session metadata
+   */
+  createScopedMetadata(metadata, userContext) {
+    return {
+      ...metadata,
+      userId: userContext.userId,
+      orgId: userContext.orgId,
+      createdBy: userContext.userId,
+      lastAccessedBy: userContext.userId,
+      acl: {
+        readers: [userContext.userId],
+        writers: [userContext.userId],
+        isPublic: false
+      }
+    };
+  }
+  /**
+   * Validate user context
+   */
+  validateUserContext(userContext) {
+    if (!userContext || typeof userContext !== "object") {
+      return false;
+    }
+    const ctx = userContext;
+    if (!ctx.userId || typeof ctx.userId !== "string") {
+      return false;
+    }
+    if (ctx.orgId !== void 0 && typeof ctx.orgId !== "string") {
+      return false;
+    }
+    if (ctx.roles !== void 0 && !Array.isArray(ctx.roles)) {
+      return false;
+    }
+    return true;
+  }
+};
+var globalMultiUserManager = null;
+function getMultiUserManager() {
+  if (!globalMultiUserManager) {
+    globalMultiUserManager = new MultiUserManager();
+  }
+  return globalMultiUserManager;
+}
+function resetMultiUserManager() {
+  globalMultiUserManager = null;
+}
+function createUserContext(userId, options = {}) {
+  return {
+    userId,
+    orgId: options.orgId,
+    roles: options.roles ?? ["user"]
+  };
+}
+function isAdmin(userContext) {
+  return userContext.roles?.includes("admin") ?? false;
+}
+function requireOwnership(threadId, userContext, manager = getMultiUserManager()) {
+  const check = manager.canAccessSession(threadId, userContext);
+  if (!check.allowed) {
+    throw new Error(`Access denied: ${check.reason}`);
+  }
+}
+var StateSyncManager = class extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.sequenceNumber = 0;
+    this.pendingChanges = [];
+    this.throttleTimer = null;
+    this.config = {
+      enabled: config.enabled ?? true,
+      conflictStrategy: config.conflictStrategy ?? "last_write_wins",
+      throttleInterval: config.throttleInterval ?? 100,
+      maxRetries: config.maxRetries ?? 3,
+      clientId: config.clientId ?? this.generateClientId()
+    };
+  }
+  /**
+   * Notify that state has changed (called by agent internals)
+   */
+  notifyStateChange(type, threadId, payload, userId) {
+    if (!this.config.enabled) return;
+    const event = {
+      type,
+      threadId,
+      userId,
+      timestamp: Date.now(),
+      payload,
+      version: this.createVersionVector(),
+      sourceClientId: this.config.clientId
+    };
+    this.pendingChanges.push(event);
+    this.emit("stateChange", event);
+    this.scheduleSync();
+  }
+  /**
+   * Receive state change from server (called by server transport)
+   */
+  receiveRemoteChange(event) {
+    if (event.sourceClientId === this.config.clientId) return;
+    const conflicts = this.findConflicts(event);
+    if (conflicts.length > 0) {
+      const resolution = this.resolveConflicts(event, conflicts);
+      if (resolution.resolved) {
+        this.emit("stateReconciled", resolution.winningState, event);
+      } else {
+        this.emit("conflictDetected", conflicts, event);
+      }
+    } else {
+      this.emit("remoteChange", event);
+    }
+  }
+  /**
+   * Create sync snapshot for current state
+   */
+  createSnapshot(threadId, state) {
+    return {
+      threadId,
+      checkpoint: state.checkpoint,
+      sessionMetadata: state.sessionMetadata,
+      memoryState: state.memoryState,
+      version: this.createVersionVector(),
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Compare two version vectors
+   * Returns: -1 if a < b, 0 if concurrent/equal, 1 if a > b
+   */
+  compareVersions(a, b) {
+    if (a.timestamp < b.timestamp) return -1;
+    if (a.timestamp > b.timestamp) return 1;
+    if (a.sequence < b.sequence) return -1;
+    if (a.sequence > b.sequence) return 1;
+    return 0;
+  }
+  /**
+   * Check if there are pending changes to sync
+   */
+  hasPendingChanges() {
+    return this.pendingChanges.length > 0;
+  }
+  /**
+   * Get and clear pending changes
+   */
+  flushPendingChanges() {
+    const changes = [...this.pendingChanges];
+    this.pendingChanges = [];
+    return changes;
+  }
+  /**
+   * Get sync configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update sync configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.emit("configUpdated", this.config);
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    if (this.throttleTimer) {
+      clearTimeout(this.throttleTimer);
+      this.throttleTimer = null;
+    }
+    this.removeAllListeners();
+    this.pendingChanges = [];
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  generateClientId() {
+    return `client_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+  createVersionVector() {
+    this.sequenceNumber++;
+    return {
+      timestamp: Date.now(),
+      sequence: this.sequenceNumber,
+      nodeId: this.config.clientId
+    };
+  }
+  scheduleSync() {
+    if (this.throttleTimer) return;
+    this.throttleTimer = setTimeout(() => {
+      this.throttleTimer = null;
+      if (this.pendingChanges.length > 0) {
+        this.emit("syncRequired", this.flushPendingChanges());
+      }
+    }, this.config.throttleInterval);
+  }
+  findConflicts(incoming) {
+    return this.pendingChanges.filter(
+      (local) => local.threadId === incoming.threadId && local.type === incoming.type && this.compareVersions(local.version, incoming.version) !== 0
+    );
+  }
+  resolveConflicts(incoming, conflicts) {
+    switch (this.config.conflictStrategy) {
+      case "last_write_wins":
+        let winningEvent = incoming;
+        for (const conflict of conflicts) {
+          if (this.compareVersions(conflict.version, winningEvent.version) > 0) {
+            winningEvent = conflict;
+          }
+        }
+        return {
+          resolved: true,
+          strategy: "last_write_wins"
+        };
+      case "manual":
+        return {
+          resolved: false,
+          strategy: "manual",
+          conflicts: conflicts.map((c) => ({ clientA: c, clientB: incoming }))
+        };
+      case "merge":
+      default:
+        return {
+          resolved: conflicts.length === 0,
+          strategy: conflicts.length === 0 ? "merge" : "manual",
+          conflicts: conflicts.length > 0 ? conflicts.map((c) => ({ clientA: c, clientB: incoming })) : void 0
+        };
+    }
+  }
+};
+var globalStateSyncManager = null;
+function getStateSyncManager(config) {
+  if (!globalStateSyncManager) {
+    globalStateSyncManager = new StateSyncManager(config);
+  }
+  return globalStateSyncManager;
+}
+function resetStateSyncManager() {
+  globalStateSyncManager?.dispose();
+  globalStateSyncManager = null;
+}
+function withSync(fn, syncManager, options) {
+  return ((...args) => {
+    const result = fn(...args);
+    syncManager.notifyStateChange(
+      options.type,
+      options.threadId,
+      options.getPayload(...args)
+    );
+    return result;
+  });
+}
+function debounceSync(syncManager, delay = 100) {
+  let timeout = null;
+  let pending = null;
+  return (type, threadId, payload) => {
+    pending = { type, threadId, payload };
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      if (pending) {
+        syncManager.notifyStateChange(pending.type, pending.threadId, pending.payload);
+        pending = null;
+      }
+      timeout = null;
+    }, delay);
+  };
+}
 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, 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 };
+export { AgenticSearchEngine, ContinueRequestSchema, DEFAULT_COMPACTION_CONFIG, EVENT_BUDGETS, ExtractedRequirementsSchema, FirestoreCheckpointer, FirestoreSessionStore, FirestoreStore, GenerateRequestSchema, MemoryManager, MemoryOrbitalSchema, MemorySessionBackend, MetricsCollector, MultiUserManager, ObservabilityCollector, PreferenceLearner, ResumeRequestSchema, SessionManager, StateSyncManager, analyzeFailures, export_applySectionUpdate as applySectionUpdate, combineOrbitals, combineOrbitalsToSchema, export_convertDomainToSchema as convertDomainToSchema, export_convertSchemaToDomain as convertSchemaToDomain, createAgentTools, createAgenticSearchEngine, 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, createUserContext, createValidateSchemaTool, debounceSync, export_deleteSection as deleteSection, endObservabilitySession, estimateCacheSavings, estimateCombineComplexity, estimateTokens, extractFileOperation, extractInterruptData, formatSSEEvent, formatSummary, generateFullOrbital, getBudgetWarningMessage, getEventBudget, getInterruptConfig, getMultiUserManager, getObservabilityCollector, getPerformanceSnapshot, getStateSyncManager, hasInterrupt, isAdmin, isCompleteEvent, isErrorEvent, isExecutionEvent, isFileOperation, isSSECompleteEvent, isSSEErrorEvent, isSSEGenerationLogEvent, isSSEInterruptEvent, isSSEMessageEvent, isSSEStartEvent, isSSESubagentEvent, isSSETodoDetailEvent, isSSETodoUpdateEvent, isSSEToolCallEvent, isSchemaEvent, isStartEvent, isTodoUpdate, needsCompaction, parseDeepAgentEvent, parseSSEEvent, recordEvent, requireOwnership, resetMultiUserManager, resetObservabilityCollector, resetStateSyncManager, resumeSkillAgent, startObservabilitySession, transformAgentEvent, transformAgentEventMulti, validateCommandPaths, withSync };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map