@lanonasis/mem-intel-sdk/
├── dist/
│   ├── core/
│   │   ├── client.js          # MemoryIntelligenceClient
│   │   ├── types.js           # TypeScript definitions
│   │   └── errors.js          # Error classes
│   ├── server/
│   │   └── index.js           # MCP Server (createMCPServer)
│   ├── utils/
│   │   ├── similarity.js      # cosineSimilarity()
│   │   ├── embeddings.js      # Embedding utilities
│   │   ├── http-client.js     # HttpClient with cache
│   │   └── response-adapter.js # ResponseCache
│   ├── react/                 # React hooks
│   ├── vue/                   # Vue composables
│   └── node/                  # Node.js entry

export type BehaviorOutcome = 'success' | 'partial' | 'failed';

export interface ToolAction {
  tool: string;
  parameters: Record<string, any>;
  outcome: BehaviorOutcome;
  timestamp: string;
  duration_ms?: number;
}

export interface WorkflowPattern {
  id: string;
  user_id: string;
  trigger: string;
  trigger_embedding?: number[];
  context: {
    directory: string;
    project_type?: string;
    branch?: string;
    files_touched?: string[];
  };
  actions: ToolAction[];
  final_outcome: BehaviorOutcome;
  confidence: number;
  use_count: number;
  last_used_at?: string;
  created_at: string;
  updated_at: string;
}

export interface BehaviorRecordParams {
  userId: string;
  trigger: string;
  context: {
    directory: string;
    projectType?: string;
    branch?: string;
    filesTouched?: string[];
  };
  actions: ToolAction[];
  finalOutcome: BehaviorOutcome;
  confidence?: number;
}

export interface BehaviorRecallParams {
  userId: string;
  context: {
    currentDirectory: string;
    currentTask: string;
    projectType?: string;
  };
  limit?: number;
  similarityThreshold?: number;
}

/**
 * Record a successful workflow pattern for future recall
 */
async recordBehavior(params: BehaviorRecordParams): Promise<{
  data: WorkflowPattern;
  usage?: UsageInfo;
}> {
  // First check for duplicates locally
  if (this.processingMode === 'offline-fallback' && this.cache) {
    const existing = await this.findSimilarBehavior(params.trigger, params.userId);
    if (existing && existing.similarity > 0.95) {
      // Update use_count instead of creating duplicate
      return this.updateBehaviorUsage(existing.id);
    }
  }

  const response = await this.httpClient.postEnhanced(
    '/intelligence/behavior/record',
    {
      user_id: params.userId,
      trigger: params.trigger,
      context: params.context,
      actions: params.actions,
      final_outcome: params.finalOutcome,
      confidence: params.confidence || 0.7
    }
  );

  return { data: response.data, usage: response.usage };
}

/**
 * Recall relevant behavior patterns for current context
 */
async recallBehavior(params: BehaviorRecallParams): Promise<{
  data: BehaviorRecallResult;
  usage?: UsageInfo;
  fromCache?: boolean;
}> {
  // Try local cache first
  if (this.processingMode === 'offline-fallback' && this.cache) {
    const cached = await this.localBehaviorSearch(params);
    if (cached.patterns.length > 0) {
      return { data: cached, fromCache: true };
    }
  }

  const response = await this.httpClient.postEnhanced(
    '/intelligence/behavior/recall',
    {
      user_id: params.userId,
      context: params.context,
      limit: params.limit || 5,
      similarity_threshold: params.similarityThreshold || 0.7
    }
  );

  return { data: response.data, usage: response.usage, fromCache: false };
}

CREATE TABLE IF NOT EXISTS public.behavior_patterns (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
  trigger TEXT NOT NULL,
  trigger_embedding VECTOR(1536),
  context JSONB NOT NULL DEFAULT '{}',
  actions JSONB NOT NULL DEFAULT '[]',
  final_outcome TEXT NOT NULL CHECK (final_outcome IN ('success', 'partial', 'failed')),
  confidence FLOAT NOT NULL DEFAULT 0.7 CHECK (confidence >= 0 AND confidence <= 1),
  use_count INT NOT NULL DEFAULT 1,
  last_used_at TIMESTAMPTZ,
  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- Vector similarity index for semantic search
CREATE INDEX behavior_patterns_embedding_idx
  ON public.behavior_patterns
  USING ivfflat (trigger_embedding vector_cosine_ops)
  WITH (lists = 100);

-- RLS policies
ALTER TABLE public.behavior_patterns ENABLE ROW LEVEL SECURITY;

CREATE POLICY "Users can view own patterns" ON public.behavior_patterns
  FOR SELECT USING (auth.uid() = user_id);

// v1.x - No changes needed, existing methods unchanged
const client = new MemoryIntelligenceClient({ apiKey: 'lano_xxx' });
await client.analyzePatterns({ userId, timeRangeDays: 30 });

// v2.0 - New behavior methods available
await client.recordBehavior({ userId, trigger, context, actions, finalOutcome });
await client.recallBehavior({ userId, context });
await client.suggestBehavior({ userId, currentState });