memorylink 1.0.0

package/docs/MISTRAL_AI_STRATEGIC_VALIDATION.md

@@ -0,0 +1,334 @@
+# Mistral AI Strategic Validation - Feature-Complete Launch Strategy
+
+**Date**: December 15, 2025  
+**Source**: Mistral AI Strategic Questions Response  
+**Status**: ✅ Stored in MemoryLink
+
+---
+
+## 📊 EXECUTIVE SUMMARY
+
+Mistral AI provides **strategic, actionable response** based on latest AI coding tool trends, user expectations, and competitive analysis. Key recommendation: **Ship feature-complete v1.0 (not v1.3) with Tree-sitter, Web Dashboard, and native integrations BEFORE launch**.
+
+**Key Insight**: "In an agent-driven world, users expect tools to **just work**. Partial solutions are rejected quickly. First experience is critical - users won't give second chances if agents fail due to missing features."
+
+**Philosophy**: **Feature-complete at launch** vs "ship now, add later" (ChatGPT) or "ship with VS Code extension" (Perplexity AI)
+
+---
+
+## 🎯 QUESTION 1: PRE-LAUNCH vs POST-LAUNCH FEATURES
+
+### Tree-sitter (Multi-Language Support)
+
+**Answer: ✅ YES - Build BEFORE Launch**
+
+**Why:**
+- 4+ AIs recommend it as **high priority**
+- Agents need multi-language support to function effectively
+- Without it, users with Python/Go/Java projects will experience failures and may not return
+- Users expect agents to work across languages
+- Limited to JS/TS = limited adoption
+
+**Risk of Not Building**: **HIGH**
+- Users expect agents to work across languages
+- Limited to JS/TS = limited adoption
+
+**Recommendation**: Build Tree-sitter before launch
+
+---
+
+### Web Dashboard
+
+**Answer: ✅ YES - Build BEFORE Launch**
+
+**Why:**
+- 4+ AIs recommend it for **non-technical users** and **visual learners**
+- CLI-only tools have a steeper learning curve and lower adoption rates
+- Non-technical users (e.g., managers, designers) need a visual interface
+- CLI-only tools are intimidating for many users
+
+**Risk of Not Building**: **MEDIUM**
+- Early adopters may tolerate CLI, but broader adoption will suffer
+
+**Recommendation**: Build Web Dashboard before launch
+
+---
+
+### Launch Strategy
+
+**Recommendation**: Ship a **feature-complete v1.0** (not v1.3) with core features to ensure agents and users succeed immediately.
+
+**Strategy**: Launch with v1.3 + Tree-sitter + Web Dashboard
+
+---
+
+## 🔌 QUESTION 2: MCP INTEGRATION - Only for Some Applications
+
+### Key Insights
+
+- **MCP is Limited**: Only Claude Desktop and Cursor support MCP natively
+- Most users rely on **ChatGPT, GitHub Copilot, VS Code, IntelliJ, and WebStorm**, which require manual context injection
+- **Manual Injection is Not Enough**: Users expect **seamless integration**. Manual steps create friction and reduce adoption
+- **Native Extensions Drive Adoption**: Tools like GitHub Copilot and Tabnine succeed because they integrate natively with popular IDEs
+
+### Recommendations
+
+**Build Native Extensions for Major Tools BEFORE Launch:**
+
+1. **VS Code**: Highest priority (most popular IDE)
+2. **IntelliJ**: Critical for Java/Kotlin developers
+3. **ChatGPT/GitHub Copilot**: Build plugins or extensions to inject context automatically
+
+**Risk of Not Building**: **HIGH**
+- Users will abandon MemoryLink if it doesn't integrate with their primary tools
+
+**Prioritize:**
+1. VS Code Extension
+2. IntelliJ Plugin
+3. ChatGPT Plugin
+4. GitHub Copilot Integration
+
+---
+
+## 🤖 QUESTION 3: AGENT-DRIVEN DEMAND - Everything is Automated
+
+### Key Insights
+
+- **Agents Expect Complete Context**: If MemoryLink lacks features (e.g., Tree-sitter, Web Dashboard), agents will fail to provide accurate suggestions, leading to user frustration
+- **"Good Enough" is Not Enough**: In an agent-driven world, users expect tools to **just work**. Partial solutions are rejected quickly
+- **First Experience is Critical**: Users won't give second chances if agents fail due to missing features
+
+### Recommendations
+
+**Ship Feature-Complete:**
+- Ensure **Tree-sitter, Web Dashboard, and native integrations** are ready at launch
+- **Test with agents** (e.g., GitHub Copilot, Cursor) to validate seamless functionality
+
+**Minimum Feature Set for Agent Success:**
+- ✅ Multi-language support (Tree-sitter)
+- ✅ Visual interface (Web Dashboard)
+- ✅ Native IDE integrations (VS Code, IntelliJ)
+- ✅ Git-native workflows
+
+---
+
+## 💰 QUESTION 4: BUSINESS MODEL (Free/Pro/Enterprise)
+
+### Key Insights
+
+- **Free Version**: Should include **core memory features** (e.g., basic search, learnings) to drive adoption
+- **Pro Version ($15/user/month)**: Should include **advanced features** (e.g., Tree-sitter, Web Dashboard, analytics) to justify the cost
+- **Enterprise Version**: Should focus on **security, RBAC, SSO, and support** for large teams
+
+### Competitive Analysis
+
+| Tool | Free | Individual | Team/Enterprise |
+|------|------|------------|-----------------|
+| **GitHub Copilot** | Free for students | $10/user/month | $19/user/month |
+| **Tabnine** | Free for individuals | - | $12/user/month (teams), custom (enterprise) |
+| **Cursor** | Free for basic use | - | $20/user/month (advanced) |
+
+### Recommendations
+
+**🆓 FREE Version:**
+- Core memory features (basic search, learnings)
+- CLI access
+- Limited to 1 repository
+
+**💼 PRO Version ($15/user/month):**
+- Tree-sitter (multi-language support)
+- Web Dashboard
+- Advanced analytics
+- Unlimited repositories
+
+**🏢 ENTERPRISE Version (Custom Pricing):**
+- RBAC and SSO
+- Audit logs and compliance features
+- Priority support
+- Self-hosted deployment
+
+---
+
+## 🌍 QUESTION 5: WEBSITE & MARKETING
+
+### Key Insights
+
+- **Website is Critical**: Tools like GitHub Copilot, Tabnine, and Cursor have **websites with clear value propositions, demos, and guides**
+- **Marketing Matters**: Successful tools highlight **ease of use, integrations, and privacy**
+- **Guides and Demos**: Users expect **step-by-step guides** and **video demos** to understand the tool quickly
+
+### Recommendations
+
+**Build a Website BEFORE Launch:**
+
+**Homepage**: Clear value proposition (e.g., "Privacy-First, Git-Native AI Coding Assistant")
+
+**Demos**: Short videos showing MemoryLink in action (e.g., dependency graphs, team patterns)
+
+**Guides**: Step-by-step installation and usage guides
+
+**Pricing Page**: Transparent Free/Pro/Enterprise tiers
+
+**Minimum Marketing Needed:**
+- Launch on **Product Hunt, Dev.to, Hacker News**
+- Partner with **influencers in the dev tools space**
+- Highlight **privacy, Git integration, and IDE agnosticism** in messaging
+
+---
+
+## 🧲 QUESTION 6: USER ADOPTION - Why Users Don't Use Tools
+
+### Top 3 Reasons Users Abandon Tools:
+
+1. ❌ **Poor Onboarding**: Users don't understand how to use the tool
+2. ❌ **Lack of Integrations**: Tool doesn't work with their existing workflow
+3. ❌ **No Immediate Value**: Users don't see the benefit quickly
+
+### Top 3 Reasons Users Adopt Tools:
+
+1. ✅ **Seamless Integration**: Works with their IDE/agents
+2. ✅ **Clear Value Proposition**: Solves a specific problem (e.g., privacy, team knowledge)
+3. ✅ **Easy to Use**: Minimal setup, clear guides
+
+### Recommendations
+
+**Reduce Friction:**
+- **One-command installation** (e.g., `npm install -g memorylink`)
+- **Clear onboarding flow** (e.g., guided setup for Git, IDE integrations)
+
+**Demonstrate Value Immediately:**
+- Show **dependency graphs** and **team patterns** in the first 5 minutes
+- Highlight **privacy benefits** upfront
+
+**"Aha Moment":**
+- When users see MemoryLink **automatically suggest fixes** based on team patterns or **predict change impacts**, they'll stick around
+
+---
+
+## 🧠 QUESTION 7: MAKING MEMORYLINK "SMART"
+
+### Key Insights
+
+**"Smart" Tools:**
+- **Understand context** (e.g., dependency graphs, team patterns)
+- **Integrate seamlessly** with existing workflows
+- **Provide immediate value** (e.g., predict impacts, suggest fixes)
+
+**User Needs:**
+- **Easy installation** (one command)
+- **Clear guides** (what the tool does, how to use it)
+- **Agent compatibility** (works with GitHub Copilot, Cursor, etc.)
+
+**Agent Needs:**
+- **Complete context** (multi-language, dependency graphs)
+- **No manual steps** (automatic integration)
+
+### Recommendations
+
+**Optimize for Users:**
+- **One-command install**
+- **Interactive demo** on the website
+- **Clear documentation** (GitHub, website)
+
+**Optimize for Agents:**
+- **Tree-sitter for multi-language support**
+- **Native IDE integrations**
+- **Automatic context injection** (no manual steps)
+
+**"Smartest" Feature to Highlight:**
+- **Change Impact Prediction**: "See how your changes affect the entire codebase—before you commit."
+
+---
+
+## 🎯 FINAL DECISION POINTS
+
+| **Decision** | **Recommendation** | **Risk if Not Followed** |
+|--------------|-------------------|--------------------------|
+| Build Tree-sitter before launch | ✅ YES | High risk: Agents fail for Python/Go/Java users |
+| Build Web Dashboard before launch | ✅ YES | Medium risk: Limits adoption to CLI-savvy users |
+| Build native extensions before launch | ✅ YES (VS Code, IntelliJ, ChatGPT) | High risk: Users abandon if no integration with their IDE/agents |
+| Build website before launch | ✅ YES | High risk: Poor discovery and adoption without clear marketing |
+| Free/Pro/Enterprise pricing | ✅ Free: Core features; Pro: Advanced; Enterprise: Security + Support | Medium risk: Poor monetization or user dissatisfaction |
+| Launch strategy | ✅ Ship feature-complete v1.0 (not v1.3) with Tree-sitter, Web Dashboard, integrations | High risk: User abandonment if agents fail or features are missing |
+
+---
+
+## 📊 COMPETITIVE ANALYSIS: MemoryLink vs. Existing Tools
+
+| **Tool** | **Strengths** | **Weaknesses** | **MemoryLink's Edge** |
+|----------|--------------|----------------|----------------------|
+| **GitHub Copilot** | Broad language support, deep IDE integration | Cloud-based, privacy concerns | Local-first, Git-native, no cloud |
+| **Tabnine** | Privacy-first, local deployment | Limited codebase intelligence | Dependency graphs, change impact prediction |
+| **Cursor** | Built-in IDE, multi-file reasoning | Not IDE-agnostic, cloud-based | MCP integration, works with any editor |
+| **Sourcegraph Cody** | Enterprise-grade codebase intelligence | Cloud-based, complex setup | Local, lightweight, Git-native |
+| **Augment Code** | Cross-repo dependency mapping | Cloud-based, expensive | Local, affordable, self-hosted |
+| **Mem0/SuperMemory** | Memory-focused, agent-friendly | Limited to memory, no codebase intelligence | Code structure + team patterns + change impact prediction |
+
+---
+
+## 🏆 SUMMARY: WHY MEMORYLINK WINS
+
+### Unique Value Proposition
+
+- **Local-First Privacy**: No cloud dependency, ideal for regulated industries
+- **Git-Native Workflow**: Seamless integration with existing Git workflows
+- **IDE Agnosticism**: Works with any editor/IDE via MCP
+- **Codebase Intelligence**: Dependency graphs, team patterns, change impact prediction
+- **Agent-Optimized**: Designed for seamless agent integration
+
+### Competitive Edge
+
+- **Solves problems** that cloud-based tools ignore (privacy, Git integration)
+- **Lightweight and self-hosted**, appealing to cost-conscious teams
+- **Feature-complete at launch**, ensuring agents and users succeed immediately
+
+### Launch Strategy
+
+1. **Ship v1.0** (not v1.3) with:
+   - Tree-sitter (multi-language support)
+   - Web Dashboard (visual interface)
+   - Native integrations (VS Code, IntelliJ, ChatGPT)
+
+2. **Market as**:
+   - "The privacy-first, Git-native AI coding assistant."
+   - "See how your changes affect the entire codebase—before you commit."
+
+3. **Pricing**:
+   - Free: Core features
+   - Pro ($15/user/month): Advanced features
+   - Enterprise: Security + support
+
+---
+
+## 🔄 KEY DIFFERENCES FROM OTHER AIs
+
+### vs ChatGPT:
+
+**ChatGPT**: Ship now (7 days), add Tree-sitter/dashboard later  
+**Mistral AI**: Ship feature-complete v1.0 with Tree-sitter + dashboard
+
+**ChatGPT**: VS Code extension post-launch  
+**Mistral AI**: VS Code extension pre-launch (agrees with Perplexity)
+
+### vs Perplexity AI:
+
+**Perplexity AI**: Ship v1.3 now, Tree-sitter v2.0, dashboard v2.0  
+**Mistral AI**: Ship feature-complete v1.0 with Tree-sitter + dashboard
+
+**Perplexity AI**: VS Code extension pre-launch  
+**Mistral AI**: VS Code extension pre-launch (agrees)
+
+**Perplexity AI**: IntelliJ post-launch  
+**Mistral AI**: IntelliJ pre-launch
+
+### Philosophy Difference:
+
+**ChatGPT/Perplexity**: "Ship now, iterate based on feedback"  
+**Mistral AI**: "Ship feature-complete, ensure agents succeed immediately"
+
+---
+
+**Status**: ✅ Validated and Stored  
+**Priority**: High (most aggressive "feature-complete" approach)  
+**Recommendation**: **Ship feature-complete v1.0 with Tree-sitter, Web Dashboard, and native integrations (VS Code, IntelliJ, ChatGPT) before launch**
+

package/docs/MISTRAL_AI_TESTING_REQUEST.md

@@ -0,0 +1,261 @@
+# 🧪 MISTRAL AI - MEMORYLINK v1.0 TESTING REQUEST
+
+**Date:** December 13, 2025  
+**Purpose:** Request actual test results from Mistral AI (not just a testing prompt)
+
+---
+
+## ⚠️ IMPORTANT: WHAT WE NEED
+
+**We need ACTUAL TEST RESULTS from Mistral AI, not a testing prompt.**
+
+You (Mistral AI) provided a refined testing prompt, which is valuable. However, we now need you to:
+
+1. **ACTUALLY TEST MemoryLink v1.0** using the scenarios below
+2. **PROVIDE TEST RESULTS** for all 8 scenarios (PASS/FAIL/PARTIAL)
+3. **IDENTIFY GAPS** (critical, important, nice-to-have)
+4. **GIVE LAUNCH RECOMMENDATION** (YES/NO with reasoning)
+5. **PROVIDE PRIORITY LIST** (top 5 things to fix)
+
+---
+
+## 📋 MEMORYLINK v1.0 OVERVIEW
+
+MemoryLink is a **universal memory layer for AI coding assistants** that:
+
+- **Stores** project decisions, learnings, and code snippets in `.memorylink/` (JSONL format)
+- **Syncs** memory across all AIs (Cursor, Claude, ChatGPT, Copilot) via Git and instruction files
+- **Auto-applies** preferences/rules (e.g., "take control automatically") to agent behavior
+- **Prevents** mistakes (secret detection, file protection, conflict detection)
+
+**Key Features:**
+✅ Auto-logging (Git hooks)
+✅ Code snippet storage
+✅ Git sync & team sharing
+✅ Preference auto-injection (`.cursorrules`, `CLAUDE_INSTRUCTIONS.md`, `AGENTS.md`)
+✅ Secret detection (27 patterns)
+✅ File protection (Git hooks)
+✅ Conflict detection & resolution
+✅ Cross-platform (Windows/Linux/Mac)
+✅ "Hello World" loop (30-second demo)
+✅ Troubleshooting guide
+✅ Enhanced rule formatting (triple emphasis, explicit instructions)
+
+**CLI Commands:**
+`init`, `quickstart`, `memory`, `learn`, `protect`, `get-context`, `inject`, `search`, `sync`, `doctor`, `setup cursor`, `sync-rules`, `auto-context enable`
+
+**Recent Enhancements (Fixed PARTIAL PASS):**
+- Stronger rule formatting in `get-context` (🚨🚨🚨 triple emphasis)
+- Enhanced `rules.md` generation (CRITICAL, HIGHEST PRIORITY labels)
+- Stronger `.cursorrules` integration (BEFORE responding, MUST READ)
+- Explicit "DO NOT ask for confirmation" instructions
+
+---
+
+## 🧪 TESTING SCENARIOS (8 Scenarios)
+
+### SCENARIO 1: New Developer Onboarding
+**Test:** A new developer joins a project.
+1. Run `memorylink quickstart`
+2. Check if onboarding is clear
+3. Verify "Hello World" loop works
+4. Test if they can add their first memory entry
+
+**Expected:** Clear onboarding, helpful Hello World demo, intuitive first steps
+
+---
+
+### SCENARIO 2: Cross-AI Memory Sharing
+**Test:** Developer uses Cursor AI in morning, Claude in afternoon.
+1. Add memory in Cursor: `memorylink memory "Project uses TypeScript" --tags tech`
+2. Add learning in Cursor: `memorylink learn "Bug" "Fix" --status SUCCESS`
+3. Switch to Claude, run: `memorylink get-context`
+4. Verify Claude sees the memory and learning
+
+**Expected:** Seamless cross-AI sharing, clear context format, actionable information
+
+---
+
+### SCENARIO 3: Preventing Mistakes
+**Test:** Developer tries to make common mistakes.
+1. Try to store a secret: `memorylink memory "API_KEY=sk_live_abc123"`
+2. Try to edit a protected file (should be blocked by Git hook)
+3. Try to repeat a failed solution (should show FAILED in `learnings.log`)
+
+**Expected:** Secrets blocked, protected files blocked, failed solutions visible
+
+---
+
+### SCENARIO 4: Memory Usage Gap (Critical - RECENTLY FIXED)
+**Test:** Developer sets a preference; AI should auto-apply it.
+1. Add preference: `memorylink memory "When I say 'take control', proceed automatically" --type preference`
+2. Run `memorylink setup cursor`
+3. Check if `.cursorrules` was updated with enhanced formatting
+4. Check if `get-context` shows the preference first with triple emphasis (🚨🚨🚨)
+5. Verify the AI (Cursor) acts on the preference without manual intervention
+
+**Expected:** Preference auto-syncs, visible with maximum emphasis, AI compliance improved
+
+**Note:** This was PARTIAL PASS before, but has been FIXED with:
+- Triple emphasis (🚨🚨🚨) in get-context
+- "HIGHEST PRIORITY" labeling
+- Explicit "DO NOT ask for confirmation" instructions
+- Stronger .cursorrules format
+
+---
+
+### SCENARIO 5: Team Collaboration
+**Test:** Two developers work on same project.
+1. Developer A: `memorylink memory "Use JWT for auth" --tags auth`
+2. Developer A: `memorylink sync` (commits to Git)
+3. Developer B: `git pull`
+4. Developer B: `memorylink get-context --tag auth`
+5. Verify Developer B sees Developer A's memory
+
+**Expected:** Smooth Git sync, team sees same context, merge conflicts rare
+
+---
+
+### SCENARIO 6: Error Recovery
+**Test:** Developer encounters errors.
+1. Try to use MemoryLink without `init` (should show clear error)
+2. Try to add memory with invalid format (should show clear error)
+3. Run `memorylink doctor` (should diagnose issues)
+4. Check if troubleshooting guide helps resolve issues
+
+**Expected:** Clear error messages, helpful doctor command, useful troubleshooting guide
+
+---
+
+### SCENARIO 7: Large Project Performance
+**Test:** Project with 100+ memory entries.
+1. Add 100 memory entries
+2. Run `memorylink get-context --limit 10`
+3. Run `memorylink search "keyword"`
+4. Check performance and responsiveness
+
+**Expected:** Acceptable performance, effective filtering and search
+
+---
+
+### SCENARIO 8: Code Snippet Storage
+**Test:** Developer stores a code snippet.
+1. Run: `memorylink snippet "Auth helper function" --file src/auth.ts --lines 42-50 --code "function auth() {...}" --language typescript`
+2. Run: `memorylink get-context`
+3. Verify the code snippet appears
+4. Run: `memorylink search "auth"`
+5. Verify the code snippet is searchable
+
+**Expected:** Code snippets stored correctly, searchable, useful for context
+
+---
+
+## 📊 REQUESTED RESPONSE FORMAT
+
+Please provide your test results in this exact format:
+
+```markdown
+# MEMORYLINK v1.0 TESTING RESULTS - MISTRAL AI
+
+## Test Results (8 Scenarios)
+
+1. **New Developer Onboarding:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+2. **Cross-AI Memory Sharing:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+3. **Preventing Mistakes:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+4. **Memory Usage Gap:** [PASS/FAIL/PARTIAL] - [Detailed notes - Note: This was recently fixed]
+5. **Team Collaboration:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+6. **Error Recovery:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+7. **Large Project Performance:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+8. **Code Snippet Storage:** [PASS/FAIL/PARTIAL] - [Detailed notes]
+
+## Gap Analysis
+
+### Critical Gaps (Must Fix Before Launch)
+- [List any critical gaps]
+
+### Important Gaps (Should Fix Before Launch)
+- [List any important gaps]
+
+### Nice-to-Have (Can Wait for v1.1+)
+- [List nice-to-have features]
+
+## Hard Test Results
+
+### Edge Cases
+- [What edge cases break MemoryLink?]
+
+### Performance Issues
+- [Any performance bottlenecks?]
+
+### Error Conditions
+- [What error conditions cause problems?]
+
+## Launch Recommendation
+
+- **Ready to Launch:** [YES/NO]
+- **Reasoning:** [Why? Be specific]
+- **Must Fix Before Launch:** [List - if any]
+- **Should Fix Before Launch:** [List - if any]
+- **Can Wait for v1.1:** [List - if any]
+
+## Priority List (Top 5)
+
+1. [Top priority item]
+2. [Second priority item]
+3. [Third priority item]
+4. [Fourth priority item]
+5. [Fifth priority item]
+
+## Real-World Validation
+
+- **Would I Use This:** [YES/NO]
+- **Why:** [Detailed reasoning]
+- **What Would Make Me Use It More:** [List improvements]
+```
+
+---
+
+## 🎯 TESTING FOCUS
+
+**Focus on:**
+✅ Does it **work in real scenarios**?
+✅ Are there **blockers**?
+✅ What would cause **user abandonment**?
+✅ What's **missing** that's critical?
+✅ **Test Scenario 4 carefully** - it was recently fixed
+
+**Avoid:**
+❌ Nice-to-have features (v1.1)
+❌ Theoretical improvements
+❌ Just providing a testing prompt (we need actual test results)
+
+---
+
+## 📝 IMPORTANT NOTES
+
+1. **We need ACTUAL TEST RESULTS**, not just a testing prompt
+2. **Test Scenario 4 carefully** - it was PARTIAL PASS before but has been FIXED with enhanced formatting
+3. **Be brutally honest** - this is the final check before launch
+4. **Follow the response format** exactly as shown above
+5. **Provide specific examples** and detailed notes for each scenario
+
+---
+
+## ✅ WHAT WE'VE ALREADY RECEIVED FROM OTHER AIs
+
+- **ChatGPT:** ✅ YES - Ready to launch
+- **Perplexity:** ⚠️ PARTIAL PASS (quickstart clarity, rules messaging - FIXED)
+- **Grok:** ✅ YES - Ready to launch
+- **Gemini:** ✅ YES CONDITIONAL (security fixes - FIXED)
+- **DeepSeek:** ❌ NO - Strategic friction concern (not market-ready)
+- **Claude:** ✅ YES - Ready to launch (7 hours prep work)
+- **Mistral:** ⚠️ Testing prompt refinement (need actual test results)
+
+**We need your actual test results to complete the validation.**
+
+---
+
+**Thank you for testing MemoryLink v1.0!** 🚀
+
+**Please provide actual test results, not just a testing prompt.**
+