supaclaw 1.0.0

package/dist/parsers.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Phase 9: Migration & Import Parsers
+ *
+ * Parsers for converting Clawdbot memory files to OpenClaw Memory database format:
+ * - MEMORY.md → memories table
+ * - memory/*.md → sessions + messages
+ * - TODO.md → tasks table
+ * - LEARNINGS.md → learnings table
+ */
+export interface ParsedMemory {
+    content: string;
+    category: string;
+    importance: number;
+    metadata?: Record<string, any>;
+    created_at?: string;
+}
+export interface ParsedSession {
+    user_id: string;
+    channel?: string;
+    started_at: string;
+    ended_at?: string;
+    summary?: string;
+    messages: ParsedMessage[];
+}
+export interface ParsedMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: string;
+    metadata?: Record<string, any>;
+}
+export interface ParsedTask {
+    title: string;
+    description?: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    priority?: number;
+    due_date?: string;
+    metadata?: Record<string, any>;
+}
+export interface ParsedLearning {
+    category: string;
+    trigger: string;
+    lesson: string;
+    importance: number;
+    applied_count?: number;
+    created_at?: string;
+}
+/**
+ * Parse MEMORY.md into structured memories
+ *
+ * Expected format:
+ * # MEMORY.md
+ *
+ * ## Category Name
+ *
+ * - Memory item [importance: 0.9]
+ * - Another memory [2024-01-28]
+ *
+ * Regular paragraphs are also captured as memories.
+ */
+export declare function parseMemoryMd(filePath: string): ParsedMemory[];
+/**
+ * Parse daily log files (memory/YYYY-MM-DD.md) into sessions and messages
+ *
+ * Expected format:
+ * # 2024-01-28
+ *
+ * ## Session: Trading Research
+ * Started: 09:00
+ *
+ * **User**: What's the stock price of TSLA?
+ *
+ * **Assistant**: Tesla is currently trading at $245.
+ *
+ * **User**: Should I buy?
+ *
+ * Summary: Discussed TSLA stock price...
+ */
+export declare function parseDailyLog(filePath: string, userId?: string): ParsedSession[];
+/**
+ * Parse all daily logs in a directory (memory/*.md)
+ */
+export declare function parseAllDailyLogs(memoryDir: string, userId?: string): ParsedSession[];
+/**
+ * Parse TODO.md into structured tasks
+ *
+ * Expected format:
+ * # TODO
+ *
+ * ## Priority: High
+ * - [ ] Incomplete task
+ * - [x] Completed task
+ * - [~] Cancelled task
+ *
+ * ## Category Name
+ * - [ ] Task with [due: 2024-02-01]
+ */
+export declare function parseTodoMd(filePath: string): ParsedTask[];
+/**
+ * Parse LEARNINGS.md into structured learnings
+ *
+ * Expected format:
+ * # LEARNINGS
+ *
+ * ## Category: Corrections
+ *
+ * **Trigger**: User said "actually, I prefer Rust"
+ * **Lesson**: User prefers Rust over TypeScript
+ * **Importance**: 0.8
+ *
+ * ---
+ *
+ * ## Category: Errors
+ * ...
+ */
+export declare function parseLearningsMd(filePath: string): ParsedLearning[];

package/dist/parsers.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Phase 9: Migration & Import Parsers
+ *
+ * Parsers for converting Clawdbot memory files to OpenClaw Memory database format:
+ * - MEMORY.md → memories table
+ * - memory/*.md → sessions + messages
+ * - TODO.md → tasks table
+ * - LEARNINGS.md → learnings table
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMemoryMd = parseMemoryMd;
+exports.parseDailyLog = parseDailyLog;
+exports.parseAllDailyLogs = parseAllDailyLogs;
+exports.parseTodoMd = parseTodoMd;
+exports.parseLearningsMd = parseLearningsMd;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ============ MEMORY.MD PARSER ============
+/**
+ * Parse MEMORY.md into structured memories
+ *
+ * Expected format:
+ * # MEMORY.md
+ *
+ * ## Category Name
+ *
+ * - Memory item [importance: 0.9]
+ * - Another memory [2024-01-28]
+ *
+ * Regular paragraphs are also captured as memories.
+ */
+function parseMemoryMd(filePath) {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const memories = [];
+    const lines = content.split('\n');
+    let currentCategory = 'general';
+    let currentParagraph = '';
+    let lineNumber = 0;
+    const flushParagraph = () => {
+        if (currentParagraph.trim().length > 0) {
+            memories.push({
+                content: currentParagraph.trim(),
+                category: currentCategory,
+                importance: 0.6,
+                metadata: { source: 'MEMORY.md' }
+            });
+            currentParagraph = '';
+        }
+    };
+    for (const line of lines) {
+        lineNumber++;
+        const trimmed = line.trim();
+        // Skip title and empty lines at paragraph boundaries
+        if (trimmed.startsWith('# ') || trimmed === '') {
+            flushParagraph();
+            continue;
+        }
+        // Category header
+        if (trimmed.startsWith('## ')) {
+            flushParagraph();
+            currentCategory = trimmed.slice(3).trim().toLowerCase();
+            continue;
+        }
+        // List item memory
+        if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+            flushParagraph();
+            let memoryText = trimmed.slice(2).trim();
+            let importance = 0.6;
+            let createdAt;
+            // Extract [importance: X] tags
+            const importanceMatch = memoryText.match(/\[importance:\s*([\d.]+)\]/i);
+            if (importanceMatch) {
+                importance = parseFloat(importanceMatch[1]);
+                memoryText = memoryText.replace(importanceMatch[0], '').trim();
+            }
+            // Extract [YYYY-MM-DD] dates
+            const dateMatch = memoryText.match(/\[(\d{4}-\d{2}-\d{2})\]/);
+            if (dateMatch) {
+                createdAt = dateMatch[1];
+                memoryText = memoryText.replace(dateMatch[0], '').trim();
+            }
+            if (memoryText.length > 0) {
+                memories.push({
+                    content: memoryText,
+                    category: currentCategory,
+                    importance,
+                    created_at: createdAt,
+                    metadata: { source: 'MEMORY.md', line: lineNumber }
+                });
+            }
+            continue;
+        }
+        // Regular text - accumulate into paragraph
+        if (trimmed.length > 0) {
+            currentParagraph += (currentParagraph ? ' ' : '') + trimmed;
+        }
+    }
+    flushParagraph();
+    return memories;
+}
+// ============ DAILY LOG PARSER (memory/*.md) ============
+/**
+ * Parse daily log files (memory/YYYY-MM-DD.md) into sessions and messages
+ *
+ * Expected format:
+ * # 2024-01-28
+ *
+ * ## Session: Trading Research
+ * Started: 09:00
+ *
+ * **User**: What's the stock price of TSLA?
+ *
+ * **Assistant**: Tesla is currently trading at $245.
+ *
+ * **User**: Should I buy?
+ *
+ * Summary: Discussed TSLA stock price...
+ */
+function parseDailyLog(filePath, userId = 'default') {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const sessions = [];
+    const lines = content.split('\n');
+    let currentSession = null;
+    let currentMessage = '';
+    let currentRole = null;
+    // Extract date from filename (YYYY-MM-DD.md)
+    const dateMatch = filePath.match(/(\d{4}-\d{2}-\d{2})/);
+    const fileDate = dateMatch ? dateMatch[1] : new Date().toISOString().split('T')[0];
+    const flushMessage = () => {
+        if (currentMessage.trim() && currentRole && currentSession) {
+            currentSession.messages.push({
+                role: currentRole,
+                content: currentMessage.trim(),
+                timestamp: currentSession.started_at
+            });
+            currentMessage = '';
+            currentRole = null;
+        }
+    };
+    const flushSession = () => {
+        if (currentSession) {
+            sessions.push(currentSession);
+            currentSession = null;
+        }
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Session header
+        if (trimmed.startsWith('## Session:') || trimmed.startsWith('## ')) {
+            flushMessage();
+            flushSession();
+            const sessionName = trimmed.replace(/^## (Session:?\s*)?/, '').trim();
+            currentSession = {
+                user_id: userId,
+                started_at: `${fileDate}T00:00:00Z`,
+                messages: [],
+                summary: sessionName
+            };
+            continue;
+        }
+        // Started/Ended timestamps
+        if (trimmed.startsWith('Started:') && currentSession) {
+            const time = trimmed.replace('Started:', '').trim();
+            currentSession.started_at = `${fileDate}T${time}:00Z`;
+            continue;
+        }
+        if (trimmed.startsWith('Ended:') && currentSession) {
+            const time = trimmed.replace('Ended:', '').trim();
+            currentSession.ended_at = `${fileDate}T${time}:00Z`;
+            continue;
+        }
+        // Summary
+        if (trimmed.startsWith('Summary:') && currentSession) {
+            currentSession.summary = trimmed.replace('Summary:', '').trim();
+            continue;
+        }
+        // Message markers
+        if (trimmed.startsWith('**User**:') || trimmed.startsWith('**User**')) {
+            flushMessage();
+            currentRole = 'user';
+            currentMessage = trimmed.replace(/^\*\*User\*\*:?\s*/, '');
+            continue;
+        }
+        if (trimmed.startsWith('**Assistant**:') || trimmed.startsWith('**Assistant**')) {
+            flushMessage();
+            currentRole = 'assistant';
+            currentMessage = trimmed.replace(/^\*\*Assistant\*\*:?\s*/, '');
+            continue;
+        }
+        if (trimmed.startsWith('**System**:') || trimmed.startsWith('**System**')) {
+            flushMessage();
+            currentRole = 'system';
+            currentMessage = trimmed.replace(/^\*\*System\*\*:?\s*/, '');
+            continue;
+        }
+        // Continue accumulating message content
+        if (currentRole && trimmed.length > 0) {
+            currentMessage += '\n' + trimmed;
+        }
+    }
+    flushMessage();
+    flushSession();
+    // If no sessions were found but there's content, create a default session
+    if (sessions.length === 0 && content.trim().length > 0) {
+        sessions.push({
+            user_id: userId,
+            started_at: `${fileDate}T00:00:00Z`,
+            messages: [{
+                    role: 'system',
+                    content: content,
+                    timestamp: `${fileDate}T00:00:00Z`
+                }],
+            summary: 'Daily log'
+        });
+    }
+    return sessions;
+}
+/**
+ * Parse all daily logs in a directory (memory/*.md)
+ */
+function parseAllDailyLogs(memoryDir, userId = 'default') {
+    if (!(0, fs_1.existsSync)(memoryDir)) {
+        throw new Error(`Directory not found: ${memoryDir}`);
+    }
+    const files = (0, fs_1.readdirSync)(memoryDir)
+        .filter(f => f.match(/^\d{4}-\d{2}-\d{2}\.md$/))
+        .sort();
+    const allSessions = [];
+    for (const file of files) {
+        const filePath = (0, path_1.join)(memoryDir, file);
+        try {
+            const sessions = parseDailyLog(filePath, userId);
+            allSessions.push(...sessions);
+        }
+        catch (err) {
+            console.error(`⚠️  Failed to parse ${file}:`, err);
+        }
+    }
+    return allSessions;
+}
+// ============ TODO.MD PARSER ============
+/**
+ * Parse TODO.md into structured tasks
+ *
+ * Expected format:
+ * # TODO
+ *
+ * ## Priority: High
+ * - [ ] Incomplete task
+ * - [x] Completed task
+ * - [~] Cancelled task
+ *
+ * ## Category Name
+ * - [ ] Task with [due: 2024-02-01]
+ */
+function parseTodoMd(filePath) {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const tasks = [];
+    const lines = content.split('\n');
+    let currentPriority = 1;
+    let currentCategory = 'general';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip title and empty lines
+        if (trimmed.startsWith('# ') || trimmed === '') {
+            continue;
+        }
+        // Category/Section headers
+        if (trimmed.startsWith('## ')) {
+            const header = trimmed.slice(3).trim();
+            // Check for priority indicators
+            if (header.toLowerCase().includes('priority')) {
+                if (header.toLowerCase().includes('high') || header.toLowerCase().includes('urgent')) {
+                    currentPriority = 3;
+                }
+                else if (header.toLowerCase().includes('medium') || header.toLowerCase().includes('normal')) {
+                    currentPriority = 2;
+                }
+                else if (header.toLowerCase().includes('low')) {
+                    currentPriority = 1;
+                }
+            }
+            else {
+                currentCategory = header.toLowerCase();
+            }
+            continue;
+        }
+        // Task items
+        const taskMatch = trimmed.match(/^[-*]\s*\[([ x~])\]\s*(.+)$/i);
+        if (taskMatch) {
+            const statusChar = taskMatch[1];
+            let taskText = taskMatch[2].trim();
+            let status = 'pending';
+            if (statusChar.toLowerCase() === 'x')
+                status = 'completed';
+            if (statusChar === '~')
+                status = 'cancelled';
+            // Extract [due: YYYY-MM-DD] tags
+            let dueDate;
+            const dueDateMatch = taskText.match(/\[due:\s*(\d{4}-\d{2}-\d{2})\]/i);
+            if (dueDateMatch) {
+                dueDate = dueDateMatch[1];
+                taskText = taskText.replace(dueDateMatch[0], '').trim();
+            }
+            if (taskText.length > 0) {
+                tasks.push({
+                    title: taskText,
+                    status,
+                    priority: currentPriority,
+                    due_date: dueDate,
+                    metadata: { source: 'TODO.md', category: currentCategory }
+                });
+            }
+        }
+    }
+    return tasks;
+}
+// ============ LEARNINGS.MD PARSER ============
+/**
+ * Parse LEARNINGS.md into structured learnings
+ *
+ * Expected format:
+ * # LEARNINGS
+ *
+ * ## Category: Corrections
+ *
+ * **Trigger**: User said "actually, I prefer Rust"
+ * **Lesson**: User prefers Rust over TypeScript
+ * **Importance**: 0.8
+ *
+ * ---
+ *
+ * ## Category: Errors
+ * ...
+ */
+function parseLearningsMd(filePath) {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const learnings = [];
+    // Split by --- separators
+    const blocks = content.split(/\n---+\n/);
+    for (const block of blocks) {
+        const lines = block.trim().split('\n');
+        let category = 'general';
+        let trigger = '';
+        let lesson = '';
+        let importance = 0.5;
+        let createdAt;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Category header
+            if (trimmed.startsWith('## ')) {
+                const header = trimmed.slice(3).trim();
+                const catMatch = header.match(/Category:\s*(.+)/i);
+                if (catMatch) {
+                    category = catMatch[1].trim().toLowerCase();
+                }
+                continue;
+            }
+            // Field lines
+            const triggerMatch = trimmed.match(/^\*\*Trigger\*\*:\s*(.+)/i);
+            if (triggerMatch) {
+                trigger = triggerMatch[1].trim();
+                continue;
+            }
+            const lessonMatch = trimmed.match(/^\*\*Lesson\*\*:\s*(.+)/i);
+            if (lessonMatch) {
+                lesson = lessonMatch[1].trim();
+                continue;
+            }
+            const importanceMatch = trimmed.match(/^\*\*Importance\*\*:\s*([\d.]+)/i);
+            if (importanceMatch) {
+                importance = parseFloat(importanceMatch[1]);
+                continue;
+            }
+            const dateMatch = trimmed.match(/^\*\*Date\*\*:\s*(\d{4}-\d{2}-\d{2})/i);
+            if (dateMatch) {
+                createdAt = dateMatch[1];
+                continue;
+            }
+        }
+        // Add if we have at minimum a lesson
+        if (lesson.length > 0) {
+            learnings.push({
+                category,
+                trigger: trigger || 'Unknown trigger',
+                lesson,
+                importance,
+                created_at: createdAt
+            });
+        }
+    }
+    return learnings;
+}

package/migrations/001_initial.sql

@@ -0,0 +1,153 @@
+-- OpenClaw Memory - Initial Schema
+-- Run this in your Supabase SQL editor
+
+-- Enable vector extension for semantic search
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Sessions: Every conversation gets a session
+CREATE TABLE IF NOT EXISTS sessions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  agent_id TEXT NOT NULL,
+  user_id TEXT,
+  channel TEXT,
+  started_at TIMESTAMPTZ DEFAULT NOW(),
+  ended_at TIMESTAMPTZ,
+  summary TEXT,
+  metadata JSONB DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS sessions_agent_id_idx ON sessions(agent_id);
+CREATE INDEX IF NOT EXISTS sessions_user_id_idx ON sessions(user_id);
+CREATE INDEX IF NOT EXISTS sessions_started_at_idx ON sessions(started_at DESC);
+
+-- Messages: Every message in every session
+CREATE TABLE IF NOT EXISTS messages (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  session_id UUID REFERENCES sessions(id) ON DELETE CASCADE,
+  role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system', 'tool')),
+  content TEXT NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  token_count INT,
+  metadata JSONB DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS messages_session_id_idx ON messages(session_id);
+CREATE INDEX IF NOT EXISTS messages_created_at_idx ON messages(created_at);
+
+-- Memories: Long-term memories extracted from sessions
+CREATE TABLE IF NOT EXISTS memories (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  agent_id TEXT NOT NULL,
+  user_id TEXT,
+  category TEXT,
+  content TEXT NOT NULL,
+  importance FLOAT DEFAULT 0.5 CHECK (importance >= 0 AND importance <= 1),
+  source_session_id UUID REFERENCES sessions(id),
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW(),
+  expires_at TIMESTAMPTZ,
+  embedding VECTOR(1536),
+  metadata JSONB DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS memories_agent_id_idx ON memories(agent_id);
+CREATE INDEX IF NOT EXISTS memories_user_id_idx ON memories(user_id);
+CREATE INDEX IF NOT EXISTS memories_category_idx ON memories(category);
+CREATE INDEX IF NOT EXISTS memories_importance_idx ON memories(importance DESC);
+CREATE INDEX IF NOT EXISTS memories_created_at_idx ON memories(created_at DESC);
+
+-- Vector similarity index (for semantic search)
+CREATE INDEX IF NOT EXISTS memories_embedding_idx ON memories 
+  USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+
+-- Entities: People, places, things the agent knows about
+CREATE TABLE IF NOT EXISTS entities (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  agent_id TEXT NOT NULL,
+  entity_type TEXT NOT NULL,
+  name TEXT NOT NULL,
+  aliases TEXT[],
+  description TEXT,
+  properties JSONB DEFAULT '{}',
+  first_seen_at TIMESTAMPTZ DEFAULT NOW(),
+  last_seen_at TIMESTAMPTZ DEFAULT NOW(),
+  mention_count INT DEFAULT 1,
+  embedding VECTOR(1536),
+  
+  UNIQUE(agent_id, entity_type, name)
+);
+
+CREATE INDEX IF NOT EXISTS entities_agent_id_idx ON entities(agent_id);
+CREATE INDEX IF NOT EXISTS entities_type_idx ON entities(entity_type);
+CREATE INDEX IF NOT EXISTS entities_name_idx ON entities(name);
+
+-- Tasks: Persistent task tracking
+CREATE TABLE IF NOT EXISTS tasks (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  agent_id TEXT NOT NULL,
+  user_id TEXT,
+  title TEXT NOT NULL,
+  description TEXT,
+  status TEXT DEFAULT 'pending' CHECK (status IN ('pending', 'in_progress', 'blocked', 'done')),
+  priority INT DEFAULT 0,
+  due_at TIMESTAMPTZ,
+  completed_at TIMESTAMPTZ,
+  source_session_id UUID REFERENCES sessions(id),
+  parent_task_id UUID REFERENCES tasks(id),
+  metadata JSONB DEFAULT '{}',
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS tasks_agent_id_idx ON tasks(agent_id);
+CREATE INDEX IF NOT EXISTS tasks_user_id_idx ON tasks(user_id);
+CREATE INDEX IF NOT EXISTS tasks_status_idx ON tasks(status);
+CREATE INDEX IF NOT EXISTS tasks_priority_idx ON tasks(priority DESC);
+CREATE INDEX IF NOT EXISTS tasks_due_at_idx ON tasks(due_at);
+
+-- Learnings: Self-improvement records
+CREATE TABLE IF NOT EXISTS learnings (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  agent_id TEXT NOT NULL,
+  category TEXT NOT NULL CHECK (category IN ('error', 'correction', 'improvement', 'capability_gap')),
+  trigger TEXT NOT NULL,
+  lesson TEXT NOT NULL,
+  action TEXT,
+  severity TEXT DEFAULT 'info' CHECK (severity IN ('info', 'warning', 'critical')),
+  source_session_id UUID REFERENCES sessions(id),
+  applied_count INT DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  metadata JSONB DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS learnings_agent_id_idx ON learnings(agent_id);
+CREATE INDEX IF NOT EXISTS learnings_category_idx ON learnings(category);
+CREATE INDEX IF NOT EXISTS learnings_severity_idx ON learnings(severity);
+
+-- Function to update updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = NOW();
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Triggers for updated_at
+CREATE TRIGGER memories_updated_at
+  BEFORE UPDATE ON memories
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at();
+
+CREATE TRIGGER tasks_updated_at
+  BEFORE UPDATE ON tasks
+  FOR EACH ROW
+  EXECUTE FUNCTION update_updated_at();
+
+-- Row Level Security (optional - enable if using Supabase auth)
+-- ALTER TABLE sessions ENABLE ROW LEVEL SECURITY;
+-- ALTER TABLE messages ENABLE ROW LEVEL SECURITY;
+-- ALTER TABLE memories ENABLE ROW LEVEL SECURITY;
+-- ALTER TABLE entities ENABLE ROW LEVEL SECURITY;
+-- ALTER TABLE tasks ENABLE ROW LEVEL SECURITY;
+-- ALTER TABLE learnings ENABLE ROW LEVEL SECURITY;