@triedotdev/mcp 1.0.148 → 1.0.149

package/README.md

@@ -7,29 +7,29 @@
 
 ## What Trie Does
 
-Trie is a trainable AI agent that maintains a ledger that governs work across agents and humans:
+Trie is governance for teams where agents and humans ship together. Every decision, direction change, and tradeoff gets recorded in a cryptographic ledger that every contributor—human or agent—reads from and writes to, across every tool in the stack.
 
 - **Autonomous Operation**: Run `trie watch` and the agent monitors your codebase 24/7
 - **Intelligent Extraction**: Automatically extracts decisions, facts, blockers from every change
-- **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
+- **Cryptographic governance ledger**: Tamper-evident, append-only chain of blocks—the shared memory that travels from Cursor/Claude Code → CLI → CI/CD
 - **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 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 work stays coherent not because someone held it together, but because the ledger did. When any contributor flags a direction change, the ledger surfaces the relevant history instantly. When an agent acts, it does so with full context of what was decided before and why.
 
-### The Context-Across-Tools Problem (and How the Ledger Solves It)
+### The Context-Across-Tools Problem
 
-**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 problem**: When work happens across Cursor, Claude Code, VS Code, the terminal, and more, context fragments. An agent makes a decision in one tool; a human forgets it in another. Accountability and context diffuse across tools, models, and people until they belong to no one.
 
-**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.
+**The solution**: Trie stores every decision, incident, fix, and tradeoff in a cryptographic governance ledger—a tamper-evident, append-only chain of blocks that lives in your `.trie/` folder and syncs across your team. Every tool reads from the same source of truth. The ledger surfaces the relevant history instantly in each contributor's native tool. No more context loss. No more conflicting memories.
 
-## Goal
+## Why It Matters
 
-**Trie is the governance layer for teams where agents and humans ship together.**
+Code is solved. The bottleneck isn't building—it's deciding what to build and whether the change aligns with how you got here.
 
-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.
+When agents and non-technical contributors can ship production changes, coordination tools built to manage engineering capacity break down. Linear tells you what's in the queue. GitHub tells you what changed. Neither tells you whether the change aligns with the decisions that came before.
 
-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.
+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 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.
 
@@ -91,54 +91,66 @@ Tools like Cursor Bugbot flag issues—but flagging doesn't help you avoid simil
 
 ## Key Features
 
-### Smart Memory
+### Governance That Scales
 
-- 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, VS Code, CLI, and CI/CD.
-- 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.
+- **Cryptographic ledger** - Tamper-evident, append-only chain of blocks; every tool reads from the same source of truth
+- **True immutability** - Ledger entries never deleted, only marked as corrected; full audit trail for compliance
+- **Decision memory** - Captures architectural choices, tradeoffs, and context across Cursor, Claude, VS Code, CLI, and CI/CD
+- **Judgment artifacts** - Not just what shipped, but why, what was considered, and who decided
+- **Git-based storage** - Your project's memory travels with your code in `.trie/` folder
 
-### Intelligent Analysis
+### Intelligence That Compounds
 
-- 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.
+- **Predictive analysis** - `trie gotcha` queries the ledger to predict problems before they happen
+- **Pattern recognition** - Identifies recurring issues and edge cases from your actual incident history
+- **Cross-project learning** - Patterns discovered in one project help prevent bugs in others
+- **System coherence** - Tracks relationships between files, changes, incidents, fixes, and decisions
+- **Continuous learning** - Gets better at predicting what matters in YOUR codebase over time
 
-### Development Integration
+### Integration Built for Speed
 
-- Git hooks - Automatic checks before commits and pushes.
-- Watch mode - Real-time monitoring while you code.
-- Fast performance - Sub-500ms checks, won't slow down your workflow.
+- **Multiple interfaces** - CLI, MCP tools for Claude/Cursor, visual dashboards, Slack notifications
+- **Git hooks** - Automatic checks before commits and pushes
+- **Watch mode** - Real-time monitoring while you code
+- **Fast performance** - Sub-500ms checks, won't slow down your workflow
+- **Flexible workflow** - Works with any editor, any git workflow, any deployment setup
 
-### Developer Experience
+## How It Works
 
-- Plain English warnings - "This payment flow broke twice before" instead of cryptic codes.
-- Multiple interfaces - CLI, MCP tools for Claude/Cursor, visual dashboards.
-- Flexible workflow - Works with any editor, any git workflow, any deployment setup.
+### Memory Architecture
 
-## How It Works
+Trie maintains two complementary memory systems that work together to provide both fast queries and tamper-evident governance:
+
+**1. Governance Ledger** (`.trie/memory/ledger.json`)
+- **Purpose**: Cryptographic chain of what was detected and when
+- **Properties**: Append-only, tamper-evident, never deleted
+- **Used for**: Audit trail, compliance, historical analysis, gotcha predictions
+- **Immutability**: Entries are marked as corrected, not deleted (see [Ledger Corrections](./docs/LEDGER_CORRECTIONS.md))
 
-### The Trie Agent
+**2. Issue Memory** (`.trie/memory/issues/`)
+- **Purpose**: Fast searchable cache of detected issues
+- **Properties**: Queryable, can be compacted and purged
+- **Used for**: `trie memory search`, pattern recognition, recent issue queries
+- **Lifecycle**: Subject to capacity limits; cleaned up via `trie memory purge` strategies
 
-Trie uses a proactive agent architecture:
+Both systems sync across your team and travel with your codebase. The `.trie/` folder commits with your code, so your project's intelligence is preserved and shared across:
 
-- Analyzes your code for potential issues based on your incident history.
-- The agent decides what matters based on your history.
-- Memory Tree stores incident patterns using a trie data structure for fast lookups.
-- Learning Loop improves predictions based on your feedback.
+Local development  
+CI/CD pipelines  
+Team members  
+Cursor/Claude/VS Code  
+Git hooks
 
-### Memory That Travels
+### File Structure
 
 ```
 your-project/
 ├── .trie/
 │   ├── hot/             # In-memory current session
-│   ├── warm/            # Queryable decisions DB
+│   ├── warm/            # Queryable governance DB
 │   │   └── decisions.db # SQLite database
 │   ├── cold/            # Archived history
-│   ├── memory/          # Incident history + ledger.json (cryptographic ledger)
+│   ├── memory/          # Issue cache + ledger.json (cryptographic ledger)
 │   ├── patterns/        # Learned patterns
 │   ├── context.json     # Project knowledge graph
 │   └── config.json      # Settings
@@ -148,13 +160,7 @@ your-project/
 │   └── ledger-manifest.json
 ├── src/
 └── .git/
-```
-
-The .trie/ folder commits with your code, so your project's intelligence is preserved and shared across:
-
-Local development  
-CI/CD pipelines  
-Team members  
+```  
 Different machines
 
 ### Decision Memory Across Tools
@@ -503,7 +509,7 @@ Git repository
 npm install -g trie
 
 # Or use npx for one-time runs
-npx trie scan
+npx trie watch
 ```
 
 ### Project Setup
@@ -752,6 +758,46 @@ Or manually add to `.trie/config.json`:
 - Critical decision changes
 - Auto-escalation notifications
 
+### Ledger Corrections (Immutable Audit Trail)
+
+The ledger is **append-only** - entries are never deleted. When mistakes happen, use corrections instead:
+
+**Mark entries as corrected:**
+```bash
+# Correct a false positive
+trie ledger correct <entry-id> -r "Expected behavior, not a bug" -t false-positive
+
+# Mark as fixed
+trie ledger correct <entry-id> -r "Fixed in commit abc123"
+
+# Batch corrections
+trie ledger correct entry1 entry2 entry3 -r "Duplicate detections"
+```
+
+**View correction stats:**
+```bash
+# Show correction statistics
+trie ledger corrections
+
+# View history for specific entries
+trie ledger corrections --entries <entry-id1> <entry-id2>
+```
+
+**What happens:**
+- Original entry preserved for audit trail
+- Entry marked with status (`corrected` or `false-positive`)
+- Correction metadata added (timestamp, reason, who)
+- New correction entry appended to ledger
+- Queries automatically filter out corrected entries
+
+**Why immutability matters:**
+- Full audit trail for compliance and trust
+- Tamper-evidence through cryptographic chain
+- Learn from false positives to improve detection
+- Track correction rates over time
+
+See [docs/LEDGER_CORRECTIONS.md](./docs/LEDGER_CORRECTIONS.md) for detailed usage.
+
 ## CI/CD Integration
 
 ### GitHub Actions
@@ -772,45 +818,60 @@ trie ci github
 # In your CI pipeline
 npm install -g trie
 # Query decision ledger for risks
-trie gotcha
-# Check memory for related incidents
-trie memory search "deployment"
-```
 
-## Memory System
+## Memory Architecture
 
-### Local Memory
+Trie maintains two complementary memory systems that work together:
 
-Each project stores its own memory in .trie/memory/:
+### 1. Governance Ledger (Primary Product)
 
-Incident reports and patterns  
-Risk scores and confidence levels  
-Performance over time
+**Location:** `.trie/memory/ledger.json`  
+**Purpose:** Cryptographic, tamper-evident record of what was detected and when  
+**Architecture:** Append-only chain of blocks with merkle roots
 
-### Cross-Project Memory
+This is the **core governance layer** - the immutable audit trail that:
+- Powers `trie gotcha` predictions
+- Provides compliance and trust
+- Never deleted, only corrected (see [Ledger Corrections](./docs/LEDGER_CORRECTIONS.md))
+- Syncs across team via `.trie-shared/`
 
-Global patterns stored in ~/.trie/memory/:
+The ledger is what makes Trie's governance verifiable and trustworthy. It's the permanent record.
 
-Patterns that apply across projects  
-Your personal coding patterns
+### 2. Issue Memory (Query Cache)
 
-### Memory Management
+**Location:** `.trie/memory/issues.json`  
+**Purpose:** Fast searchable cache for pattern queries  
+**Complementary to:** The ledger
 
-```bash
-# View capacity (default: 10,000 issues)
-trie memory stats
+Issue memory caches:
+- **Goal violations** caught by watch mode
+- **Learning extractions** from `trie learn` (git history analysis)
+- **Manual reports** via `trie tell` or chat
+- **Working state** - tracks resolved/open/fixed status
+- **Cross-project patterns** in `~/.trie/memory/`
+
+**Each issue links back to the ledger** via `ledgerBlockHash` for full audit trail.
+
+**Why both systems?**
+- **Ledger** = immutable historical record (what was detected, when)
+- **Issue memory** = mutable working state (resolved, open, metrics)
 
-# Smart cleanup (removes resolved + old low-priority)
-trie memory purge smart
+The ledger ensures nothing is lost. Issue memory tracks current state and makes queries fast.
 
-# Remove all resolved issues
-trie memory purge resolved
+### Query Issue Memory
+
+```bash
+# Search for patterns
+trie memory search "authentication"
+
+# View statistics
+trie memory stats
 
-# Remove issues older than 90 days
-trie memory purge old --days=90
+# See recent detections
+trie memory recent
 ```
 
-What happens at the 10,000 issue cap: Trie will deduplicate new repeats, compact older issues into summaries, and if it still exceeds the cap it will prune the oldest/lowest-value issues (it does not “overwrite” in place).
+**Note:** Issue memory can be cleaned up (`trie memory purge smart`) without affecting the immutable ledger. The ledger remains the source of truth.
 
 ## Troubleshooting
 
@@ -838,4 +899,4 @@ trie goal list
 
 ## License
 
-MIT License
+MIT License

package/dist/{chunk-4PAAGLKO.js → chunk-53KUI7RQ.js}

@@ -7,6 +7,9 @@ import {
 import {
   ContextGraph
 } from "./chunk-FH335WL5.js";
+import {
+  storeIssues
+} from "./chunk-QH77RQB3.js";
 import {
   scanForVulnerabilities
 } from "./chunk-F4NJ4CBP.js";
@@ -18,9 +21,8 @@ import {
   getRecentCommits,
   getStagedChanges,
   getUncommittedChanges,
-  getWorkingTreeDiff,
-  storeIssues
-} from "./chunk-62POBLFC.js";
+  getWorkingTreeDiff
+} from "./chunk-ZUEAHFSY.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
@@ -1454,4 +1456,4 @@ export {
   handleCheckpointCommand,
   isTrieInitialized
 };
-//# sourceMappingURL=chunk-4PAAGLKO.js.map
+//# sourceMappingURL=chunk-53KUI7RQ.js.map