@triedotdev/mcp 1.0.138 → 1.0.139

package/README.md

@@ -1,30 +1,36 @@
-# Trie: Trainable AI Agent for AI-Generated Codebases
+# Trie: Governance for Teams That Ship with AI
 
-**Your autonomous agent that learns from every incident, extracts decisions from every change, and predicts problems before they happen.**
+**The ledger that keeps your work compliant when agents and humans ship together—so you ship the right thing every time.**
 
 [![Download Workspace](https://img.shields.io/badge/Download-Trie%20Workspace-blue)](https://www.trie.dev) [![Follow on X](https://img.shields.io/badge/Follow-@louiskishfy-1DA1F2?logo=x)](https://x.com/louiskishfy)
 
 ## What Trie Does
 
-Trie is an **autonomous, trainable AI agent** that maintains a decision ledger for your codebase:
+Trie maintains a **decision ledger** that governs work across agents and humans:
 
 - **Autonomous Operation**: Run `trie watch` and the agent monitors your codebase 24/7
 - **Intelligent Extraction**: Automatically extracts decisions, facts, blockers from every change
-- **Ledger**: Builds institutional knowledge that travels from Cursor/Claude Code → CLI → CI/CD
+- **Cryptographic governance ledger**: Stores decisions, incidents, and fixes in a tamper-evident chain—the shared memory that travels from Cursor/Claude Code → CLI → CI/CD, solving the context-across-tools problem
 - **Predictive Intelligence**: `trie gotcha` queries the ledger to predict problems before they happen
 - **Continuous Learning**: Feed it incidents with `trie tell`, teach it patterns with your history
 
-The agent learns from every incident, decision, and fix. When you ship, Trie remembers. When something breaks, Trie learns. Over time, your agent gets better at predicting what will go wrong before it does.
+The ledger learns from every incident, decision, and fix. When you ship, Trie remembers. When something breaks, Trie learns. Over time, everyone on the team—human and agent—gets better at predicting what will go wrong before it does.
+
+### The Context-Across-Tools Problem (and How the Ledger Solves It)
+
+**The problem**: When work happens across Cursor, Claude Code, VS Code, the terminal, and CI/CD, context fragments. An agent makes a decision in one tool; a human forgets it in another. Each environment has its own memory—or none at all. You burn tokens re-explaining the same constraints, or worse, ship code that violates decisions made elsewhere.
+
+**The solution**: Trie stores important information in a **cryptographic governance ledger**—a tamper-evident, append-only chain of blocks. Every decision, incident, fix, and tradeoff gets written to the ledger. Because the ledger lives in your `.trie/` folder and syncs across your team, **every tool reads from the same source of truth**. Cursor, Claude, the CLI, and CI/CD all query the same blocks. No more context loss. No more conflicting memories. The ledger is the shared brain that keeps agents and humans aligned across every tool you use.
 
 ## Goal
 
-**Trie is your personal AI agent that carries context across tools.**
+**Trie is the governance layer for teams where agents and humans ship together.**
 
-Every bug you fix teaches the agent 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 extracted and stored automatically by the agent.
+Every bug you fix teaches the ledger 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 extracted and stored automatically. The ledger keeps work compliant so you ship the right thing every time.
 
-Instead of burning tokens on the same questions across different repos or forgetting why you architected something a certain way six months ago, **your agent remembers for you**. Instead of losing track of edge cases and tradeoffs as you switch between tools, **your agent maintains system coherence**.
+Instead of burning tokens on the same questions across different repos or forgetting why you architected something a certain way six months ago, the ledger remembers for everyone. Instead of agents and humans stepping on each other's decisions, the ledger maintains system coherence.
 
-The result is faster development with fewer production fires, because **your agent gets smarter every time something breaks** instead of starting from zero in every conversation.
+The result: faster development with fewer production fires, because the ledger gets smarter every time something breaks—and every agent and human on the team benefits.
 
 ### How the Agent Works
 
@@ -35,7 +41,7 @@ The result is faster development with fewer production fires, because **your age
 5. **`trie tell`** - Feed agent incidents to improve its predictions
 6. **Agent Learns** - Gets better at predicting what matters in YOUR codebase
 
-**Your thinking and planning keep up with code generation. Your decisions persist across tools. Your edge cases don't get forgotten. Your agent handles it all.**
+Your decisions persist across tools. Your edge cases don't get forgotten. The ledger keeps agents and humans compliant—so you ship the right thing every time.
 
 ## Quick Start
 
@@ -70,13 +76,13 @@ trie bad   # Prediction was wrong
 
 ## Why Trie Exists
 
-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.
+The real challenge isn't generating code—it's governance. When some of your teammates are agents and you're working with multiple humans, context fragments. An agent makes a decision in Cursor, a human forgets it in Claude Code, another agent ships something that breaks what you fixed last week. You're not just maintaining a codebase—you're coordinating a mixed team where work happens across tools, models, and people.
 
-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.
+The ledger is the answer. Trie keeps a tamper-evident record of decisions, incidents, and tradeoffs so everyone—human and agent—stays compliant with what you've already learned. Ship the right thing every time. That's the competitive advantage. Software margins are compressing; pure application software is becoming a fundamentally different, worse category. The teams that can coordinate agents and humans, that can scale contributors without losing coherence, will win.
 
-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.
+Cursor is building toward self-driving codebases—agents that merge PRs, manage rollouts, and monitor production. We're moving from a world where developers use agents to create diffs to one where agents ship tested features end-to-end. The closer we march toward self-driving systems and AGI, the more important governance becomes. That shift requires tooling that coordinates work across many agents and models that learn from past runs. Trie is optimized for coordination and collaboration with both humans and agents. It keeps your work compliant, scales your contributors (human and AI), and turns your decision history into durable institutional knowledge.
 
-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.
+Tools like Cursor Bugbot flag issues—but flagging doesn't help you avoid similar patterns in the future. Trie remembers what broke, learns across projects, and warns before you ship risky code. You end up architecting better and prompting better because the ledger enforces coherence.
 
 ## Key Features
 
@@ -86,7 +92,8 @@ Trie remembers your decisions across tools, tracks the tradeoffs you've made, an
 - 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, VS Code, CLI, and CI/CD.
-- Context that travels - Your thinking and planning keep up with code generation across all your tools.
+- Cryptographic governance ledger - Chain-of-blocks, append-only, tamper-evident; solves the context-across-tools problem; every tool reads from the same source of truth.
+- Governance that travels - The ledger keeps agents and humans compliant across all your tools.
 
 ### Intelligent Analysis
 
@@ -126,10 +133,14 @@ your-project/
 │   ├── warm/            # Queryable decisions DB
 │   │   └── decisions.db # SQLite database
 │   ├── cold/            # Archived history
-│   ├── memory/          # Incident history
+│   ├── memory/          # Incident history + ledger.json (cryptographic ledger)
 │   ├── patterns/        # Learned patterns
 │   ├── context.json     # Project knowledge graph
 │   └── config.json      # Settings
+├── .trie-shared/        # Shared ledger for team sync (optional)
+│   ├── active/          # Recent blocks
+│   ├── archived/        # Compressed old blocks
+│   └── ledger-manifest.json
 ├── src/
 └── .git/
 ```
@@ -143,18 +154,18 @@ Different machines
 
 ### Decision Memory Across Tools
 
-Trie maintains a Context Graph that tracks decisions, tradeoffs, and architectural choices:
+Trie solves the context-across-tools problem with a **cryptographic governance ledger**: an append-only, tamper-evident chain of blocks that stores decisions, incidents, fixes, and tradeoffs. Every tool—Cursor, Claude, VS Code, CLI, CI/CD—reads from the same ledger in `.trie/`, so there is no context fragmentation.
 
-Decision nodes store why you made certain choices and what tradeoffs were considered  
-Cross-tool access - Cursor, Claude, VS 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
+- **Decision nodes** store why you made certain choices and what tradeoffs were considered
+- **Cross-tool access** - Cursor, Claude, VS 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.
+When you switch from Cursor to Claude Code to terminal—or when different agents and humans work in parallel—Trie remembers. Every tool shares the same ledger, so governance stays consistent.
 
 ### Signal Extraction: Context Without Pollution
 
-**The Problem**: Agents drown in raw data. Dumping 10,000 lines of logs, 500 Slack messages, and 200 commits into context is expensive and ineffective.
+The Problem: Agents drown in raw data. Dumping 10,000 lines of logs, 500 Slack messages, and 200 commits into context is expensive and ineffective.
 
 **Trie's Solution**: Extract signal, not noise.
 
@@ -181,7 +192,7 @@ When you switch from Cursor to Claude Code to terminal, Trie remembers. Your thi
 
 #### MCP Query Tools
 
-Agents don't get dumps—they **query** for what they need:
+Agents don't get dumps—they query for what they need:
 
 ```typescript
 // Agent queries decision ledger
@@ -196,7 +207,7 @@ trie_get_decisions({
 // 2. "EU customers need VAT validation" (2 months ago)
 ```
 
-**Why this matters**: Context management IS the product. Agents get the right information at the right moment, not everything dumped at once.
+Why this matters: context management IS the product. Agents get the right information at the right moment, not everything dumped at once.
 
 ## Core Workflow
 
@@ -214,7 +225,7 @@ trie status                   # Check overall project health
 # Trie's Context Graph remembers why you made choices and what happened
 ```
 
-**Pro tip:** The moment something goes sideways, check Trie again. Don't keep pushing—re-plan with historical context. Trie shows you what broke before, what decisions were made, and what edge cases caused issues. Use that knowledge to inform your plan, then let your AI tools implement it.
+Pro tip: The moment something goes sideways, check Trie again. Don't keep pushing—re-plan with historical context. Trie shows you what broke before, what decisions were made, and what edge cases caused issues. Use that knowledge to inform your plan, then let your AI tools implement it.
 
 ### 1. Teaching Phase
 
@@ -250,16 +261,16 @@ trie bad
 # Also updates: decision patterns, edge case recognition, tradeoff understanding
 ```
 
-### 4. Maintenance Phase
+### 4. Governance Phase
 
-This is where Trie shines. As your app grows and you handle edge cases:
+This is where Trie shines. As your team grows—more humans, more agents, more tools:
 
 ```bash
-# Working in Cursor, you make a decision about error handling
-# Trie records it in the context graph
+# Working in Cursor, an agent makes a decision about error handling
+# Trie records it in the ledger
 
-# Switch to Claude Code later
-# Same context graph, same decisions remembered
+# A teammate switches to Claude Code later
+# Same ledger, same decisions, same compliance
 
 # Push from terminal
 # Git hooks check against your full history of decisions and incidents
@@ -268,7 +279,7 @@ This is where Trie shines. As your app grows and you handle edge cases:
 # 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.
+Edge cases, tradeoffs, and system coherence—Trie handles governance by remembering what was decided, why it was decided, and what happened as a result. When agents and humans ship together, the ledger keeps everyone compliant.
 
 ## Advanced Features
 
@@ -332,6 +343,116 @@ trie gotcha
 
 Trie will warn you if your current task correlates with historical regressions or high-risk signatures.
 
+### Integrations: Linear, GitHub & Cursor Cloud Agent
+
+**Linear** — Sync active tickets for JIT defect prediction:
+
+```bash
+trie linear auth <your-api-key>
+trie linear sync
+```
+
+Or via MCP: `trie_linear_sync` — syncs tickets into the context graph for gotcha predictions.
+
+**GitHub** — Sync open PRs and issues into the context graph:
+
+```bash
+# Via MCP (Cursor/Claude)
+trie_github_sync
+```
+
+Links PRs to changed files and to Linear tickets mentioned in PR descriptions. Requires `GITHUB_TOKEN` (repo scope for private repos, public_repo for public).
+
+**Cursor Cloud Agent** — Dispatch high-risk issues to Cursor's cloud for verified, test-passing fixes:
+
+```bash
+# Via MCP
+trie_cloud_fix action:configure apiKey:"key-..."
+trie_cloud_fix action:dispatch issueIds:["issue-1", "issue-2"]
+```
+
+The cloud agent runs in an isolated VM, applies the fix, runs tests, captures screenshots, and opens a PR. Requires `CURSOR_API_KEY`. Use `trie_fix action:route` first to see which issues qualify.
+
+### Fix Triage System
+
+Trie routes each issue to one of three fix strategies based on a scoring system:
+
+| Strategy | When | Action |
+|----------|------|--------|
+| **inline-auto** | Trivial, auto-fixable (score < 0) | Apply fix automatically |
+| **local-ai** | Moderate risk (score 0–3) | `trie_fix` — local AI applies fix |
+| **cloud-agent** | High risk (score ≥ 4) | `trie_cloud_fix` — Cursor cloud agent |
+
+Scoring signals: Issue shape (effort, severity, CWE, OWASP), code context (tests, auth/crypto/payments), occurrence history (how often seen), pipeline context (linked PR/ticket), and user config.
+
+```bash
+# See routing plan before applying
+trie_fix action:route
+```
+
+### Pipeline View
+
+Get a consolidated view of your work across Linear, GitHub, and Trie:
+
+```bash
+# Via MCP
+trie_pipeline                    # Full status: tickets, PRs, issues, coverage gaps
+trie_pipeline action:coverage    # Only Trie issues with no ticket/PR
+trie_pipeline action:create_tickets issueIds:["id1","id2"]  # Open Linear tickets for uncovered issues
+```
+
+### Cryptographic Governance Ledger
+
+Trie uses a **chain-of-blocks ledger** for tamper-evident incident history and team sync. The ledger transforms from isolated per-developer chains into a collaborative, distributed cryptographic ledger that scales to teams while maintaining integrity.
+
+**Architecture:**
+- **Chained blocks** — Each block links to the previous via hash; genesis block starts the chain
+- **Merkle roots** — Block contents hashed for integrity verification
+- **Author attribution** — Each block records who added it; git commit correlation for developer attribution
+- **Version 2 format** — Syncable blocks with backwards compatibility for v1 ledgers
+
+**Shared storage** (`.trie-shared/`):
+
+```
+.trie-shared/
+├── ledger-manifest.json    # Global chain metadata + index
+├── active/                 # Hot storage (recent blocks)
+│   ├── 2024-01-20.json
+│   └── 2024-01-21.json
+└── archived/               # Cold storage (compressed)
+    ├── 2024-01.tar.gz      # Monthly archives
+    └── 2023-12.tar.gz
+```
+
+**Compression & scalability:**
+- Automatic archiving after 30 days
+- gzip compression with configurable levels (90%+ space savings)
+- Hot/cold storage tiers; lazy loading of archived content
+
+**Conflict resolution:** Divergent chains merge with timestamp or longest-chain strategy; entry deduplication across developer chains.
+
+**Git integration:** Auto-sync via `trie sync hooks --install` — pre-push and post-merge hooks keep local and shared ledgers in sync. Commit correlation and developer attribution from git history.
+
+**Backwards compatibility:** Automatic migration of v1 ledgers; legacy detection and zero-data-loss upgrade.
+
+```bash
+# Sync commands
+trie sync init              # Initialize shared storage
+trie sync pull              # Pull shared updates (auto-migrates legacy)
+trie sync push              # Push local changes
+trie sync status            # Show sync state, conflicts
+trie sync migrate           # Manually migrate legacy v1 ledger
+trie sync hooks --install   # Install pre-push/post-merge auto-sync hooks
+
+# Ledger commands
+trie ledger verify          # Validate chain integrity
+trie ledger history         # Show chain with author attribution
+trie ledger stats           # Block counts, entries, severity breakdown
+trie ledger diff            # Compare local vs shared
+trie ledger compress        # Manually archive old blocks
+trie ledger storage         # Detailed storage usage stats
+```
+
 ### Integration with AI Coding Tools
 
 Trie provides MCP (Model Context Protocol) tools for seamless integration with Claude, Cursor, and other AI assistants:
@@ -340,9 +461,16 @@ Trie provides MCP (Model Context Protocol) tools for seamless integration with C
 trie_tell - Report incidents and extract structured signals  
 trie_check - Quick risk assessment  
 trie_memory - Search incident history  
-trie_fix - Apply suggested fixes
+trie_fix - Apply suggested fixes (use action:route to see triage plan)  
+trie_cloud_fix - Dispatch to Cursor cloud agent for verified fixes
+
+**Integration Tools:**  
+trie_linear_sync - Sync active Linear tickets  
+trie_github_sync - Sync open PRs and issues from GitHub  
+trie_github_branches - Fetch branches with latest commit info (which branch has latest updates)  
+trie_pipeline - Consolidated view of tickets, PRs, issues, coverage gaps
 
-**Query Tools (NEW - Signal Extraction):**  
+**Query Tools (Signal Extraction):**  
 trie_get_decisions - Query decisions with filters (tags, time, file)  
 trie_get_blockers - Get active blockers only  
 trie_get_related_decisions - Find related context  
@@ -433,7 +561,9 @@ For Claude (MCP): Add to your MCP settings:
       "args": ["mcp"],
       "env": {
         "ANTHROPIC_API_KEY": "your-api-key-here",
-        "LINEAR_API_KEY": "your-key"
+        "LINEAR_API_KEY": "your-key",
+        "GITHUB_TOKEN": "your-github-token",
+        "CURSOR_API_KEY": "your-cursor-key"
       }
     }
   }
@@ -474,6 +604,23 @@ trie goal list                   # View progress
 trie linear sync                 # Sync Linear tickets for intent context
 ```
 
+### Ledger & Sync
+
+```bash
+trie ledger verify               # Verify chain integrity
+trie ledger history              # Show blocks with author attribution
+trie ledger stats                # Block counts, entries, severity
+trie ledger diff                # Compare local vs shared ledger
+trie ledger compress             # Archive old blocks
+trie ledger storage              # Storage usage stats
+trie sync init                   # Initialize shared ledger
+trie sync pull                   # Pull from shared storage
+trie sync push                   # Push local blocks to shared
+trie sync status                 # Show sync state and conflicts
+trie sync migrate                # Migrate legacy v1 ledger
+trie sync hooks --install        # Install auto-sync git hooks
+```
+
 ### Feedback & Training
 
 ```bash
@@ -644,8 +791,6 @@ node fix-goals.js "NO EMOJIS"
 trie goal add "NO EMOJIS"
 trie goal list
 ```
-See [Goal Detection Fix](./docs/GOAL_DETECTION_FIX.md) for details.
-
 ### Getting Help
 - Issues: [Report bugs and request features](https://x.com/louiskishfy)
 

package/dist/{autonomy-config-TZ6HF4FA.js → autonomy-config-ZCOSTMPD.js}

@@ -10,7 +10,7 @@ import {
   shouldAutoFix,
   shouldBlockPush,
   trackIssueOccurrence
-} from "./chunk-J5EMP4XW.js";
+} from "./chunk-5KJ4UJOY.js";
 import "./chunk-SH7H3WRU.js";
 import "./chunk-APMV77PU.js";
 import "./chunk-DGUM43GV.js";
@@ -27,4 +27,4 @@ export {
   shouldBlockPush,
   trackIssueOccurrence
 };
-//# sourceMappingURL=autonomy-config-TZ6HF4FA.js.map
+//# sourceMappingURL=autonomy-config-ZCOSTMPD.js.map