Last Updated: 7/24/2026

Supported AI Assistants and Capture

Jolli Memory captures the reasoning behind your work automatically. On every commit, a background worker finds the AI coding session that produced the work, reads its transcript and your git diff, and attaches a structured Memory to the commit. You keep using your AI assistant exactly as you normally would; capture happens in the background, and reviewing or turning off any source is optional.

This page lists every assistant Memory can capture, how each one is captured, and how to turn any of them on or off.

Private and local-first: your summaries and transcripts are stored with your repo. Generating a summary sends your transcript and diff to the LLM for that request (never stored off-machine); nothing is published to anyone else until you Share in Jolli.

What “capture” means

Capture is the step where Memory turns a coding session into a stored Memory:

1. You code with an AI assistant in a git repo where Memory is enabled.
2. You commit.
3. In the background, Memory finds the session that produced the work, reads its transcript and the diff, and generates the Memory.

Each Memory names the assistant that produced it, so you can use more than one assistant in the same repo and still tell them apart.

Memory finds your session in one of two ways, depending on the assistant. Some assistants run a hook that records the session as it happens. Others have no usable hook, so Memory discovers the session by reading files or a local database at commit time. Both models are explained below.

Supported assistants at a glance

Memory captures twelve sources across nine assistants. Some assistants have more than one capture path that shares a single toggle - GitHub Copilot, Cursor, and Cline each do. Every source is enabled automatically when its assistant is detected, unless you turn it off.

Notes:

• Three assistants have two capture paths that share one toggle: GitHub Copilot (copilotEnabled, CLI + Chat), Cursor (cursorEnabled, the Composer IDE + the cursor-agent CLI), and Cline (clineEnabled, the VS Code extension + the Cline CLI).
• “Auto briefing” means the session-start briefing described later. Only Claude Code gets it automatically.

The two capture models

Hook-based: Claude Code and Gemini CLI

Claude Code and Gemini CLI record each session through an agent hook that jolli enable installs. Because the hook runs inside the assistant, the assistant must be started after you enable Memory.

If Claude Code or Gemini CLI was already running when you enabled Memory, restart it. Otherwise the hook is not loaded and the session is not recorded.

Discovery-based: every other source

The other ten sources have no hook that Memory can use. Instead, Memory discovers the session at commit time by scanning the filesystem or reading a local database. There is nothing to restart. As long as the assistant wrote its session to the expected location and you committed within the freshness window, the session is found.

Per-assistant notes

Claude Code

Captured by the Stop hook, which records the session when a turn ends. Claude Code is on by default (claudeEnabled defaults to true). It is the only assistant that gets the automatic session-start briefing.

Gemini CLI

Captured by an after-agent hook. Like Claude Code, Gemini CLI must be started after you enable Memory so the hook is loaded. There is no session-start briefing for Gemini; use Recall instead.

Codex CLI

Discovered by scanning ~/.codex/sessions/ and ~/.codex/archived_sessions/ for the session whose working directory matches your repo. No hook, no restart.

OpenCode

Discovered by reading OpenCode’s local SQLite database at ~/.local/share/opencode/opencode.db. Requires Node 22.5+ (see below). If you use a non-standard data directory, set XDG_DATA_HOME so Memory can find the database.

Cursor

Two capture paths under the single cursorEnabled toggle:

• Cursor’s Composer IDE: discovered by reading Cursor’s global state database (state.vscdb) and matching Composer sessions to your workspace. Requires Node 22.5+.
• The cursor-agent CLI: discovered by scanning ~/.cursor/chats/ and ~/.cursor/projects/. Reads plain JSON, so it has no Node requirement.

GitHub Copilot

One assistant, two capture paths, one switch:

• GitHub Copilot CLI: discovered by reading ~/.copilot/session-store.db. Requires Node 22.5+.
• GitHub Copilot Chat, in VS Code: discovered by scanning the chat session files in VS Code workspace storage and in ~/.copilot/session-state/. No Node requirement.

Both paths are controlled by the single copilotEnabled toggle. There is no separate switch for Chat. Turning copilotEnabled off disables both.

Cline

One assistant, two capture paths, one clineEnabled toggle:

• The VS Code extension (extension id saoudrizwan.claude-dev): discovered by reading its task history in VS Code global storage (state/taskHistory.json).
• The Cline CLI: discovered by scanning ~/.cline/data/sessions/.

Both read plain JSON, so neither needs Node 22.5+.

Devin

Discovered by reading Devin CLI’s local SQLite database at ~/.local/share/devin/cli/sessions.db (%APPDATA%\devin\cli\sessions.db on Windows). Requires Node 22.5+.

Antigravity

Discovered by reading Antigravity’s local SQLite database under ~/.gemini/<variant>/conversations/ (the variant is one of antigravity, antigravity-ide, or antigravity-cli). Requires Node 22.5+.

Node 22.5+ prerequisite

The jolli CLI itself needs Node 22.5+ (the requirement on the install page). Separately, five capture sources - OpenCode, Cursor’s Composer IDE, GitHub Copilot CLI, Devin, and Antigravity - read a local SQLite database using Node’s built-in SQLite support, so they too need Node 22.5+ at runtime; the other sources do not. That is what the “Node 22.5+?” column above means.

• On the CLI, this is your installed Node version.
• In VS Code (or a fork such as Cursor or Windsurf), you need a build recent enough to bundle Node 22.5+, roughly VS Code 1.99 or later. The Node 22.5+ requirement is exact; the specific editor version that ships it is approximate.

If the runtime is older, these five sources are reported as not detected rather than as an error. They simply will not appear in jolli status. Codex CLI, GitHub Copilot Chat, the cursor-agent CLI, and both Cline sources read plain files, so they have no Node requirement.

Auto-linked references

When a session mentions an issue, page, thread, or meeting in a supported tool, Memory can attach it to the Memory as a reference. There are two kinds of reference:

With-context references - the title, a link, and a few key fields are captured, and the reference is included as context when Memory generates the summary. Ten trackers produce with-context references:

• Linear
• Jira
• GitHub
• Notion
• Confluence
• Asana
• monday.com
• Slack
• Zoom (meetings)
• Zoom (docs)

Tracking-only references - a lightweight bookmark: the link and a short label are recorded so you can see what the session consulted, but the fetched content is not saved and the reference is not fed into the summary. One source is tracking-only today:

• Context7 (library-documentation lookups) - records the library, a Context7 link, and your query only. Context7’s full documentation response is intentionally not saved, and the reference is not used as a source when generating memory summaries. Each Context7 reference carries a short note on its page saying so, so a near-empty body is expected, not a bug.

Coverage by assistant: references are extracted only from Claude Code and Codex CLI sessions - other assistants still produce full Memories but no auto-linked references yet. Claude Code covers all ten with-context trackers plus Context7. Codex covers nine of the ten with-context trackers - everything except Zoom docs - plus Context7. (Codex now extracts Slack threads; earlier releases did not.)

Session-start briefing vs Recall

Only Claude Code gets an automatic session-start briefing (the “Auto briefing” column above): a short [Jolli Memory — <branch>] block prepended to a new session in a repo with Memories, on any branch except the shared branches main, master, develop, development, staging, and production. Every other assistant pulls context on demand with jolli recall (or /jolli-recall inside Claude Code). For the briefing’s size, the branches it skips, and when to run an explicit Recall instead, see the Recall and Search doc.

Turning a source on or off

Every source is enabled automatically when its assistant is detected. To turn one off, set its toggle to false.

From the CLI:

jolli configure --set cursorEnabled=false    # stop capturing Cursor
jolli configure --set codexEnabled=true      # capture Codex again
jolli configure --remove cursorEnabled       # back to auto-detect
jolli configure --list-keys                  # list every config key

In VS Code (or a fork such as Cursor or Windsurf) or IntelliJ, use the Settings panel. All surfaces read the same config file at ~/.jolli/jollimemory/config.json, so a change in one place applies everywhere.

Toggle defaults:

• claudeEnabled defaults to on. The rest default to auto-detect, which means on whenever the assistant is detected.
• Three toggles each cover two sources: copilotEnabled (GitHub Copilot CLI + Chat), cursorEnabled (the Composer IDE + the cursor-agent CLI), and clineEnabled (the Cline VS Code extension + the Cline CLI).

My tool isn’t captured

Work through these in order:

1. Run jolli status. It lists each detected assistant, whether it is enabled, and how many recent sessions it found. If your assistant is missing entirely, it was not detected.
2. Check your Node version for the SQLite-backed sources - OpenCode, Cursor’s Composer IDE, GitHub Copilot CLI, Devin, and Antigravity. These need Node 22.5+. On an older runtime they show as not detected.
3. Restart hook-based assistants. Claude Code and Gemini CLI must be started after jolli enable. If you started one first, restart it.
4. Mind the freshness window. Memory only considers sessions updated within the last 48 hours. An older session is not picked up.
5. Confirm the detection path. The assistant must have written its session to the expected location listed in the table above. A non-standard install or data directory can hide it. For OpenCode, set XDG_DATA_HOME.

If a commit was made with no supported assistant running, there is no transcript to read, and Memory falls back to a diff-only summary.

Related

• Getting Started with Jolli Memory - install, sign in, and your first Memory.
• Recall and Search - how the Claude Code briefing and manual Recall reach your next session.
• Reference - the per-assistant config toggles and other keys.