ThinkGit

Git for your thinking - Version control for AI conversations in Cursor and VS Code.

ThinkGit captures, indexes, and visualizes your AI coding sessions. The primary flow is capture → cited intent → Why Probe → MCP parity: a captured conversation is extracted into cited rationale, you ask why active code exists, and agents query the same records.

Supported editors: Cursor (reads from Cursor's composer database) and VS Code with Copilot Chat (reads from Copilot Chat session files). ThinkGit auto-detects the available conversation source.

Version 0.6.1 includes identifier-tab fixes on top of Intent Arc and Why Probe. Default UI gating and MCP host registration follow the Golden Path plan.

Quick Start

1. Install ThinkGit

Search for ThinkGit in the VS Code / Cursor Extensions Marketplace and click Install.

2. Set up Ollama (required for intent extraction)

Intent extraction uses a pinned local model. There is no Claude, OpenAI, or heuristic fallback on the rationale path.

# macOS
brew install ollama

# Or download from https://ollama.ai

ollama serve
ollama pull qwen3.5:4b

Embeddings for semantic search may still use nomic-embed-text. Extraction still depends on qwen3.5:4b.

ollama pull nomic-embed-text   # optional; semantic search only

3. Capture a conversation

1. Have an AI conversation in Cursor or VS Code Copilot Chat (Cmd+K or Cmd+L)
2. Press Cmd+Shift+T (thinkgit.captureSession) or wait for background auto-sync
3. First proof is not “a thread exists.” It completes when capture produces an active, citation-valid, target-valid committed intent. That sets thinkgit.hasRationale. A thread without cited intent is not first proof.

4. Ask why the code exists

Run ThinkGit: Why Probe (thinkgit.whyProbe) on the active line or selection, or hover a line. Open a citation with thinkgit.openCitedMessage.

5. Let agents query the same decisions

ThinkGit registers itself as an MCP server in this editor. Agents call query_intent, get_decisions, and get_anti_intent against the same committed snapshot Why Probe uses. Disable thinkgit.mcp.enabled if you do not want that.

Walkthrough order: welcome → setupOllama (qwen3.5:4b required) → captureSession (completes at cited intent) → exploreGraph → intentBlame / Why Probe → connectMcp → gitignore → shortcuts.

Features

• Session Capture: Capture AI conversations from Cursor's composer or VS Code Copilot Chat via conversation picker
  • Session pickers are workspace-scoped (only sessions tied to the current repo/workspace are shown)
• Cited intent extraction: Strict Ollama extraction (qwen3.5:4b) writes accepted and rejected rationale with exact message citations and code targets
• Why Probe: Query the committed snapshot for the active line, selection, or diff; hover, graph details, and MCP return the same ordered records
• Capture receipts and diagnostics: Thread persistence and extraction status are separate. ThinkGit: Show Capture Diagnostics (thinkgit.showCaptureDiagnostics) shows provider, trigger, thread ID, status, model, counts, and sanitized errors — not transcript text
• Auto-Sync: Automatically syncs conversations in the background — no manual capture needed
  • Smart capture logic avoids interrupting agentic loops
  • Status bar showing sync state with conversation count
• Auto-Capture on Commit: Automatically captures recent conversations when you make a git commit
• Semantic Search: Natural language queries powered by Ollama embeddings (nomic-embed-text)
  • Quick Search: Single-step search with inline filters (tag:, after:, before:, mode:, has:, no:)
  • Per-Message Search: Find specific content within conversations
  • Advanced Filters: Date range, tags, commit status, AI model
  • Cross-Workspace Search: Search across multiple registered workspaces
  • HNSW Indexing: Optional sub-50ms search at scale for large stores
• Graph Visualization: Interactive force-directed graph of thinking sessions
  • Intent Arc mode: Committed snapshot plus typed edges; clusters by lineage or code target
  • Default Intent Arc enablement requires .thinkgit/intent-arc-benchmark-gate.json to pass
  • In-Graph Search: Find and cycle through threads by keyword in the toolbar
  • Tag Clustering: Group threads by tag with compound nodes, collapse/expand on double-click
• Intent Blame: Hover over code to see cited intent
  • Color-coded status: stable, evolved, superseded
• Corrections: Confirm, correct text, not-intent (retract), and intent-aware source deletion from the Why Probe detail panel (human confirmation required)
• Context Graph: Structured knowledge extraction with path reasoning and contradiction detection
• Thread Summaries: LLM-generated summaries with fallback chain, displayed in sidebar
• Thread Branching: Track divergent conversation approaches with visual branch indicators
• Export & Comparison: Export to Markdown/HTML, compare two threads side-by-side
• Concept Heatmap: Visualize concept frequency across your codebase
• Playback Simulation: Replay thread changes step-by-step on a temp git branch
• MCP Server: Host-registered MCP tools for agents; decision tools stay in parity with Why Probe
• Data Integrity: FileLock mutex, atomic writes, consistency checks, retry with exponential backoff
• JSONL Compression: 70%+ storage reduction with transparent gzip
• Cursor Format Detection: Warns on unrecognized Cursor database versions
• Guided Onboarding: First-run walkthrough, first proof on cited intent, and progressive feature discovery

Requirements

• VS Code 1.85.0 or later (or Cursor)
• Ollama running locally with qwen3.5:4b for intent extraction
• nomic-embed-text only if you want semantic search embeddings

Usage

Keyboard Shortcuts

Commands

Access via Command Palette (Cmd/Ctrl+Shift+P):

• ThinkGit: Capture Session (thinkgit.captureSession) - Select and save an AI conversation, then extract cited intent
• ThinkGit: Why Probe (thinkgit.whyProbe) - Show cited intent for the active line or selection
• ThinkGit: Show Capture Diagnostics (thinkgit.showCaptureDiagnostics) - Receipts for capture vs extraction, without transcript text
• ThinkGit: Open Cited Message (thinkgit.openCitedMessage) - Open a bounded citation (threadId, messageIndex, UTF-16 startOffset/endOffset)
• ThinkGit: Show Graph (thinkgit.showGraph) - Opens the interactive graph visualization (Intent Arc when the quality gate passes)
• ThinkGit: Quick Search - Single-step search with inline filters (tag:auth after:2026-01 mode:messages)
• ThinkGit: Advanced Search - Multi-step semantic search with filter UI
• ThinkGit: Export Thread - Export a thread to Markdown or HTML format
• ThinkGit: Compare Two Threads - Compare two threads side-by-side
• ThinkGit: Remove Duplicate Threads - Clean up duplicate conversations
• ThinkGit: Delete Thread - Remove a specific thread from history (intent-aware; dependent rationale is tombstoned)
• ThinkGit: Reindex Embeddings - Regenerate missing embeddings for all threads
• ThinkGit: Generate Summaries - Backfill LLM-generated summaries for existing threads
• ThinkGit: Toggle Intent Blame View Mode - Cycle through intent blame display modes
• ThinkGit: Toggle Advanced Commands - Show or hide heatmap, replay, compare, and other power-user commands
• ThinkGit: Getting Started - Open the guided walkthrough

Sidebar

ThinkGit adds a sidebar panel with:

• Think Graph: Interactive visualization of your thinking sessions and Intent Arc
• Threads: Chronological list of captured sessions grouped by date, with LLM-generated summaries

Turn on ThinkGit: Toggle Advanced Commands (or thinkgit.ui.advanced) to show Intent Timeline, compare, heatmap, and replay.

What You'll See (First Time)

When you first install ThinkGit and open a workspace:

1. Welcome notification - A one-time "Get Started" notification guides you to the walkthrough
2. ThinkGit icon appears in the activity bar (left sidebar) - click it to open the panel
3. Welcome content in the Threads sidebar with quick-action buttons (Capture Session, Get Started)
4. Getting Started walkthrough - welcome → setup Ollama (qwen3.5:4b) → capture (completes at cited intent) → graph → Why Probe → MCP → gitignore → shortcuts
5. Status bar shows Ollama status (required for intent extraction; also used for semantic search):
   • $(check) Ollama - Ollama is running
   • $(warning) Ollama Offline - Start Ollama with ollama serve and pull qwen3.5:4b
6. .thinkgit/ folder is created in your workspace (add to .gitignore if desired)

After capturing a conversation that produces cited intent:

• thinkgit.hasRationale becomes true (first proof)
• Graph and Why Probe walkthrough steps become visible
• Why Probe, hover, and MCP can return that rationale
• A first-proof notification can open the cited message or capture diagnostics

Capturing a thread with no cited intent keeps the transcript and a no-intent (or failed/partial) receipt. That is not first proof.

Capturing Sessions

1. Have an AI conversation in Cursor or VS Code Copilot Chat
2. Run ThinkGit: Capture Session or press Cmd+Shift+T
3. Select the conversation from the picker (preview and message count)
4. The thread is saved independently of extraction. Extraction then runs through Ollama qwen3.5:4b

Manual capture, commit auto-capture, and background sync all invoke the same thread-to-intent pipeline.

Capture success and extraction status are separate. Receipt statuses: queued, processing, succeeded, no-intent, partial, failed, skipped-already-complete.

If Ollama is unavailable or qwen3.5:4b is missing, the thread is still kept and extraction reports ollama_unavailable or missing_model. Disabling extraction reports the Ollama/qwen3.5:4b dependency; it does not switch to Claude, OpenAI, or a heuristic.

Why Probe and Intent Blame

Why Probe (thinkgit.whyProbe) asks why the active line or selection exists. Hover, Why Probe detail, graph details, and MCP query_intent / get_decisions / get_anti_intent all go through IntentQueryService and the committed snapshot (at most three records by default).

Citations are bounded: threadId, messageIndex, UTF-16 startOffset/endOffset. Opening a citation uses thinkgit.openCitedMessage. Agents see cited projections, not full transcripts.

Query statuses: ready, no_match, extraction_pending, extraction_failed, no_intent, empty_store, invalid_target, stale_source, storage_integrity, concurrent_update.

Lifecycle of an intent record: active, superseded, retracted, source-deleted. Contradicted is a typed edge, not a lifecycle value.

From the Why Probe detail panel (with human confirmation):

• Confirm — records human review
• Correct text — writes a successor intent
• Not intent — retracts the record
• Delete source thread — intent-aware deletion; dependent rationale is tombstoned as source-deleted

Intent Arc Graph

ThinkGit: Show Graph can open Intent Arc mode built from the committed snapshot and typed edges. Nodes cluster by lineage or code target. There is no semantic_similarity fallback in Intent Arc.

Default Intent Arc enablement requires .thinkgit/intent-arc-benchmark-gate.json to pass. If the gate is missing or failed: a quality warning, no default Intent Arc, and an explicit empty state.

Benchmark thresholds (from the Intent Arc scorer):

• Citation validity 100%
• Accepted and rejected precision ≥ 0.90
• Decision recall ≥ 0.80
• Rejected accuracy ≥ 0.85
• No-intent false-positive rate ≤ 0.05

Searching Past Sessions

Quick Search (recommended):

1. Press Cmd+Shift+F or run ThinkGit: Quick Search
2. Type a query with optional inline filters: authentication tag:auth after:2026-01 mode:messages
3. Select a result to view the full conversation

Recent searches are remembered and shown as suggestions. Semantic search embeddings use nomic-embed-text; intent extraction still requires qwen3.5:4b.

Advanced Search (multi-step):

1. Run ThinkGit: Advanced Search from the Command Palette
2. Choose search mode (threads or messages)
3. Optionally apply filters (date range, tags, commit status, model)
4. Enter a natural language query
5. Select a result to view the full conversation

Auto-Sync (Background Conversation Capture)

ThinkGit automatically syncs your AI conversations in the background — from both Cursor and VS Code Copilot Chat — and runs the same intent pipeline as manual capture.

How it works:

1. ThinkGit polls your conversation source every 30 seconds (configurable)
2. Smart capture logic avoids interrupting agentic loops:
   • Waits until conversation has no new messages for 2 minutes
   • Waits until workspace is quiet (no file saves/edits) for 3 minutes
   • Won't capture if last message is from user (awaiting response)
3. Force captures after 30 minutes to prevent indefinite delay
4. Embeddings are generated in the background for semantic search

MCP Server (Connect Agents to Your Thinking)

ThinkGit registers as an MCP server in Cursor and VS Code. After cited intent exists, agents can call query_intent, get_decisions, and get_anti_intent without pasting JSON. Those tools use IntentQueryService and reload the committed snapshot on each query, so later captures are visible without restarting the server.

A one-time privacy note explains that MCP clients in this workspace can call those tools and read thinkgit://threads. Turn off thinkgit.mcp.enabled to unregister the server.

Claude Desktop / Claude Code still need a JSON snippet if you use those hosts — see docs/MCP_GUIDE.md. In Cursor and VS Code, host registration is the setup path.

Decision tools (canonical Why Probe parity): query_intent, get_decisions, get_anti_intent

Other tools: get_related, find_path, find_contradictions, get_constraints, query_context

Configuration

Configure ThinkGit in VS Code Settings (Cmd/Ctrl+,):

See full configuration reference for all settings.

Data Storage

ThinkGit stores data in a .thinkgit folder in your workspace:

.thinkgit/
├── threads.jsonl                      # Conversation history (append-only)
├── capture-receipts.jsonl             # Capture/extraction receipts (no transcript text)
├── intents.jsonl                      # Intent nodes (accepted/rejected rationale)
├── edges.jsonl                        # Typed intent relationships
├── transactions.jsonl                 # Intent transaction journal (commit authority)
├── receipt-outcomes.jsonl             # Committed receipt outcomes
├── correction-outbox.jsonl            # Correction events
├── correction-corpus.jsonl            # Local correction corpus (not an MCP resource)
├── intent-generation.json             # Store generation manifest (schema 0.6)
├── intent-arc-benchmark-gate.json     # Quality gate for default Intent Arc
├── context/
│   ├── entities.jsonl                 # Context entities
│   └── relations.jsonl                # Context edges
└── index/
    └── embeddings.bin                 # Vector embeddings for search

Add .thinkgit/ to your .gitignore if you don't want to version control your thinking history.

Pre-0.6 rationale journals are not migrated in place. Readers report unsupported_schema until the workspace archives, resets, and re-extracts surviving threads.

Troubleshooting

Intent extraction failed / "Ollama is not available"

Intent extraction requires Ollama and qwen3.5:4b:

ollama serve
ollama pull qwen3.5:4b
ollama list

Run ThinkGit: Show Capture Diagnostics to see status, model, counts, and sanitized error codes without transcript text.

Sanitized error codes: unsupported_source_format, missing_workspace_evidence, invalid_citation, ollama_unavailable, missing_model, timeout, malformed_output, persistence_error.

Do not switch thinkgit.llm.provider to Claude or OpenAI for extraction. That path is not used.

First proof did not complete

thinkgit.hasRationale is set only after an active, citation-valid, target-valid committed intent. A captured thread with no-intent, failed, or partial extraction is not first proof.

Intent Arc did not become the default graph

Default enablement requires .thinkgit/intent-arc-benchmark-gate.json to pass. Missing or failed gate: quality warning, no default Intent Arc, explicit empty state. Thread similarity is not used as a fallback.

"No AI conversation source found"

ThinkGit auto-detects your conversation source. It looks for:

• Cursor: ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb (macOS)
• VS Code Copilot Chat: ~/Library/Application Support/Code/User/workspaceStorage/<hash>/chatSessions/ (macOS)

Make sure:

1. Cursor is installed, or you have VS Code with Copilot Chat
2. You've had at least one AI conversation to create the database/session files
3. Set thinkgit.capture.provider to force a specific source if auto-detect picks the wrong one

"Cursor's database format isn't recognized"

This warning appears when Cursor updates its database schema to a version ThinkGit doesn't recognize. Capture may still work, but consider updating ThinkGit to the latest version. Check the Output panel for format detection logs (e.g., Detected Cursor format: v10+ (_v=10)).

Sessions not capturing

1. Ensure you have an active workspace folder open
2. Check the Output panel (View > Output) and select "ThinkGit" for logs
3. Verify you have AI conversation history (Cursor composer or Copilot Chat)
4. For Cursor provider, verify the conversation includes current workspace context (selected files/folders or file references)
5. Check thinkgit.capture.provider setting if auto-detection isn't working
6. Open ThinkGit: Show Capture Diagnostics for receipt status
7. Try closing and reopening the editor if the database appears locked

Contributing

Contributions are welcome! See README_DEV.md for development setup, architecture, and testing instructions, CLAUDE.md for architecture notes, and AGENTS.md for agent and Cursor Cloud instructions.

Intent Arc behavior is specified in docs/plans/2026-08-21-001-feat-intent-arc-why-probe-plan.md. The Golden Path plan remains prerequisite context for default UI gating and MCP host registration.

Note: Native addon tests (HNSW) are optional and run in a separate job. See README_DEV.md for npm run test:native.

License

MIT License - see LICENSE for details.