Wisdom

Wisdom records Claude Code, Codex and Pi sessions on your machine and links every file change to the request, the reasoning and the commands that produced it. You browse sessions in a local dashboard, and any of your agents can query them through a skill, so the next agent starts from what was actually asked, tried and changed.

Why Wisdom

Agent sessions can add useful context to a diff: what you asked for, what the agent tried and how it checked the result. Revisiting that context can take a little digging, especially across different tools.

Wisdom keeps a local record you and your agents can read:

• File diffs alongside the requests and tool calls recorded around them.
• A common way to browse Claude Code, Codex and Pi sessions, one turn at a time.
• Session history to help with reviews, follow-up work and handoffs between agents.

How it works

The agent's own hooks send each event to a small daemon on your machine. The daemon saves it in the project's .wisdom/ folder, along with a byte-for-byte copy of the agent's transcript and the diffs of the files it watches. If the daemon is down, events are kept and recorded when it comes back; the agent is never blocked.

Quick start

Step 1: Install

npm install -g @oqura/wisdom

Step 2: Connect a project

cd your-project
wisdom connect

Step 3: Use your agent as usual

claude      # or codex, or pi

Sessions are recorded with your normal login. Open them with:

wisdom dashboard

The first time in a project, Codex asks you to trust it and to approve Wisdom's hooks in /hooks, and Pi asks you to trust it. On Windows PowerShell with scripts blocked, use wisdom.cmd and npm.cmd.

Supported agents

Agent	Tested with	Records through	Notes
Claude Code	2.1.319	Hooks	Start it in the project's folder
Codex CLI	0.166.0	Hooks	Trust the project and approve the hooks once
Pi	1.2.0	Extension	Start it in the project's folder and trust the project once

Two ways to record

• wisdom connect (above) records claude, codex and pi with your normal login. It adds Wisdom's hook to the project's agent settings and keeps those files out of git. Claude Code and Pi are recorded when started in the project's folder.
• wisdom init, then wisdom track claude (or codex, pi), gives each agent its own home inside .wisdom/ and touches nothing else. Each agent logs in once for that project. Use it to keep everything in one folder, or to record sessions started from a subfolder.

Details in two ways to record.

Commands

Full reference in usage.

Finding the intent behind a change

Wisdom puts a skill in each connected agent that teaches it two moves: glance to see a session's turns, and open to read one turn in full. The session can come from any agent: Codex can read what Claude Code did, and the other way round. Ask something like "which session changed tool.py, and was that on purpose?" and the agent finds the turn and reads it:

t3  in        Add a one-line docstring to main() in jev_router/tool.py.

c4  Edit src/optim_jev/tools/jev_router/tool.py · ok · → p1
reply     I added a one-line docstring to main().

p1  src/optim_jev/tools/jev_router/tool.py · modify · +2 −1 · observed during c4
     def main() -> None:
    -    mode = sys.argv[1] if len(sys.argv) > 1 else ""
    +    """Dispatch a JSON request from stdin to the handler named by argv[1]."""
    +    mode =sys.argv[1] if len(sys.argv) > 1 else ""

The request and the reply both say docstring; the diff shows the line below changed too. The agent sees the change, the request behind it, and where they differ. More in agents.

From a commit back to its sessions

wisdom glance --commit HEAD lists each piece of a commit with the recorded step that made it, and says not recorded for anything no session explains. Wisdom keeps that answer for each commit you make, in your own .git, never on a branch.

Each commit with agent work can also get a short guide: what changed and why, citing the steps. By default Wisdom builds a plain one from the record; wisdom guide on has a cheap model (Claude Haiku through your own Claude Code) read the sessions since your last commit and write it.

Team mode is opt-in: commit a wisdom-team.json. Then each git push also sends the commits' records and their sessions, secrets redacted, to hidden refs in your own git remote. Teammates read them with wisdom team fetch, and CI checks every PR with wisdom check. Details in team mode.

Dashboard

wisdom dashboard opens a local viewer for every session in the project, live while the agent runs.

Overview	Chat view

Dev view	An agent reading a session

More in dashboard.

Privacy

Everything stays in the project's .wisdom/ folder on your machine. Git ignores it, but it holds sessions unredacted, so keep it out of shared drives and zips. wisdom share and wisdom export check for API keys, tokens, email addresses and similar before writing anything. In team mode, sessions and commit records are redacted the same way before a push, and go only to your own git remote; your recorded sessions are never changed. The check finds known shapes only, and a team can add its own scanner.

Status

Early. Tested on Windows, macOS and Linux. See limitations and the roadmap.

Documentation

Installation · Usage · Dashboard · Agents · Harnesses · Architecture · All docs

Contributing

git clone https://github.com/Oqura-ai/wisdom.git && cd wisdom
npm ci && npm test

Read CONTRIBUTING.md first: it says which automated and live checks your change needs. See also development and the data policy. Coding agents working on this repository should start with AGENTS.md.

License

Apache 2.0