@triedotdev/mcp 1.0.81 → 1.0.83

package/README.md

@@ -16,9 +16,11 @@
 
 Trie exists so you can maintain multiple codebases as one person without losing your mind. 
 
-Every bug you fix teaches Trie a pattern that protects all your projects. Every incident you report becomes institutional knowledge that travels with your code. 
+Every bug you fix teaches Trie a pattern that protects all your projects. Every incident you report becomes institutional knowledge that travels with your code. Every decision you make—and the tradeoffs you considered—gets remembered across Cursor, Claude Code, CLI, and CI/CD.
 
-Instead of burning tokens on the same questions across different repos or forgetting why you architected something a certain way six months ago, Trie remembers for you. The result is faster development with fewer production fires, because your personal AI agent gets smarter every time something breaks instead of starting from zero in every conversation.
+Instead of burning tokens on the same questions across different repos or forgetting why you architected something a certain way six months ago, Trie remembers for you. Instead of losing track of edge cases and tradeoffs as you switch between tools, Trie maintains system coherence. The result is faster development with fewer production fires, because your personal AI agent gets smarter every time something breaks instead of starting from zero in every conversation.
+
+**Your thinking and planning keep up with code generation. Your decisions persist across tools. Your edge cases don't get forgotten.**
 
 ## Quick Start
 
@@ -65,7 +67,11 @@ trie bad   # Pattern is bad
 
 Building apps with AI tools like Cursor and Claude Code is incredibly fast - but maintaining them alone is a nightmare. You fix a bug and forget why it happened. The same issues keep coming back. Your codebase grows faster than your memory of it.
 
-Trie solves this by being your persistent memory. It keeps a ledger so it remembers what broke before, learns patterns across your projects, and warns you before you ship risky code. Tools like Cursor Bugbot are great, but just flagging issues isn't going to help you avoid similar patterns in the future. With Trie, you'll find quickly that you end up architecting apps and prompting better.
+**The real challenge isn't generating code—it's maintaining it.** Real software has countless edge cases. Every architectural decision involves tradeoffs. As you switch between Cursor, Claude Code, terminal, and CI/CD, context gets lost. You make a decision in one tool, forget it in another, and repeat the same mistakes.
+
+You shipped an MVP. You've got traction. Maybe even paying customers. Now you're in the maintenance phase—where the hard work happens. Where you handle edge cases, make tradeoffs, and keep the system coherent as it grows. Where you need your thinking and planning to keep pace with rapid code generation.
+
+Trie remembers your decisions across tools, tracks the tradeoffs you've made, and maintains system coherence as your codebase evolves. It solves this by being your persistent memory. It keeps a ledger so it remembers what broke before, learns patterns across your projects, and warns you before you ship risky code. Tools like Cursor Bugbot are great, but just flagging issues isn't going to help you avoid similar patterns in the future. With Trie, you'll find quickly that you end up architecting apps and prompting better.
 
 ## Key Features
 
@@ -73,11 +79,15 @@ Trie solves this by being your persistent memory. It keeps a ledger so it rememb
 - **Git-based storage** - Your project's memory travels with your code in `.trie/` folder
 - **Cross-project learning** - Patterns discovered in one project help prevent bugs in others
 - **Incident tracking** - Build a searchable history of what went wrong and why
+- **Decision memory** - Remembers architectural choices and tradeoffs across Cursor, Claude Code, CLI, and CI/CD
+- **Context that travels** - Your thinking and planning keep up with code generation across all your tools
 
 ### Intelligent Analysis
 - **26 built-in scouts** - Automated analyzers for security, performance, accessibility, and more
 - **Custom skills** - Add external analyzers from the community
 - **Risk scoring** - Intelligent priority ranking based on your actual incident history
+- **Edge case detection** - Identifies recurring issues and patterns you've hit before
+- **System coherence** - Tracks relationships between files, changes, incidents, fixes, and decisions
 
 ### Development Integration
 - **Git hooks** - Automatic checks before commits and pushes
@@ -108,6 +118,7 @@ your-project/
 │   ├── memory/          # Incident history
 │   ├── patterns/        # Learned patterns
 │   ├── context.json     # Project knowledge graph
+│   ├── context.db       # SQLite graph (decisions, relationships)
 │   └── config.json      # Settings
 ├── src/
 └── .git/
@@ -119,6 +130,17 @@ The `.trie/` folder commits with your code, so your project's intelligence is pr
 - Team members
 - Different machines
 
+### Decision Memory Across Tools
+
+Trie maintains a **Context Graph** that tracks decisions, tradeoffs, and architectural choices:
+
+- **Decision nodes** store why you made certain choices and what tradeoffs were considered
+- **Cross-tool access** - Cursor, Claude Code, CLI, and CI/CD all read from the same `.trie/` folder
+- **Context trail** - Knows which environment ran which analysis and when
+- **Relationship tracking** - Files ↔ Changes ↔ Incidents ↔ Fixes ↔ Decisions
+
+When you switch from Cursor to Claude Code to terminal, Trie remembers. Your thinking and planning keep up with code generation because every tool shares the same memory.
+
 ## Core Workflow
 
 ### 1. Teaching Phase
@@ -127,6 +149,7 @@ The `.trie/` folder commits with your code, so your project's intelligence is pr
 trie tell "Payment processing failed for EU customers"
 
 # Trie learns: "payments/" + "EU" + "failed" = high risk pattern
+# Also records: decision context, affected files, tradeoffs made
 ```
 
 ### 2. Prevention Phase
@@ -136,6 +159,7 @@ git add src/payments/eu-handler.js
 git commit -m "Update EU payment logic"
 
 # Trie warns: "This area broke 2 weeks ago with EU payments. Consider extra testing."
+# Context: Remembers the decision you made last time, the edge case that caused the issue
 ```
 
 ### 3. Feedback Loop
@@ -147,8 +171,29 @@ trie ok
 trie bad
 
 # Trie adjusts confidence for similar future warnings
+# Also updates: decision patterns, edge case recognition, tradeoff understanding
 ```
 
+### 4. Maintenance Phase
+
+This is where Trie shines. As your app grows and you handle edge cases:
+
+```bash
+# Working in Cursor, you make a decision about error handling
+# Trie records it in the context graph
+
+# Switch to Claude Code later
+# Same context graph, same decisions remembered
+
+# Push from terminal
+# Git hooks check against your full history of decisions and incidents
+
+# CI/CD runs
+# Same checks, same memory, same coherence
+```
+
+**Edge cases, tradeoffs, and system coherence**—Trie handles the hard part that can't be automated by remembering what you decided, why you decided it, and what happened as a result.
+
 ## Advanced Features
 
 ### Goals & Hypotheses
@@ -173,6 +218,25 @@ trie watch
 
 Interactive panels for goals, memory, scout activity, and more.
 
+**Running in Background:**
+To keep `trie watch` running in the background, use `screen` or `tmux`:
+
+```bash
+# Using screen
+screen -S trie-watch
+trie watch
+# Press Ctrl+A then D to detach
+# Reattach with: screen -r trie-watch
+
+# Using tmux
+tmux new -s trie-watch
+trie watch
+# Press Ctrl+B then D to detach
+# Reattach with: tmux attach -t trie-watch
+```
+
+This allows you to keep the guardian running while using other terminals. The interactive dashboard will be available when you reattach.
+
 ### JIT Defect Prediction ("Gotchas")
 Trie connects to your issue tracker and project history to predict problems *while you work*:
 
@@ -353,6 +417,10 @@ trie pause       # Disable warnings for 1 hour
 ### Watch Mode
 ```bash
 trie watch       # Start interactive monitoring dashboard
+
+# Run in background with screen/tmux:
+screen -S trie-watch && trie watch    # Detach: Ctrl+A, D
+tmux new -s trie-watch && trie watch  # Detach: Ctrl+B, D
 ```
 
 ## Configuration