Build history of your codebase. Inquire.
Track decisions as you go further with an expert that feels like it was in the room when the decisions were made.
Understand how existing code evolved. Map the decisions, pivots, and reasoning behind any codebase.
/decision-graph path/to/code
Keep track of ongoing decisions. Log goals, actions, and outcomes in real-time as you work.
/recover
Archaeology mode is for understanding existing codebases. When you join a project or need to understand "why is this like this?", archaeology helps you reconstruct the decision trail from commit history, PRs, and code patterns.
Pulse mode is for ongoing work. As you build, log decisions in real-time. When sessions end or teammates need context, the graph survives.
Both modes produce the same graph. Archaeology reconstructs history; pulse captures it live. Either way, you end up with queryable institutional memory.
Drop into an existing project and build a decision graph from its history. Perfect for onboarding, code review, or understanding legacy systems.
Trace how code got to its current state. Map pivots where the approach changed. Link decisions to commits.
The revisit node type captures moments when the team changed direction. Understand why approach A was abandoned for B.
Use --date "YYYY-MM-DD" to place decisions at their historical timestamps. Build accurate timelines.
The web viewer's "Ask About This Code" feature lets you query narrative chains. Get explanations of complex evolution patterns.
Log decisions in real-time as you work. When sessions end, context survives. When PRs need writeups, generate them from the graph.
Create goal and decision nodes before writing code. Forces clearer thinking and captures the reasoning.
Use --commit HEAD to link outcomes to git commits. Every commit becomes traceable to its goals.
New session? Use /recover to pick up where you left off. The graph remembers what you were working on.
Inquire about the code and your plans as if Claude was in the room when those plans were made and executed.
Deciduous integrates deeply with Claude Code through skills, hooks, and commands. Run deciduous init to set up everything.
Skill that recovers context from the decision graph at session start.
Skill for logging decisions with proper node types and links.
Skill that creates a goal node before starting implementation.
Hook that reminds Claude to link commits to the decision graph.
Hook that checks for action nodes before allowing commits.
Export graph for GitHub Pages deployment.
deciduous init
A full CLI for querying and managing your decision graph.
List all nodes. Filter by type, branch, status. Output as JSON for scripting.
Web viewer with DAG visualization, narrative chains, and Claude Q&A.
Export graph to JSON for GitHub Pages deployment or sharing.
A simple vocabulary for capturing how software evolves. Click any type to see an example.
What you're achieving
Choice points
Approaches considered
What you implemented
Results of actions
Insights discovered
Pivot points
Deciduous is flexible. Use it however fits your style.
Use all the skills and hooks. Let Claude log decisions automatically as it works. Maximum context recovery.
Run deciduous add yourself. Keep the graph updated without automated hooks.
Skip pulse mode entirely. Use deciduous just to understand existing codebases and document history.
Use deciduous writeup to generate PR descriptions. Great even without the full workflow.
Get deciduous running in under a minute.
One command to install the CLI globally.
Creates skills, hooks, and commands for Claude.
Use /recover at session start, or archaeology mode for existing code.
Deciduous was built using deciduous to track its own development. The graph you see at demo/ is the real decision trail from building this tool.
From day one, every goal, decision, and outcome was logged. The tool proved itself by building itself.
Multiple sessions lost context. Each time, /recover brought developers back up to speed.