# Jolli Support --- # Getting Started with Jolli Memory Source: /jolli-memory/getting-started-with-jolli-memory # Jolli Memory When you work with an AI coding agent, the reasoning behind every decision lives in the conversation: why you picked this approach, what alternatives you rejected, what dead ends you hit. The commit message captures none of it. A week later, you can't remember why; neither can the teammate who asks. Jolli Memory captures that context automatically. On every commit, a background worker reads your AI session transcript and your git diff, then attaches a structured summary to the commit: **Why**, **Decisions**, **Implementation**. The commit returns instantly; the summary appears shortly after. ## What you get - Structured commit summaries - **Why**, **Decisions**, **Implementation** - attached to each commit and stored with your repo, not in any cloud. Your git history stays normal. - **Recall** - feeds a branch's past reasoning into your next AI session so you don't start from zero. - **Search** - find a past decision across every branch. - **Share in Jolli** - optional, publish a Memory to your team. - Runs headless from the **CLI** in any terminal, editor, or CI. An optional editor extension (VS Code, Cursor, Windsurf, IntelliJ) adds a visual sidebar and in-editor actions - see **Editor extensions**, below. Keep coding with your AI the way you already do. Memory works in the background: you do not change your workflow, and reviewing or curating what gets captured is optional. Memory captures from nine AI coding assistants across twelve sources: **Claude Code**, **Codex CLI**, **Gemini CLI**, **OpenCode**, **Cursor** (the Composer IDE and the `cursor-agent` CLI), **GitHub Copilot** (both the Copilot CLI and VS Code Copilot Chat), **Cline** (the VS Code extension and the CLI), **Devin**, and **Antigravity**. Use more than one in the same repo and each Memory names the assistant that produced it. For exactly how each is captured, see [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3). ### Privacy Private and local-first. Your summaries and transcripts are stored with your repo, not in any cloud. Generating a summary does send your transcript and diff to the LLM (Anthropic directly, or the Jolli proxy, which holds them only for that request and never stores them); nothing is published to anyone else until you explicitly Share a Memory. Licensed under Apache 2.0. Jolli Memory does collect **content-free usage telemetry**, on by default. It never sends your code, file paths, commit messages, diffs, transcripts, Memory content, or repo or branch names, and the payload carries no account identifier (though when you are signed in, events upload under your Jolli key, so they can be attributed to your account on our end). Turn it off with `jolli telemetry off`, or by setting `DO_NOT_TRACK` to any non-empty value other than `0`. For the exact fields it sends and every opt-out path, see [Troubleshooting and FAQ](jrn:/global:docs:article/sync-6c6d4d79-61fa-477b-8079-dc88c7b998b5). ## Install the CLI The CLI is the primary way to use Jolli Memory - it works in any terminal, any editor, and in CI. It requires **Node 22.5 or later** - on an older Node, upgrade first (e.g. `nvm install 22`). (Prefer clicking to the terminal? You can use an editor extension instead - see **Editor extensions**, below.) ```bash npm install -g @jolli.ai/cli jolli --version ``` That gives you the `jolli` command. (To try a command without a global install, `npx @jolli.ai/cli ` works too; for day-to-day use - where the git hooks call `jolli` - install it globally as above.) **Prefer Claude Code?** Jolli also ships as a **Claude Code plugin** - add it from the plugin marketplace and it bundles the git hooks, the `jollimemory` MCP server, and the `/jolli` skills, installing the same repo hooks (via `jolli enable --repo-hooks-only`) without a separate CLI setup. Whichever install surface - the CLI, the editor extension, or the plugin - is newest drives your repo's hooks. **The quickest way to get set up is to just run `jolli`.** With no arguments, in an interactive terminal, the bare `jolli` command launches a guided front door: it checks whether Memory can generate summaries (do you have a credential?) and sync to a Space (are you signed in?), then walks you through fixing whatever is missing and enabling this repo - doing the work of `jolli auth login`, `jolli enable`, and `jolli status` in one flow. On a repo that already has commits, it also offers to capture your recent history right then (a backfill from your Claude Code sessions), so you are not starting from an empty slate. Run `jolli --help` any time to see every command. Prefer to run each step by hand (or script it for CI)? The manual path is **Sign in** then **Enable in your repo**, below. ### Or have your AI agent install it If you already work in a terminal agent like Claude Code or Codex, you can just ask it to set Jolli up for you. Paste this in: > Install the Jolli Memory CLI: run `npm install -g @jolli.ai/cli`, then `jolli auth login` to sign me in, then `jolli enable` in this repository and show me `jolli status`. The agent runs the commands and reports back. Then pick up at "Make your first commit" below. ## Sign in Jolli Memory needs a way to generate summaries. Three options: - **Sign in with Jolli (recommended)** - OAuth into Jolli and use Jolli's LLM proxy. Choose this if you might Share to your team later. ```bash jolli auth login ``` - **BYOK (bring your own key)** - Memory calls Anthropic directly with your key. Choose this if you already pay Anthropic, or want to evaluate before creating a Jolli account. ```bash jolli configure --set apiKey=sk-ant-api03-... ``` - **Use your local Claude Code CLI (no key)** - if Claude Code is already installed and signed in, Memory can drive it to generate summaries through its own subscription, with no Anthropic key and no Jolli account. ```bash jolli configure --set aiProvider=local-agent ``` If the `claude` binary is not on your `PATH`, add `jolli configure --set localAgentPath=/path/to/claude`. This powers summary generation only; Sharing to a team Space still needs a Jolli API key. You can switch or add another later. For CI or scripts, create a personal Jolli API key at **Settings → Jolli Memory → Create Key** (format `sk-jol-...`, shown once) and set it with `jolli configure --set jolliApiKey=`. ## Enable in your repo `jolli enable` is the single command that sets Jolli Memory up in a repository - it installs everything and then helps you configure a credential. Run it from the root of a git repo: ```bash jolli enable jolli status ``` `enable` does three things in one pass: 1. **Installs the git hooks** that drive Memory - `post-commit`, `post-rewrite`, `prepare-commit-msg`, `post-merge`, and `pre-push`. 2. **Wires up your assistants** - agent hooks for **Claude Code** and **Gemini CLI**, plus the MCP server and the `/jolli-recall` and `/jolli-search` skills, registered into every assistant it detects. The other ten sources are discovered automatically and need no hook. 3. **Sets up a credential** - in an interactive terminal (skip with `-y`), `enable` then helps you choose how summaries get generated. If you already have a working local Claude Code CLI, it is selected automatically (its subscription, no key, no menu). Otherwise you get three choices: sign in to Jolli (recommended), enter an Anthropic API key (`sk-ant-...`), or skip and configure later. So you do not have to run `jolli auth login` first - `enable` can do the sign-in for you. `status` then confirms your hooks, credential, and detected assistants. A fresh repo shows `Stored memories: 0` until your first commit generates one - that's expected, not a misconfiguration. Handy flags: `-y` skips the interactive prompts (for CI or scripts); `--integrations-only` sets up the MCP server and skills without installing any git or agent hooks (for hosts that manage their own, such as the IntelliJ plugin); `--cwd ` targets a specific repo. Installed a new assistant later? Run `jolli enable` again to register it. **If a hook-based assistant (Claude Code or Gemini CLI) was already open when you enabled, restart it** so the hooks attach - this is the most common reason a first Memory doesn't appear. (Discovery-based assistants - Codex, Cursor, OpenCode, Copilot, Cline, Devin, and Antigravity - need no restart.) Run `jolli status` to confirm your assistant was detected; if it is missing, it may need a newer Node or editor build. See [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) for the per-assistant details. ## Make your first commit Open your AI agent and code normally. Ask it to make a small, real change. Conversational pairing is the point - the more reasoning lives in the transcript, the better the Memory. Commit without an AI session and you still get a Memory, just a thinner, diff-only one. Stage and commit as usual: ```bash git add git commit -m "Fix tile generation when grid snaps are fractional" ``` The commit returns immediately. In the background, Memory reads your transcript and the diff, generates a summary, and stores it with the commit - usually within about 10 to 20 seconds. **Already have history?** Running `jolli` offers a backfill automatically on a repo that already has commits, and the editor extension prompts for the same on enable. To run it yourself, `jolli backfill` creates Memories for commits made before you enabled Jolli (Claude Code transcripts only; commits with no attributable transcript get a diff-only summary). It defaults to the last 20 commits - use `--last ` for more, or `--all` for every commit missing a Memory. ## See your first Memory From the CLI: ```bash jolli view # list recent Memories jolli view --commit 1 # open the latest commit's Memory ``` If `jolli view` shows nothing right after committing, the summary is still generating - wait a few seconds and run it again. `--commit` takes a numeric index (`1` is the latest) or a commit-hash prefix; `HEAD`, branch names, and tags are not recognized. Each Memory leads with a Quick recap, then a card per topic with labeled callouts: - **Why this change** - what problem the commit solved and why now. - **Decisions behind the code** - trade-offs, alternatives rejected, non-obvious choices. The part that disappears without Memory. - **What was implemented** - what was built and how. In the editor extension, the same Memory opens in a visual Memory view with editable callouts (see **Editor extensions**). ## Recall Recall feeds a branch's past reasoning back into your next AI session. In Claude Code it is **automatic**: a compact `[Jolli Memory — ]` briefing prepends the conversation at session start. Every other assistant pulls it on demand with `jolli recall` (or the `/jolli-recall` skill). When a repo is enabled, Memory also registers an MCP server so an MCP-aware assistant can recall and search your history conversationally. For the automatic-vs-explicit details, flags, and how Recall differs from Search, see [Recall and Search](jrn:/global:docs:article/sync-f2f2e3c6-30b2-4ac5-9784-29da4e21c4b4) and [Connect Memory to Your AI Assistant (MCP)](jrn:/global:docs:article/sync-199a4f2a-ac32-4ea2-8733-da402d3089c8). ## Share in Jolli When a commit's reasoning would help a teammate, publish it to a dedicated **Jolli Memory Space** your team can read. Sharing needs a **Jolli API Key** (sign-in saves one), so BYOK-only setups cannot share. From the CLI, find your Space and push - the first push binds the repo automatically, so there's no separate bind step: ```bash jolli spaces # list the Spaces you can publish to jolli push --space # binds on first use, then publishes this branch's Memories ``` It sends the summary, commit metadata, changed-file paths, any extracted references (Linear, Jira, GitHub, Notion, Confluence, Asana, monday.com, Slack, Zoom, and Context7 library lookups), your repo's remote URL, and any attached plans and notes; it never sends your transcripts or the raw diff. To share a multi-commit story, squash first, then push. **Auto-sync on push:** once a repo is bound to a Space, a `git push` also syncs that branch's Memories to the Space in the background when you're signed in - so you often don't need to run `jolli push` by hand. Turn it off with `jolli configure --set syncOnPush=false`. In the editor extension, the Memory view has a **Push to Jolli** button (**Share in Jolli** in IntelliJ) for the same thing, plus a separate **Share** button for link-based sharing (anyone in your account, anyone with the link, or only people you name). **Heads up:** when you are signed in, clicking **Create PR** in the extension also publishes the branch's Memories to your team in the same step. Once pushed, the Memories appear in that Space in the Jolli web app - that's where your team reads and builds on them. Shared Memories are attributed to you and are removed by deleting the Article from the Space in the web UI; your local copy is untouched. See [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) for the team-side story. In the web app, the top-level repo folders in a Memory (Vault) space now show a **View knowledge graph** button that opens an interactive, pan-and-zoom view of that repo's knowledge graph. ## Editor extensions (optional) Prefer a visual sidebar to the terminal? Install the extension for your editor. It is entirely optional - the CLI does everything headless - but it adds a sidebar and in-editor actions on top of the same stored Memories. **Install:** - **VS Code** (1.80+) - Extensions view, search **Jolli Memory**, **Install**. Or `code --install-extension jolli.jollimemory-vscode`. - **Cursor and Windsurf** (and other VS Code forks) - same flow via Open VSX, e.g. `cursor --install-extension jolli.jollimemory-vscode`. OAuth Sign In works in VS Code, Cursor, and Windsurf; if it doesn't complete on your fork, use BYOK or `jolli auth login`. - **IntelliJ** (2025.1+ and other JetBrains IDEs) - **Settings → Plugins → Marketplace**, search **Jolli Memory**, **Install**, then restart the IDE. Enable it by clicking the Jolli Memory icon in the VS Code Activity Bar (or opening the tool window in IntelliJ); hooks install automatically, then reload the window (VS Code) or restart the IDE (IntelliJ) so they take effect. Sign-in and BYOK also have buttons here: **Status overlay → Sign In to Jolli**, or **Settings → AI Summary → Anthropic API Key** (in IntelliJ, **Settings → Tools → Jolli Memory**). **The sidebar** leads with a segmented **Current Branch / Memory Bank** switch and a `repo / branch` breadcrumb, plus **Settings** (gear) and **Status** (a pulse icon opening a full-pane overlay): - **Current Branch** - three blocks: **Pinned**, **Working Memory** (what is composing for your next commit, with the **Commit Memory** button), and **Committed Memories**. - **Memory Bank** - a cross-branch, cross-repo view of every stored Memory on disk, with search and a Tree / Timeline toggle. See [Memory Bank and Sync](jrn:/global:docs:article/sync-f0d547bc-8e4e-4604-9c1a-a2653d538469). - **Status overlay** - enable/disable, sign-in state, active AI sessions, the summary provider your next commit will use, and any missing-credential warning. **In-editor actions:** - **AI Commit** - generates a commit message from the staged diff (the **Commit Memory** button; sends only the diff, not your conversation). The full Memory still generates separately after the commit lands. - **Squash** - collapses a range of contiguous commits into one and has an LLM merge their Memories, for cleaning up WIP history before merging to `main`. Nothing is lost. - **Create PR** - drafts a pull-request description from the branch's Memories (needs the `gh` CLI, a commit with a Memory, and the branch pushed). When signed in, it also publishes the Memories to your team. ## Next steps - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - config keys, commands, and recovery paths. - [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) - once you've shared a Memory, what the team does with it. - [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) - every assistant and exactly how each session is captured. - [Recall and Search](jrn:/global:docs:article/sync-f2f2e3c6-30b2-4ac5-9784-29da4e21c4b4) - resume one branch, or find a decision across all of them. - [Memory Bank and Sync](jrn:/global:docs:article/sync-f0d547bc-8e4e-4604-9c1a-a2653d538469) - the on-disk copy of your Memories and how it syncs across devices. - [Connect Memory to Your AI Assistant (MCP)](jrn:/global:docs:article/sync-199a4f2a-ac32-4ea2-8733-da402d3089c8) - query your history conversationally. - [Jolli Memory in CI and Automation](jrn:/global:docs:article/sync-ffe2c24f-8a37-4c5b-88ae-4e5624f0d725) - run Jolli headless in CI: non-interactive auth, waiting for summaries, and batch backfill. - [Troubleshooting and FAQ](jrn:/global:docs:article/sync-6c6d4d79-61fa-477b-8079-dc88c7b998b5) - first stop when something is not working, plus what data goes where. --- # Jolli Memory in CI and Automation Source: /jolli-memory/jolli-memory-in-ci-and-automation # Jolli Memory in CI and Automation Jolli Memory runs headless. Everything you do interactively - install, sign in, enable, commit, view - also works from a script or a CI job with no editor and no browser. This page covers the pieces that are specific to unattended runs: non-interactive auth, the one timing gotcha to know about, and how commits with no AI transcript are handled. ## Install and authenticate without a browser Install the CLI (Node 22.5+): ```bash npm install -g @jolli.ai/cli ``` Summaries need an LLM credential. In CI, provide one of: - **Your own Anthropic key (simplest):** set `ANTHROPIC_API_KEY` in the job environment. Memory calls Anthropic directly, no Jolli account required. - **A Jolli API key:** `jolli configure --set jolliApiKey=sk-jol-...`. This one key covers both summary generation (via the Jolli LLM proxy) and publishing memories to a team Space (below) - use it if you want CI memories to reach your team. Create the key at **Settings → Jolli Memory → Create Key**. Heads up: `JOLLI_AUTH_TOKEN` (the OAuth token) only sets your account identity, it does **not** provide a summary-generation path. A CI run needs `ANTHROPIC_API_KEY` or `jolliApiKey`, not just `JOLLI_AUTH_TOKEN`. ## Enable non-interactively ```bash jolli enable -y ``` `-y` skips the interactive prompts. Run it from the repo root; `jolli status` confirms the result. ## Wait for summaries to finish (the important part) A commit returns instantly and the summary is generated by a **detached background worker**. That is exactly what you want interactively, but in CI it is a trap: if the job commits and then exits, the runner can tear the worker down before the summary is written. After your commit, block until the queue drains: ```bash jolli queue-status --wait --timeout 120 ``` `--wait` blocks until every pending summary is generated or the timeout (default 120 seconds) elapses. Add `--format json` for a machine-readable result you can gate on. ## Persist the memories off the runner On a stateless CI runner the memory is written locally (the git orphan branch and the Memory Bank folder) and then thrown away when the job ends. To keep CI-generated reasoning, publish the branch's memories to a team **Jolli Space** - that is the intended way to get them off the runner and in front of your team: ```bash jolli spaces # find your Space id or slug jolli push --space ``` Run `push` after `queue-status --wait` so the summaries exist first. `push` binds the repo to the Space on first use, and because the binding is stored server-side by your repo's URL, later CI runs just push - no re-bind. Publishing requires a **Jolli API key** (BYOK-only setups cannot share); the same key you use for generation covers it. (If you run on a persistent or self-hosted runner and only want memories stored with the repo, you can skip this - the local orphan branch survives there.) ## Commits with no AI transcript CI commits usually have no AI coding session behind them. That is fine: when there is no transcript, Memory generates a **diff-only summary** from the git diff alone, as long as a credential is available. You still get a structured Memory for the commit, just built from the change itself rather than a conversation. ## Generating Memories in batch To create Memories for commits made before Jolli was enabled, or to fill gaps, use backfill. It runs synchronously in-process (no detached worker), so no `queue-status` wait is needed: ```bash jolli backfill --last 50 # the most recent 50 commits (default 20) jolli backfill --all # every commit missing a Memory jolli backfill --dry-run # report what would be generated, no LLM calls ``` Backfill attributes on-disk **Claude Code** transcripts; commits without an attributable transcript get a diff-only summary. `--min-confidence ` controls how loosely a transcript is matched to a commit. ## Environment variables | Variable | What it does | |---|---| | `ANTHROPIC_API_KEY` | BYOK LLM credential; Memory calls Anthropic directly. | | `JOLLI_AUTH_TOKEN` | OAuth-token override for account identity (not a summary credential). | | `JOLLI_URL` | Override the Jolli server origin (allowlisted, HTTPS-only). | | `JOLLI_NO_PLUGINS` | Set to `1` to disable plugin discovery (the Site and Space commands). | | `XDG_DATA_HOME` | Base dir for OpenCode's session database. Default `~/.local/share`. | | `DO_NOT_TRACK` | Set to any non-empty value other than `0` to opt out of usage telemetry. | (`ANTHROPIC_BASE_URL` is honored by the Anthropic SDK itself, not by Jolli, so treat it as SDK-level rather than a documented Jolli setting.) ## Other automation notes - **Target a specific repo** with `--cwd ` on any command (`enable`, `status`, `view`, `recall`, `backfill`, and the rest), instead of relying on the current directory. - **`jolli clean`** refuses to delete in a non-interactive shell unless you pass `-y`/`--yes`; use `--dry-run` first to preview. ## Example: GitHub Actions This example generates memories in CI and publishes them to a team Space, using one Jolli API key for both: ```yaml - name: Install Jolli Memory run: npm install -g @jolli.ai/cli - name: Configure and enable run: | jolli configure --set jolliApiKey=${{ secrets.JOLLI_API_KEY }} jolli enable -y # ... your steps that commit to the repo ... - name: Wait for memories, then publish to the team Space run: | jolli queue-status --wait --timeout 120 jolli push --space ${{ vars.JOLLI_SPACE_ID }} ``` The `jolli push` step is what persists the reasoning: on a stateless runner, without it the memory is discarded when the job ends. (For generation only, on a persistent runner, an `ANTHROPIC_API_KEY` in the job environment is enough and you can drop the push step.) ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - every config key, command, and flag. - [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) - how sessions are captured, and the diff-only fallback. --- # Memory Bank and Sync Source: /jolli-memory/memory-bank-and-sync # Memory Bank and Sync Jolli Memory keeps a copy of every memory on your own disk, and it can mirror those memories across your devices. This page explains the Memory Bank (the local copy), how to find and move it, and how cloud Sync differs from Share in Jolli. ## What the Memory Bank is The Memory Bank is a plain-Markdown copy of your memories, written to a folder on your disk. Every time Jolli Memory generates a summary, it writes that summary to two places at once: the git orphan branch that stays with your repo (the source of truth), and the Memory Bank folder. This happens automatically on every commit. You do not turn it on, and you do not run anything. Because the Memory Bank is just files on disk, you can open, read, search, and back them up with any tool - reading them needs no network and not even the extension. ## Finding and browsing your memories By default the Memory Bank lives at: ``` ~/Documents/jolli// ``` Each repository gets its own subfolder. Inside, there are two layers: * A visible Markdown layer you browse. One readable file per memory, grouped by branch: ``` ~/Documents/jolli///-.md ``` * A hidden `.jolli/` layer that holds the canonical JSON (`summaries/`, `transcripts/`, `index.json`). This is for programs to read, not for editing by hand. * A generated `_wiki/` layer - a browsable knowledge wiki (`_index.md` plus one page per topic) that `jolli compile` rebuilds after each commit. Read it freely, but do not edit it: it is regenerated and is never the source of truth. Open any `.md` file in your editor, a Markdown previewer, or a file manager. Search it with your normal tools. You do not need the extension or a network connection. If you delete a `.md` file by accident, you can bring it back: ``` jolli heal-folder ``` This re-renders the missing Markdown from the canonical JSON. It does not call the AI again, and it does not change your source of truth. ## Choosing where the Memory Bank lives You can point the Memory Bank at any folder. This is useful if you want it on a different drive or in a specific location you back up. In VS Code (or a fork such as Cursor or Windsurf): 1. Open Settings (the gear icon in the Jolli Memory view). 2. Go to the Memory Bank section. 3. Click Browse and pick a folder. 4. Click Migrate to Memory Bank. In IntelliJ: 1. Open the Jolli Memory settings. 2. Go to the Memory Bank tab. 3. Set the folder path with the Browse button. 4. Click Migrate. When you migrate, Jolli Memory copies your memories into a fresh folder at the new location. The previous folder is left in place on disk. Nothing is deleted, so you can remove the old folder yourself once you are happy with the move. The folder setting is named `localFolder`. You can set it with `jolli configure --set localFolder=` or from the editor Memory Bank settings. To relocate an existing Memory Bank, use the editor's **Migrate** button: it copies your memories into the new folder and leaves the old one in place. ## Syncing across your devices Sync copies your Memory Bank to a private space that only you can see, and keeps it consistent across every device you sign in to. Jolli calls this your Personal Space. The copy is private. It is not shared with your team. Under the hood, turning on Sync makes your Memory Bank folder a git working tree connected to a private Jolli-hosted remote - which is why sync conflicts behave like git conflicts, and why you should not nest the folder inside another sync tool (see below). Sync needs a Jolli API key, so you must be signed in to Jolli. Sign in with `jolli auth login`, or with Sign In to Jolli in the editor. If you only use an Anthropic API key (BYOK) with no Jolli account, you cannot sync. ### Running a sync From the CLI: ``` jolli sync-memory-bank ``` In VS Code, open Settings, go to the Memory Bank section, and click Sync to Personal Space Now. In IntelliJ, sync runs on its own (see below). You can also trigger it by hand from the Jolli Memory tool window: use the Sync to Personal Space button in the Memory Bank explorer toolbar, or Sync to Memory Bank in the overflow menu. ### Automatic or manual, by editor Whether sync runs on its own depends on the editor: | Surface | Sync behavior | | --- | --- | | IntelliJ | Automatic. Once you are signed in, IntelliJ syncs your Memory Bank to your Personal Space in the background by default. Background sync runs on a poll timer set by the Poll interval (seconds) field on the Sync to Jolli tab, which defaults to 90 minutes (shorter values are raised to the 90-minute minimum). You can turn auto-sync off with the Auto-sync to Personal Space checkbox on that tab, and still sync by hand. | | VS Code | Manual by default. There is no toggle for background sync; click Sync to Personal Space Now when you want a sync. | | CLI | Manual. Run `jolli sync-memory-bank` when you want a sync. The CLI never syncs on its own. | A sync status indicator shows one of four states: synced, syncing, conflicts, or offline. ### Transcripts stay local unless you opt in By default, sync mirrors your summaries, plans, and notes, but not your raw conversation transcripts. Transcripts can contain pasted code, tokens, or other sensitive snippets, so they stay on your machine until you opt in. To include transcripts, turn on the `syncTranscripts` setting, or add the flag for a single run: ``` jolli sync-memory-bank --transcripts ``` This applies to both manual and automatic sync. ### If you already use Dropbox, iCloud, or Syncthing Do not put your Memory Bank folder inside a folder that another tool already syncs, such as Dropbox, iCloud, or Syncthing. Two sync tools fighting over the same files can corrupt them. If your Memory Bank folder is already inside one of those, turn one of them off. Let either Jolli sync or the other tool own that folder, not both. ### When two devices disagree If two devices push changes that conflict, Jolli resolves most of it for you. The internal index files merge automatically. For other files, it uses an AI merge when you have an Anthropic API key set, and falls back to asking you to pick a version. When you run `jolli sync-memory-bank` in a terminal, the CLI prompts you on each conflict (keep mine, keep theirs, view a diff, or skip) and can show the diff inline. In a non-interactive shell (a git hook or CI), it cannot prompt, so it skips the conflicting files and prints their paths. Open them in your editor to resolve, then sync again. ## Sync compared with Share in Jolli These are different actions with different audiences. It is worth keeping them straight. * The Memory Bank is a local copy on your disk. It is automatic, and nothing leaves your machine. * Sync mirrors your Memory Bank to your private Personal Space, so your own devices stay in step. Only you can see it. * Share in Jolli publishes one memory to your team's Jolli Space, so a teammate can read it. | | Sync | Share in Jolli | | --- | --- | --- | | What it is for | Mirror your memories across your own devices | Publish one memory to your team | | What it sends | Your whole Memory Bank: summaries, plans, and notes. Transcripts only if you opt in | One commit's summary plus its attached plans and notes | | Who can see it | Only you, in your private Personal Space | Your team, in a shared Jolli Space | | Raw transcripts | Only if you turn on `syncTranscripts` | Never sent | | The git diff | Never sent | Never sent | | How it runs | Automatic in IntelliJ, manual in VS Code and the CLI | Manual, one memory at a time | | Needs a Jolli API key | Yes | Yes | | To undo | Re-sync, or delete from your Personal Space | Delete the article in the Jolli web UI. Your local copy is untouched | To share a memory, open the memory view for a commit and click Share in Jolli. To share a multi-commit story, squash the commits first, then share the combined memory. ## Troubleshooting If sync is not working, start with: ``` jolli doctor ``` Common issues: * Not signed in. Sync needs a Jolli API key. Sign in with `jolli auth login`, or with Sign In to Jolli in the editor. * HTTP 403 on sync or share. Your Jolli API key was rejected for this workspace, often because it was issued for a different org or was revoked. Re-authenticate to get a fresh key. * HTTP 426 Plugin Outdated. Your extension is behind the server. Update the VS Code or IntelliJ extension to the latest version. * Conflicts that will not clear. Open the files listed as conflicting, keep the version you want, and sync again. For the full list of config keys and more troubleshooting, see the Reference. ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - config keys, including `localFolder` and `syncTranscripts`. - [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) - the team-side story once you publish a Memory. --- # Recall vs Search Source: /jolli-memory/recall-vs-search # Recall and Search Recall resumes one branch. Search finds a decision across all branches. Both feed old context back to you, so people mix them up. They do different jobs. > **If you only remember one thing:** Recall pulls one branch's full history into your next AI session so you can keep going where you left off. Search scans every branch for a decision, topic, or commit when you do not remember where it lives. ## Recall: resume one branch Recall compiles everything Memory knows about a single branch - its commit summaries, the decisions behind them, attached plans and notes, and file-change stats - into a briefing for your AI agent. One branch, full depth. Use it to continue your own work after a break, or to pick up a branch someone else built. ### Automatic vs explicit **Automatic, Claude Code only.** When you start a Claude Code session in a repo with Memories, a compact `[Jolli Memory — ]` block (about 300 to 500 tokens) prepends the conversation: branch name, recent Memories, key decisions, and pinned plans. It is small enough not to eat your context budget. After 3 days of inactivity on a branch, the briefing starts suggesting you run a full Recall. The automatic briefing runs on feature branches only. It is skipped on the shared branches `main`, `master`, `develop`, `development`, `staging`, and `production` (an exact, case-sensitive match, so a branch named `Main` or `release/2.0` still gets one). Skipping the automatic briefing does not disable recall: you can always pull any branch's context on demand with `jolli recall ` (for example `jolli recall main`). Every assistant other than Claude Code pulls context manually instead of getting the automatic briefing. **Explicit, any agent.** Inside Claude Code, run `/jolli-recall` (or `/jolli-recall `) for a deeper pull. From the CLI: ```bash jolli recall ``` With no argument, Recall uses your current git branch. Pass a branch name to recall a different one. If the name does not match a recorded branch, Recall lists the branches it has. (`jolli recall` is also available under the alias `jolli context`.) ### Short summary vs full context A bare `jolli recall` prints a short, human-readable summary for the terminal: last commit, topic counts, a few key decisions, files changed. That is a digest, not the full context. To get the full context (the version worth feeding to an AI agent), add a flag: ```bash jolli recall --full # full markdown to your terminal jolli recall --format json # structured payload for a skill or agent jolli recall --output ctx.md # full markdown written to a file ``` ### Useful flags The everyday ones: `--full` (full context instead of the short summary), `--budget ` (default 20,000; raise it when a long branch truncates, since lower-priority fields are trimmed first), and `--format ` (JSON for a skill or agent). See [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) for the complete set: `--depth`, `--output`, `--include-transcripts`, `--no-plans`, and `--catalog`. ## Search: find a decision across branches Search runs a full-text, relevance-ranked query over your distilled commit summaries across every branch in the repo. It returns lightweight hits, each with a title, a short snippet, the branch it belongs to, and the commit. It does not return the full decision text per hit - it points you to where the answer lives. From the CLI: ```bash jolli search "why did we switch to JWT" ``` Reach for Search when you are asking "have we handled X before", "why did we choose X over Y", or "which commit touched that half-remembered ticket or file". ### Useful flags The common ones: `--limit ` (default 20, max 100), `--branch `, `--type `, and `--format ` (default `json`). See [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) for the full set. > **Tip:** `jolli search` prints JSON by default. For a quick terminal read, add `--format text` for a one-line-per-hit view. ### Then recall the hit's branch for depth Search hits are intentionally shallow. When a hit looks right, run Recall on that hit's branch to load the full rationale and decisions: ```bash jolli recall ``` Search finds the branch. Recall gives you its full story. ## Which one do I want? | I want to... | Use | Why | | --------------------------------------------------- | ------------------------------- | -------------------------------------------------------------- | | Continue a branch I was working on | Recall | Loads that one branch's full history into your AI session. | | Pick up someone else's branch | Recall (with the branch name) | Full context without reading the code first. | | Remember why we chose X over Y | Search | Finds the decision wherever it was made. | | Find the commit for a half-remembered ticket or file | Search | Ranked hits across every branch. | | Read the full rationale behind a search hit | Recall the hit's branch | Search hits are lightweight; decisions live in Recall. | Rule of thumb: you know the branch, use Recall. You are hunting a topic, use Search. ## Commands by surface | Surface | Recall | Search | | ---------------------------- | -------------------------------------------------------------- | ------------------------------------------ | | Claude Code | Automatic briefing at session start; `/jolli-recall [branch]` for depth. | `/jolli-search `. | | Codex, Gemini, OpenCode | No auto briefing; run the `/jolli-recall` skill. | `/jolli-search` where the skill is installed. | | CLI | `jolli recall` (short) or `jolli recall --full` (full). | `jolli search `. | | VS Code | "Recall in Claude Code" button, or "Copy recall prompt" to paste into any AI tool. | See the callout below. The sidebar box is a filter. | | IntelliJ | Recall menu copies a prompt for your AI coding tool. | See the callout below. The sidebar box is a filter. | | Jolli web app | A Memory summary's panel has a **Copy Recall Prompt** button that copies a ready-to-paste recall prompt for your AI agent. | n/a | | AI agents (MCP) | `recall` tool (defaults to the current branch). | `search` tool. | ## The sidebar "Search Memories" box is a filter, not full-text Search This is the most common mix-up. > **The "Search Memories" box in the VS Code and IntelliJ sidebar is not `jolli search`.** It is a case-insensitive substring filter over the Memories list. In VS Code and its forks (Cursor, Windsurf) it matches on **commit message, branch name, and repo name**; in IntelliJ it matches on **commit message and branch name** only. Either way it does not read inside the Why, Decisions, or Implementation text, and it does not use the full-text ranking that `jolli search` does. So if you type a decision detail into the sidebar box and get nothing, that is expected. The box narrows the visible list of stored Memories; it does not search their contents. To search decision and topic text across branches, use one of these instead: - `jolli search ""` from the CLI. - `/jolli-search ` in Claude Code (or another agent with the skill). - The `search` MCP tool, if your agent is wired to Memory over MCP. ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - the full recall and search flag lists, and config keys. - [Connect Memory to Your AI Assistant (MCP)](jrn:/global:docs:article/sync-199a4f2a-ac32-4ea2-8733-da402d3089c8) - run recall and search conversationally, no CLI. --- # Reference Source: /jolli-memory/reference # Reference The lookup surface for Jolli Memory. Configuration first, then every CLI command, then the agent support matrix. To fix a problem, see the Troubleshooting and FAQ doc. ## Configuration All configuration lives in `~/.jolli/jollimemory/config.json`. The CLI, VS Code (including forks such as Cursor and Windsurf), and IntelliJ read from the same file. Secrets (`apiKey`, `jolliApiKey`, `authToken`) are masked when displayed. ### Keys | Key | Type | Description | Default | |---|---|---|---| | `apiKey` | string | Anthropic API key (BYOK). Resolution order: config `apiKey`, then `ANTHROPIC_API_KEY`, then the Jolli proxy via `jolliApiKey`. | none | | `aiProvider` | enum (`anthropic`, `jolli`, `local-agent`) | Pins which backend generates summaries: `anthropic` (BYOK), `jolli` (proxy), or `local-agent` (drive a locally-installed Claude Code CLI, no key). When unset, the resolver uses the order above. Set to `jolli` automatically when you sign in. | auto | | `model` | string | Model for summarization. Accepts an alias (`sonnet`, `haiku`, `opus`) or a full Anthropic model ID. | `sonnet` (resolves to `claude-sonnet-4-6`) | | `maxTokens` | number | Max output tokens per summarization call. | `8192` | | `jolliApiKey` | string | Jolli API key (`sk-jol-...`). Powers sign-in, the LLM proxy, and cloud features. | none | | `authToken` | string | OAuth token from `jolli auth login`. | none | | `claudeEnabled` | boolean | Enable Claude Code session tracking. | `true` | | `codexEnabled` | boolean | Enable Codex CLI session discovery. | auto | | `geminiEnabled` | boolean | Enable Gemini CLI session tracking. | auto | | `openCodeEnabled` | boolean | Enable OpenCode session discovery. Requires Node 22.5+. | auto | | `cursorEnabled` | boolean | Enable Cursor session discovery: the Composer IDE and the `cursor-agent` CLI. One shared switch. The Composer IDE path requires Node 22.5+ (SQLite); the CLI path reads plain files and has no Node requirement. | auto | | `copilotEnabled` | boolean | Enable GitHub Copilot CLI and VS Code Copilot Chat discovery. One shared switch. The Copilot CLI path requires Node 22.5+ (SQLite); the Copilot Chat path reads plain files and has no Node requirement. | auto | | `clineEnabled` | boolean | Enable Cline session discovery: the VS Code extension and the Cline CLI. One shared switch. Both read plain files - no Node requirement. | auto | | `devinEnabled` | boolean | Enable Devin CLI session discovery. Requires Node 22.5+ (SQLite). | auto | | `antigravityEnabled` | boolean | Enable Antigravity session discovery. Requires Node 22.5+ (SQLite). | auto | | `globalInstructions` | enum (`enabled`, `disabled`) | Whether Jolli may write its skill-preference block into your machine-global AI instruction files; applied immediately when you set it. Unset means undecided. | unset | | `logLevel` | enum | `debug`, `info`, `warn`, `error`. | `info` | | `excludePatterns` | string[] | Globs for files to exclude from the Changes panel. | none | | `localFolder` | string | Memory Bank root on disk. Every memory is dual-written here. Set it via the CLI or the editor Memory Bank settings. | none | | `syncTranscripts` | boolean | Include raw transcripts in cloud sync, not just summaries. | `false` | | `syncPollIntervalSec` | number | Auto-sync poll interval in seconds (IntelliJ auto-sync). Range 5400 to 86400. | `5400` (90 min) | | `syncOnPush` | boolean | Auto-sync a branch's Memories to its bound Jolli Space on every `git push` (via the pre-push hook). | on when signed in | | `mcpPlatformToolsEnabled` | boolean | Register backend-defined Jolli-platform tools in the MCP server, alongside the built-in memory tools. Set `false` for a git-memory-only server. | on | | `localAgentTool` | enum (`claude-code`) | Which local agent CLI to drive when `aiProvider=local-agent`. Only `claude-code` is supported today. | none | | `localAgentPath` | string | Explicit path to the local agent binary, overriding PATH discovery. Only used when `aiProvider=local-agent`. | none | | `slack.workspaceUrl` | string | Slack workspace URL (`https://.slack.com`) - fallback for Slack thread permalinks in references. | none | | `telemetry` | enum (`on`, `off`) | Content-free usage telemetry (attributable to your account only when signed in). Set it with the `jolli telemetry on\|off` command, not `jolli configure` (it is not an accepted `configure` key). | `on` | A few advanced keys are edited by hand in `config.json` and are not accepted by `jolli configure`: `logLevelOverrides`, `compileExcludeFolders`, `dcoSignoff`, `storageMode`, and `syncConflictPolicy`. `storageMode` selects where memories are written - `dual-write` (default: orphan branch + on-disk folder), `folder` (folder only), or `orphan` (orphan branch only, no browsable Markdown on disk). `syncConflictPolicy` sets the fallback when a sync conflict cannot be auto-merged - `prompt` (default), `mine` (always keep the local side), or `theirs` (always accept the other device). ### Editing config from the CLI ```bash jolli configure # show current config (secrets masked) jolli configure --list-keys # list every key with its type jolli configure --set model=sonnet --set maxTokens=16000 jolli configure --set excludePatterns=docs/**,*.log jolli configure --remove apiKey ``` Unknown keys and malformed values are rejected with exit code 1. ### Environment variables | Variable | What it does | |---|---| | `ANTHROPIC_API_KEY` | Fallback for Anthropic direct calls when no `apiKey` is set. | | `JOLLI_AUTH_TOKEN` | Read-time OAuth-token override for CI and scripts. | | `ANTHROPIC_BASE_URL` | Override the Anthropic API base URL (used by the official SDK). Default `https://api.anthropic.com`. | | `XDG_DATA_HOME` | Base directory for OpenCode's `opencode/opencode.db`. Default `~/.local/share`. | | `DO_NOT_TRACK` | Opt out of usage telemetry: set to any non-empty value other than `0` (e.g. `1`). | | `JOLLI_NO_PLUGINS` | Set to `1` to disable plugin discovery (the Site and Space commands). | ## CLI commands Binary `jolli`, package `@jolli.ai/cli`. Most commands accept `--cwd ` to run against a specific repo root. ### Core | Command | What it does | Key flags | |---|---|---| | `jolli enable` | Install git hooks, agent hooks, the MCP server, and the recall skill. | `-y`, `--integrations-only`, `--repo-hooks-only`, `--cwd` | | `jolli disable` | Remove all hooks. Stored memories are untouched. | `--cwd` | | `jolli uninstall` | Remove Jolli Memory's installation and configuration machine-wide: editor integrations, the global `@jolli.ai/cli` package, the `.jolli/jollimemory/` state directories, and this repo's hooks. Your stored memories are never touched. | `--dry-run`, `-y`, `--scope` | | `jolli status` | Show installation, credential, and session state. | `--json` | | `jolli view` | View memories. Compact list by default; full detail with `--commit`. | `--count ` (default 10), `--commit `, `--output `, `--format ` | | `jolli recall` | Compile branch context for an AI session. See flags below. | `--full`, `--budget`, `--catalog`, `--format` | | `jolli search` | Search memories across every branch with BM25 ranking, in a single pass. | `--limit` (default 20, max 100), `--branch`, `--type `, `--format `, `--output ` | | `jolli export` | Export memories as Markdown to `~/Documents/jollimemory//` (a manual one-off dump, separate from the auto-maintained Memory Bank at `~/Documents/jolli//`). | `--commit `, `--project ` | | `jolli configure` | Manage config keys. See above. | `--set`, `--remove`, `--list-keys` | | `jolli doctor` | Diagnose installation health. `--fix` releases stale locks, reinstalls missing hooks, and removes stale dist-path entries. | `--fix` | | `jolli clean` | Remove expired state (stale sessions, old queue entries, stale squash markers). Stored memories and transcripts are never deleted. | `--dry-run`, `-y` | `jolli enable --repo-hooks-only` installs only the repo hooks, the Claude agent hooks, and the project `/jolli` menu - it skips host detection and MCP registration, and backs the Claude Code plugin bootstrap. It is mutually exclusive with `--integrations-only`, which repairs the MCP server, skills, and dispatch scripts without changing repo hooks. `jolli view --commit ` accepts a numeric index (`1` is the latest) or a commit SHA prefix. HEAD, branch names, and tags are not recognized (they resolve to nothing). ### `jolli recall` flags `--full` (full markdown instead of the short summary), `--output ` (implies `--full`), `--depth `, `--budget ` (default 20,000), `--include-transcripts`, `--no-plans`, `--catalog` (list recorded branches), `--format `. Pass a branch name or keyword as an argument, or omit it for the current branch. ### Auth & cloud | Command | What it does | Key flags | |---|---|---| | `jolli auth login` | Sign in via browser OAuth and save a Jolli API key. | | | `jolli auth logout` | Remove the Jolli auth token and API key. Your Anthropic key is preserved. | | | `jolli auth status` | Show sign-in state. | | | `jolli sync-memory-bank` | Run one Memory Bank cloud sync round. Needs a Jolli sign-in. | `--transcripts`, `--cwd` | | `jolli push` | Push this branch's memories to a bound Jolli Space. | `--base`, `--space`, `--format json` | | `jolli spaces` | List the Jolli Spaces you can bind to. | `--format json` | | `jolli bind` | Bind this repo to a Jolli Space. | `--space` (required), `--repo-name` | Memory Bank cloud sync is on-demand. Run it from the CLI with `jolli sync-memory-bank`, or from the VS Code Settings page. IntelliJ can also sync automatically on a schedule, controlled by its Settings toggle. The only precondition is a valid `jolliApiKey`. In a terminal, `jolli sync-memory-bank` prompts you to resolve each conflict (mine / theirs / view diff / skip); only in a non-interactive shell (a hook or CI) does it skip conflicting files and print their paths for you to resolve in your editor. To publish memories to a team Jolli Space, run `jolli bind` once, then `jolli push`. The VS Code and IntelliJ editors offer the same publish per memory through the Share in Jolli action. ### Knowledge & maintenance | Command | What it does | Key flags | |---|---|---| | `jolli compile` | Fold commit memories into per-topic wiki pages. Runs automatically after each commit, and after a merge or pull (via the post-merge hook). | `--rebuild` (requires `--cwd`), `--cwd` | | `jolli graph` | Export the knowledge graph to a self-contained HTML file. | `--export `, `--open`, `--cwd` | | `jolli heal-folder` | Re-render missing Markdown in the Memory Bank folder from the canonical JSON. No LLM call. | `--cwd` | | `jolli backfill` | Create memories for commits made before you enabled Jolli. Claude transcripts only. | `--last ` (default 20), `--all`, `--hashes ` (specific commits, comma-separated; overrides `--last`/`--all`), `--dry-run`, `--min-confidence ` (default low), `--format ` | `jolli compile` requires an API key, the same one used for summary generation. `jolli graph` needs no key - it only exports the existing knowledge graph (`.jolli/graph/graph.json`, produced by a prior `jolli compile`) to HTML, and errors telling you to run `jolli compile` first if that graph is missing. ### MCP `jolli mcp` starts a Model Context Protocol server over stdio so AI agents can query your memories directly. `jolli enable` registers it into every detected host (the IntelliJ plugin too, when a compatible Node runtime is available), and each host picks it up on its next start with no manual setup. For the per-host config-file locations, see the [Connect Memory to Your AI Assistant (MCP)](jrn:/global:docs:article/sync-199a4f2a-ac32-4ea2-8733-da402d3089c8) doc. ```bash jolli mcp # start the server (normally launched by your agent) jolli mcp --reindex # rebuild the local search index and exit ``` The server exposes ten built-in tools: | Tool | Purpose | |---|---| | `search` | Full-text search over your historical decisions and implementations. | | `recall` | Load a branch's complete context. | | `get_decision_timeline` | Trace how one decision evolved across commits. | | `list_branches` | Catalog of branches that have memories. | | `get_pr_description` | Build a PR title and body from a branch's memories. | | `queue_status` | Report whether summary generation is still in progress. | | `bind_space` | Bind this repo to a Jolli Space. | | `list_spaces` | List the Jolli Spaces you can bind to. | | `push_memory` | Push a branch's memories to the bound Jolli Space. | | `status` | Report Jolli Memory's installation and configuration health for this repo: installed hooks, hook runtime, data-migration state, account/API-key configuration, detected AI integrations with their session counts, the stored-memory count, and the orphan branch. Same data as `jolli status`. | These ten are always present. When you are signed in, the server may also register additional Jolli-hosted tools alongside them (controlled by `mcpPlatformToolsEnabled`, on by default); set that key to `false` for a git-memory-only server. Two more commands, `jolli pr-description` and `jolli queue-status`, exist mainly for skills and agents. They mirror the matching MCP tools. ### Telemetry Usage telemetry is content-free and on by default. It carries no account identifier, though signed-in events upload under your Jolli key, so they can be attributed to your account on our end. | Command | What it does | |---|---| | `jolli telemetry status` | Show whether telemetry is on, plus the install ID and buffered event count. | | `jolli telemetry on` | Opt in. | | `jolli telemetry off` | Opt out. No events are collected or sent. | | `jolli telemetry inspect` | Print the exact buffered events that would be sent. | You can also opt out by setting `DO_NOT_TRACK=1`. See for the full event list. ## IDE commands The editor extensions expose the same actions in a sidebar. In VS Code (and forks such as Cursor and Windsurf) open the Command Palette (`Cmd/Ctrl+Shift+P`) and filter on **Jolli Memory**; in IntelliJ use Find Action (`Cmd/Ctrl+Shift+A`). The main commands and their CLI equivalents: | Command | What it does | CLI equivalent | |---|---|---| | Enable / Disable Jolli Memory | Install or remove the hooks in this repo | `jolli enable` / `jolli disable` | | Sign In to Jolli / Sign Out of Jolli | Manage your Jolli credential | `jolli auth login` / `jolli auth logout` | | Status | Open the Status overlay | `jolli status` | | Settings | Open the settings panel | `jolli configure` | | AI Commit | Generate a commit message from the staged diff | editor only | | Squash Selected | Squash selected commits and merge their Memories | editor only | | Search Memories / Clear Filter | Substring filter over the Memories list | `jolli search` (full-text) | | Sync Memory Bank Now | Run one Memory Bank cloud sync | `jolli sync-memory-bank` | | Build Knowledge Wiki | Compile commit memories into topic pages | `jolli compile` | | View Knowledge Graph | Open the knowledge-graph view | `jolli graph` | | Add Plan / Add Markdown File / Add Text Snippet | Attach a plan or note to the branch | editor only | | Share Memory / Share Branch | Publish memories to a team Jolli Space | `jolli push` | Create PR lives in the branch footer of the sidebar, not the palette. The IntelliJ settings page at Settings > Tools > Jolli Memory exposes the Anthropic API key, model, and Jolli API key; other keys are managed via the CLI or by editing `config.json` directly. ## Agent support matrix Jolli Memory captures twelve sources across nine assistants. Each has a config toggle in the keys table above (`claudeEnabled`, `codexEnabled`, `geminiEnabled`, `openCodeEnabled`, `cursorEnabled`, `copilotEnabled`, `clineEnabled`, `devinEnabled`, and `antigravityEnabled` - three of those each cover two sources: `cursorEnabled` (the Composer IDE + the `cursor-agent` CLI), `copilotEnabled` (both GitHub Copilot sources), and `clineEnabled` (the Cline VS Code extension + CLI)). Claude Code and Gemini CLI capture through an agent hook, so restart them after `jolli enable`; the other ten are discovered at commit time and need no hook or restart. For each source's capture mechanism, session location, and Node 22.5+ requirement, see the [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) doc. ## Troubleshooting If something is not working, run this first: ```bash jolli doctor # checklist of hook, credential, and queue state jolli doctor --fix # release stale locks and reinstall missing hooks ``` For specific problems, such as summaries not generating, sign-in failures, or sync and Share in Jolli errors, see the Troubleshooting and FAQ doc. If you still need help, email support@jolli.ai with your `jolli doctor` output. ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Troubleshooting and FAQ](jrn:/global:docs:article/sync-6c6d4d79-61fa-477b-8079-dc88c7b998b5) - fixes for the common problems, and what data goes where. - [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) - how each assistant's sessions are captured. - [Jolli Memory in CI and Automation](jrn:/global:docs:article/sync-ffe2c24f-8a37-4c5b-88ae-4e5624f0d725) - headless auth, waiting for summaries, env vars, and backfill. --- # Supported AI Assistants and Capture Source: /jolli-memory/supported-ai-assistants-and-capture # 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. | Assistant | Capture mechanism | Where sessions live | Node 22.5+? | Toggle | Auto briefing | | --- | --- | --- | --- | --- | --- | | Claude Code | Hook (Stop hook records the session) | `~/.claude/` | No | `claudeEnabled` | Yes | | Gemini CLI | Hook (after-agent hook records the session) | `~/.gemini/tmp//chats/` | No | `geminiEnabled` | No | | Codex CLI | Discovery (filesystem scan) | `~/.codex/sessions/` and `~/.codex/archived_sessions/` | No | `codexEnabled` | No | | OpenCode | Discovery (local SQLite database) | `~/.local/share/opencode/opencode.db` | Yes | `openCodeEnabled` | No | | Cursor (Composer IDE) | Discovery (local SQLite database) | Cursor's `globalStorage/state.vscdb` | Yes | `cursorEnabled` | No | | Cursor CLI (`cursor-agent`) | Discovery (filesystem scan) | `~/.cursor/chats/` and `~/.cursor/projects/` | No | `cursorEnabled` | No | | GitHub Copilot CLI | Discovery (local SQLite database) | `~/.copilot/session-store.db` | Yes | `copilotEnabled` | No | | GitHub Copilot Chat | Discovery (filesystem scan) | VS Code workspace storage and `~/.copilot/session-state/` | No | `copilotEnabled` | No | | Cline (VS Code) | Discovery (filesystem scan) | `/User/globalStorage/saoudrizwan.claude-dev/state/taskHistory.json` | No | `clineEnabled` | No | | Cline CLI | Discovery (filesystem scan) | `~/.cline/data/sessions/` | No | `clineEnabled` | No | | Devin | Discovery (local SQLite database) | `~/.local/share/devin/cli/sessions.db` (`%APPDATA%\devin\cli\sessions.db` on Windows) | Yes | `devinEnabled` | No | | Antigravity | Discovery (local SQLite database) | `~/.gemini//conversations/` | Yes | `antigravityEnabled` | No | 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//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 — ]` 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](jrn:/global:docs:article/sync-f2f2e3c6-30b2-4ac5-9784-29da4e21c4b4) 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: ```bash 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](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Recall and Search](jrn:/global:docs:article/sync-f2f2e3c6-30b2-4ac5-9784-29da4e21c4b4) - how the Claude Code briefing and manual Recall reach your next session. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - the per-assistant config toggles and other keys. --- # Troubleshooting and FAQ Source: /jolli-memory/troubleshooting-and-faq # Troubleshooting and FAQ This is the place to look when Jolli Memory is not behaving, and the place to check the common questions before you adopt it. Part 1 walks through problems in the order they usually happen. Part 2 answers the questions people ask most. Whatever the symptom, run `jolli doctor` first. ## Part 1: Troubleshooting ### Start here: jolli doctor `jolli doctor` is the first thing to run for any problem. It prints a health checklist and tells you what, if anything, is broken. ```bash jolli doctor ``` Each line is one check: | Check | What it means | Healthy state | | --- | --- | --- | | Git hooks | The post-commit, post-rewrite, prepare-commit-msg, and post-merge hooks (a separate pre-push hook handles sync-on-push) | installed | | Claude hook | The Claude Code Stop and SessionStart hooks (optional) | installed | | Gemini hook | The Gemini CLI AfterAgent hook (optional) | installed | | Orphan branch | The `jollimemory/summaries/v3` branch that stores your Memories | exists (created on your first commit) | | Worker lock | The background worker's lock file, flagged stuck when older than 5 minutes | not stuck | | Sessions | Count of tracked agent sessions (informational only) | any number | | Git queue | Pending summary operations, flagged high above 10 entries | empty or low | | Config | Whether a usable credential is available | credentials found | | dist-paths | The per-source paths the hooks resolve to at runtime | at least one registered | | plugin ... | Version compatibility of any installed plugin | compatible | If a check fails, `doctor` exits with an error so you know to act. To repair automatically: ```bash jolli doctor --fix ``` `--fix` repairs three things: - Releases a stale worker lock. - Reinstalls missing git hooks. - Removes stale dist-path entries. `--fix` does not clear the queue. To remove expired queue data, run `jolli clean`. To work through a backlog of pending summaries, make one more commit (see [Stuck or backlogged queue](#stuck-or-backlogged-queue)). If `doctor` did not pin the problem, the sections below cover what it does not. ### No Memory after a commit The most common problem. Work through these in order. **1. Restart your agent.** This is the single most frequent cause. Two agents capture sessions through hooks, and those hooks only take effect for sessions started after you enabled Jolli. If you enabled Jolli while your agent was already open, restart it (in VS Code or a fork like Cursor or Windsurf, reload the window; in IntelliJ, restart the IDE). Use the table below to see whether your agent needs a restart. | Agent | How sessions are captured | Restart after enable? | | --- | --- | --- | | Claude Code | Stop hook records each response, SessionStart hook injects a briefing | Yes | | Gemini CLI | AfterAgent hook fires after each completion | Yes | | Codex CLI | Discovered automatically by scanning the filesystem | No | | OpenCode | Discovered automatically from a local SQLite database (requires Node 22.5+) | No | | Cursor IDE (Composer) | Discovered automatically from Cursor's local SQLite stores | No | | GitHub Copilot CLI | Discovered automatically by scanning the Copilot CLI session log | No | | VS Code Copilot Chat | Discovered automatically from the Copilot Chat conversation cache | No | | Cursor CLI (`cursor-agent`) | Discovered automatically by scanning `~/.cursor/chats` and `~/.cursor/projects` | No | | Cline (VS Code) | Discovered automatically from the extension's task history | No | | Cline CLI | Discovered automatically by scanning `~/.cline/data/sessions` | No | | Devin | Discovered automatically from a local SQLite database (requires Node 22.5+) | No | | Antigravity | Discovered automatically from a local SQLite database (requires Node 22.5+) | No | **2. Check your credentials.** Memory needs a credential to generate summaries. Run `jolli status` (or check the Status panel). If nothing is configured, set one: ```bash # Sign in with Jolli jolli auth login # Or bring your own Anthropic key jolli configure --set apiKey=sk-ant-api03-... ``` With no credential, `doctor` reports `Config: no credentials`, and the log shows `No LLM provider available.` **3. Confirm hooks are installed.** If `doctor` reports `Git hooks: not installed`, run `jolli enable` from the repo root, then commit again. **4. Confirm a supported agent was running.** A Memory is built from a conversation transcript. If you committed without one of the twelve supported sources (see the table above) active in that repo, there is nothing to summarize. Every source except Claude Code and Gemini CLI is discovered automatically, so no hook or restart is needed for them, but the agent does need to have produced a session. **5. Check the queue.** If everything above is fine, the background worker may be stuck. See the next section. For deeper diagnosis, open the log. In VS Code, use **View -> Output -> Jolli Memory**. Common messages: | Message | Meaning | | --- | --- | | `No LLM provider available.` | No credential is set. Sign in or add an API key. | | `LLM proxy request failed with status 429` | Rate limited. Memory retries once within a few seconds; if that also fails it saves a placeholder summary you can refill later by clicking Regenerate on that commit. | | `LLM direct request to api.anthropic.com failed` | Your Anthropic key is invalid or rate limited. | ### Stuck or backlogged queue A stuck lock, or a backlog of queued summaries, usually means the worker crashed or the LLM provider was unreachable for a while. ```bash jolli doctor # Reports lock state and queue size jolli doctor --fix # Releases a stale lock jolli queue-status # Reports whether summary generation is still running jolli clean --dry-run # Previews expired data that can be removed jolli clean # Removes expired sessions, queue entries, and squash markers ``` For a backlog, just make one more commit. The worker picks up where it left off and processes the rest from that point. `jolli clean` only removes expired auxiliary data: session entries older than 48 hours, queue entries older than 7 days, and stale squash markers older than 48 hours. Your stored Memories and transcripts are never deleted by `clean`. In a non-interactive shell (CI, pipes, redirected input) `clean` refuses to delete unless you pass `-y` or `--yes`, so nothing is wiped by accident. ### Sign-in failures If the browser callback page shows an error, match the code below. | Code | Meaning | What to do | | --- | --- | --- | | `oauth_failed` | The OAuth flow failed. | Retry. If it persists, use BYOK instead. | | `session_missing` | The sign-in session expired or was lost. | Retry the sign-in. | | `invalid_provider` | The authentication provider was rejected. | Retry. If it persists, contact support. | | `auth_fetch_failed` | Jolli could not fetch your user info from the provider. | Retry. | | `no_verified_emails` | Your Jolli account has no verified email. | Verify an email on your account, then retry. | | `server_error` | An unexpected server error occurred. | Wait a moment and retry. | | `failed_to_get_token` | Jolli could not retrieve your credentials. | Retry. Fall back to BYOK if it persists. | | `user_denied` | Sign-in was cancelled. | Run `jolli auth login` (or Sign In again) to retry. | | `invalid_callback` | The server rejected the sign-in callback. | Retry. | | State mismatch | The callback did not match the flow you started (shown as "Invalid sign-in callback (state mismatch)"). | Retry the sign-in from the same machine. | If you see "Could not derive Jolli site URL from API key", your Jolli API key is malformed or incomplete. Regenerate it at **Settings -> Jolli Memory -> Create Key** and sign in again. BYOK is always a fallback: if sign-in keeps failing, add an Anthropic key with `jolli configure --set apiKey=sk-ant-api03-...` and you can still generate Memories (you just cannot use Share in Jolli without a Jolli key). ### Share in Jolli failures Share in Jolli posts a commit's summary to your Jolli Space. When it fails, the HTTP status tells you why. | Status | Meaning | What to do | | --- | --- | --- | | 426 | Your extension or CLI is older than the server requires ("Plugin Outdated"). | Update the VS Code or IntelliJ extension, or the CLI, to the latest version. | | 412 | This repo is not yet linked to a Jolli Space (`binding_required`). | Complete the Share flow, which prompts you to link the repo to a Space first. | | 409 | The repo is already linked to a Space (`binding_already_exists`). | No action needed. A concurrent link already won. | | 403 | The server rejected the request; the message shown comes from the server. | Usually a Jolli API key issued for a different tenant or org, or revoked access. Run `jolli auth status`, then re-authenticate. | To check which workspace you are signed in to: ```bash jolli auth status ``` If you are not signed in at all, Share asks you to sign in or add a Jolli API key first (in VS Code the button warns "Please configure your Jolli API Key first"; the CLI `jolli push` reports "Not signed in to Jolli"). Run `jolli auth login`, or paste a Jolli API key in the Settings panel. A BYOK-only setup (Anthropic key, no Jolli account) cannot use Share in Jolli. Note: a 429 (rate limit) is not a Share error. It comes from summary generation through the Jolli LLM proxy. Memory retries the summary once within a few seconds; if that retry also fails, it saves a placeholder summary that you can refill later by clicking Regenerate on that commit. ### MCP tools not appearing If your AI agent does not show the Jolli Memory tools (`search`, `recall`, and the rest), check these in order. 1. **Did enable run?** MCP registration happens during `jolli enable`. Run `jolli status` to confirm Jolli is enabled in this repo. 2. **Is the server registered for your host?** `.mcp.json` in your project root is where `jolli enable` writes the `jollimemory` server for **Claude Code** (and Copilot CLI). Other hosts use their own config: Cursor reads `.cursor/mcp.json`, and Gemini, Codex, OpenCode, and VS Code Copilot Chat each read a machine-wide file (see the host table in the "Connect Memory to Your AI Assistant (MCP)" doc). Confirm the file for *your* host exists and contains the entry. 3. **Restart your host.** Your agent reads `.mcp.json` at startup, so restart it (or reload the window) after enabling. If the tools appear but search returns nothing or looks stale, rebuild the local search index: ```bash jolli mcp --reindex ``` `--reindex` rebuilds the search index only. It does not register the server or refresh the tool list, so if tools are missing entirely, the fix is in steps 1 to 3 above, not here. For the full list of tools and how each host connects, see the "Connect Memory to Your AI Assistant (MCP)" doc. ### Missing Memory Bank Markdown files If a visible `.md` file in your Memory Bank folder was deleted (by you or another tool), restore it: ```bash jolli heal-folder ``` This re-renders the missing Markdown from the hidden canonical JSON that Jolli keeps alongside it. It does not call the LLM and does not re-summarize anything, so it is fast and free. Your Memories on the orphan branch are the source of truth and stay intact either way. Healing works only when your storage is in dual-write or folder mode (the default is dual-write). If the repo is set to orphan-only storage, there are no visible Markdown files to heal, and the command tells you so. ### Still stuck File an issue at support@jolli.ai and include your `jolli doctor` output. That output captures your hook, credential, lock, and queue state, which is exactly what we need to help. ## Part 2: FAQ ### Will Jolli Memory slow down my commits? No. Your commit returns immediately. The git hook enqueues the work and hands it to a background worker, then gets out of the way. The summary is generated in a detached process and appears in your editor shortly after, usually within about 10 to 20 seconds. If a summary call fails, it retries once after a short delay, then saves a minimal record so nothing downstream breaks. ### Does Jolli Memory send my code anywhere? Your code stays private by default. Here is exactly what happens: - Your transcripts stay on your machine by default. They are uploaded only if you turn on `syncTranscripts` for Memory Bank cloud sync (or run `jolli sync-memory-bank --transcripts`); they are never sent on Share in Jolli. - To build a summary, your transcript and git diff are sent to the LLM. Either directly to Anthropic (when you use your own Anthropic key) or through the Jolli LLM proxy (when you signed in with Jolli). The proxy holds the payload in memory only for the request and never stores it or writes it to a log. - Only the generated summary is saved, and it is saved locally. It leaves your machine when you click Share in Jolli, and then the summary (plus a structured JSON copy), the commit hash, branch, commit author, date, change stats, the changed-file paths, any extracted references (Linear, Jira, GitHub, Notion, Confluence, Asana, monday.com, Slack, Zoom, and Context7 library lookups), your repository's remote URL, and any attached plans and notes are sent. Raw transcripts and the raw diff are never sent to a Jolli Space. ### Does it work offline? Mostly. Your commit and your local Memory storage work fully offline, because the commit hook and the on-disk storage do not need the network. Only summary generation needs the network, since it calls the LLM. If you commit while offline, the worker records a minimal entry and the summary fills in later. Make one more commit once you are back online and the worker processes the backlog. ### Does it work with monorepos and git worktrees? Yes to both. Jolli Memory is worktree-aware: hooks and summaries work across `git worktree` checkouts, and each worktree tracks its own current branch so its Memories stay consistent. A monorepo is just one repository, so it works normally. One Memory Bank folder can also hold many repositories, each in its own subfolder. ### How do I see what Jolli has captured? Several ways, depending on where you are: - **In the editor sidebar (Current Branch view).** The **Committed Memories** section lists every commit's Memory; click the eye icon on one to open it: a Quick recap and per-topic cards with **Why this change**, **Decisions behind the code**, and **What was implemented** callouts, plus Conversations, Context, and Files panels. The **Working Memory** block above it shows what will go into your *next* commit's Memory before you commit, so you can see (and adjust) what is being captured. - **In the Memory Bank.** The Memory Bank view browses every stored Memory across branches and repos, with search and a Tree / Timeline toggle. Because the Memory Bank is also plain Markdown on disk (default `~/Documents/jolli//`), you can open and read it with any tool, no extension required. See [Memory Bank and Sync](jrn:/global:docs:article/sync-f0d547bc-8e4e-4604-9c1a-a2653d538469). - **From the CLI.** ```bash jolli view # compact list of recent memories jolli view --commit 1 # the latest commit's full Memory jolli view --commit # any commit by hash prefix jolli status # which assistants and sessions Jolli detected jolli recall # the current branch's compiled context ``` ### What is stored where? | Data | Where it lives | Leaves your machine? | | --- | --- | --- | | Raw transcripts | Orphan branch and Memory Bank folder (both local) | Only if you enable `syncTranscripts` (Memory Bank cloud sync); never on Share in Jolli | | Git diff | Sent to the LLM at summary time | Not stored by Jolli, discarded after the summary is made | | Generated summaries | Orphan branch and Memory Bank folder (both local) | Only when you click Share in Jolli | | Session metadata | Project `.jolli/jollimemory/` (local, gitignored) | No | | Plans and notes | Local, attached to commits | Only the attached ones, on Share in Jolli | | Usage telemetry | Local buffer, flushed in small batches | Yes; content-free, and attributable to your account only when signed in | The orphan branch (`jollimemory/summaries/v3`) is the source of truth and is completely separate from your code history. See the "Memory Bank and Sync" doc for how the folder is laid out. ### Is telemetry on, and can I turn it off? Usage telemetry is on by default. It is content-free: event names, surface and version, OS and Node version, CPU architecture, a deployment-tier tag, a timestamp, a random install ID, and coarse counts. It never includes your code, file paths, commit messages, diffs, transcripts, Memory content, or repo or branch names. The payload carries no account identifier; note that when you are signed in to Jolli, events upload with your Jolli key, so the server can associate them with your account at ingest. BYOK or signed-out setups upload with no key and stay unattributed. Turn it off any time with either of these: ```bash # Persisted opt-out jolli telemetry off # Or the standard environment variable export DO_NOT_TRACK=1 ``` Check the current state with `jolli telemetry status`, and see exactly what would be sent with `jolli telemetry inspect`. ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, sign in, and your first Memory. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - config keys, commands, and recovery paths. - [Supported AI Assistants and Capture](jrn:/global:docs:article/sync-dfa7b9b8-3232-4e54-b495-7e68050e09b3) - why a session might not be captured. --- # Use Your Memory from Any AI Assistant (MCP) Source: /jolli-memory/use-your-memory-from-any-ai-assistant-mcp # Connect Memory to Your AI Assistant (MCP) Jolli Memory captures the reasoning behind your commits. This page connects that memory to your AI assistant through the Model Context Protocol (MCP), so the assistant can read your history from inside the chat. No terminal, no copy-paste. Ask "what did we decide about auth?" or "recall this branch," and the assistant answers from your real stored Memories instead of guessing. ## What you get Enabling Jolli exposes a set of tools to your AI assistant. Most are read-only; a couple write on your behalf (`push_memory` and `bind_space` publish to and bind a Jolli Space, covered below). Four read tools cover the everyday "remember what we did" job: - **search** - Ask "have we handled rate limiting before?" and the assistant searches every branch's Memories for the answer. - **recall** - Ask it to recall a branch and it loads that branch's full context: decisions, plans, notes, and commits. - **get_decision_timeline** - Ask how a decision evolved and it traces that topic across commits, oldest first. - **list_branches** - Ask which branches have Memories and it lists them with their topics. You ask in plain language. The assistant picks the tool and answers in the chat. Also available: **get_pr_description** and **queue_status** power the pull-request workflow (see Create PR in [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu)); **bind_space**, **list_spaces**, and **push_memory** back Share in Jolli (see [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju)); and **status** reports the health of your Jolli setup for this repo - which hooks are installed, your hook runtime, account and API-key configuration, detected AI integrations, and your stored-Memory count. You never call these by name; your assistant reaches for them when the task calls for it. When you are signed in, the server may also register additional Jolli-hosted tools defined by the backend, so your assistant can see more than the built-ins listed above. Set `mcpPlatformToolsEnabled` to `false` for a built-ins-only server. ## Automatic setup Jolli's MCP server is **CLI-hosted**: a local stdio process - `jolli mcp` - that each host spawns on your own machine and talks to over standard input and output, registered under the server key `jollimemory`. There is no remote URL and no `.well-known/mcp.json`, so there is nothing to point a hosted or cloud MCP client at; your Memories never leave your machine to be queried. There is no separate MCP install. When you enable Jolli in a repo, the `jollimemory` server is registered for you into every supported AI host that Jolli detects on your machine: | Host | Where it's configured | | ---- | --------------------- | | Claude Code | `.mcp.json` in the repo | | Cursor | `.cursor/mcp.json` in the repo | | Gemini CLI | `~/.gemini/settings.json` | | Codex CLI | `~/.codex/config.toml` | | OpenCode | `~/.config/opencode/opencode.json` | | GitHub Copilot CLI | `~/.copilot/mcp-config.json` | | VS Code Copilot Chat | the VS Code user folder's `User/mcp.json` | Claude Code and Cursor are configured per repo. The other five share one machine-wide config. A host is wired up only if Jolli detects it, so if you install a new assistant later, run `jolli enable` again to register it. All three Jolli surfaces register the server: - **CLI** - `jolli enable` from the repo root. - **VS Code** (or a fork such as Cursor or Windsurf) - **Enable Jolli Memory** in the Status panel. - **IntelliJ** - **Enable** in the tool window. IntelliJ needs Node.js on your PATH for the MCP server and the `/jolli-search` skill; the plugin sets them up by running its bundled CLI. Without Node, those are skipped cleanly and the tool window shows "MCP & Skills: Node.js not found." The `/jolli-recall` skill still installs (it ships natively with the plugin, no Node needed), and memory generation keeps working through the plugin's native hooks. ### Any other MCP host Only those seven hosts are auto-registered, but the `jollimemory` server is a standard stdio MCP server, so any MCP-capable host can use it. If yours isn't on the list, wire it up by hand: register a **stdio** server with command `jolli` and args `["mcp"]`, under whatever key that host uses for its stdio servers. That's the same `jolli mcp` process the supported hosts spawn - it just assumes the global CLI is on your `PATH` (`npm install -g @jolli.ai/cli`; see [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu)). ## Turn it on and verify 1. Enable Jolli in your repo (see above) and make sure the repo has at least one commit with a Memory. 2. **Restart your AI assistant.** This is the step people miss. An assistant reads its MCP config at startup, so a session that was already running will not see the new server until you restart or reload it. In VS Code (or a fork such as Cursor or Windsurf), reload the window; in a JetBrains IDE, restart it; for a CLI assistant, quit and reopen. 3. Ask the assistant to use it: - "Recall this branch." - "What did we decide about the caching layer?" - "Have we dealt with duplicate webhook deliveries before?" If it answers with specifics grounded in your commits, you are set. On Claude Code the tools appear namespaced as `mcp__jollimemory__search`, `mcp__jollimemory__recall`, and so on. Other hosts list them under a `jollimemory` server. You rarely need the exact names; plain language is enough. ## Skills vs tools Alongside the MCP tools, `jolli enable` installs guided skills. On Claude Code they are slash commands; on other hosts they are Agent Skills. They call the MCP tools for you (and fall back to the CLI when a host has no MCP support), so they are the easy front door: - **/jolli-recall** - deep on one branch. Loads that branch's full Memory and synthesizes an answer. Use it to resume or understand a specific branch. - **/jolli-search** - broad and shallow across every branch. Returns relevance-ranked hits. Use it to find where something was decided. Rule of thumb: search to find the branch, recall to go deep on it. ## Troubleshooting **The tools do not show up.** - Restart the assistant. Its MCP config is read at startup (see above). - Check that your assistant is one of the seven supported hosts listed under Automatic setup. If it was not installed when you ran enable, install it, then run `jolli enable` again. - IntelliJ only: confirm Node.js is on your PATH, then reopen the project to retry. The tool window's "MCP & Skills" row reports the current state. **Search results look stale or empty.** The search index is a disposable local cache, separate from your stored Memories. Rebuild it: ```bash jolli mcp --reindex ``` It reindexes from your stored Memories and prints how many documents it loaded. For anything else, run `jolli doctor` and see the troubleshooting section in [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q). ## Related - [Getting Started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - install, enable, and your first Memory. - [Reference](jrn:/global:docs:article/sync-untitled-mokfos2wnr5q) - the MCP tool list, config keys, and CLI commands. - [Recall and Search](jrn:/global:docs:article/sync-f2f2e3c6-30b2-4ac5-9784-29da4e21c4b4) - what recall and search do, and when to reach for each. --- # Jolli Sites Source: /jolli-sites # Jolli Sites A Site is a published documentation website built from a Space. One Space can power more than one Site (a public one and an internal-only one drawing from the same Articles, for example). You don't write content on a Site. Writing happens in a [Space](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju); a Site is the published output. ## Create a Site From the sidebar, click **+** next to **Sites**. The wizard has four steps (three for Spaces backed by a git repo, which take their branding from the repo). ### Basics - **Display Name** - the human-readable title shown in the browser tab and the Site header. Example: `Orbit SDK Docs`. - **Site Name** - Lowercase letters, digits, and hyphens; minimum 3 characters. Becomes part of the URL. - **Subdomain** - optional; must start and end with a letter or digit, no consecutive hyphens (3–63 characters). Blank means Jolli generates one from the Site Name. A live URL preview (`docs-account.jolli.site`) updates as you type. You can point your own domain at the Site afterward. ### Content Pick the Space the Site pulls Articles from. Your space content structure will be used to generate the structure of your site. ### Branding Preset themes help you decide the base look and feel of your site. Once selected, you can override colors, logos, fonts, header links, and footer on the **Branding** tab after creation. ### Access | Tier | Who can read | | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | | **Public** | Anyone with the link; search engines can index it. | | **Restricted to Jolli users** | Signed-in members of your organization only. | | **Restricted to ALL Jolli users** | Any signed-in Jolli user, even outside your organization. Gated by an organization capability - if it's not enabled, this option doesn't appear. | Restricted (auth-required) Sites show a sign-in banner on every page, controlled by a toggle that is on by default. Public Sites have no sign-in banner. Click **Create Site**. Jolli builds the initial version, provisions hosting, and deploys. Status moves from **Publishing...** to **Up to date**; click the external-link icon to open it. ## Theme packs The **Branding** tab leads with a theme pack - the overall look and layout your Site is built on. Pick one from the preview cards, then fine-tune colors, typography, logo, and navigation in the sections below. Two built-in packs ship today - **Forge** and **Atlas** - and more may be available from the theme registry. Advanced **Custom CSS** controls appear only if your organization has that capability enabled. Git-backed Sites take their branding from the connected repo, so the Branding tab is read-only for them. ### Upgrading from Classic (one-way) Older Sites may still be on the **Classic** pack, which carries extra Layout and Navigation controls. Selecting a built-in pack (Forge or Atlas) on a Classic Site is a one-way upgrade: - A confirmation dialog shows which pack you're switching to before anything changes. - Confirming restyles the Site and drops the Classic-only Layout and Navigation settings. **There is no way back to Classic** once you upgrade. - A Classic Site can't jump straight to a registry theme - upgrade to a built-in pack first, then pick a registry theme from the normal picker. Branding changes, including a pack upgrade, take effect on the next publish. ## Tweaking branding after creation The Site detail view's **Branding** tab handles post-create edits. Changes apply on the next publish. - **Default theme** - Light, Dark, or System. - **Typography** - The font style that your site uses - **Accent color** - pick from preset swatches, a color picker, or a hex value. Drives headings, links, and primary actions. - **Logo URL** - PNG, SVG, or WebP. Around 400px wide for retina. - **Favicon URL** - ICO, PNG, or SVG; 32×32 or 16×16. Logo and favicon are URL-based, not uploaded - you provide a publicly accessible URL Jolli fetches at build time. ### Header navigation Add up to 6 top-level header items beyond the auto-generated content tree. Each item is either: - A **Link** - label + URL. - A **Dropdown** - label + up to 8 child links. Use it for things that don't belong in the navigation tree itself - Pricing, Changelog, your main marketing site, an external GitHub link. ### Footer - **Copyright** line - up to 200 characters. - Up to **4 columns**, each with a title and up to **10 links**. Group resource links however you like. - **Social links** - GitHub, Twitter/X, Discord, LinkedIn, YouTube, and Bluesky. Each renders in the footer. ## Custom domain Every Site gets a `sitename-account.jolli.site` URL by default. Point your own domain at it under **Site Settings → Custom Domain**. Each site supports one custom domain. You can add a subdomain (`docs.yourdomain.com`) or an apex (`yourdomain.com`). Each needs a different DNS record type. ### Subdomain - CNAME | Field | Value | | --------- | --------------------------------------------------------------- | | **Type** | CNAME | | **Host** | the subdomain part (`docs`, if you added `docs.yourdomain.com`) | | **Value** | the value Jolli displays on the Domain tab | Field names vary by provider - Host may be called "Name," Value may be called "Target." ### Apex - A | Field | Value | | --------- | --------------------------------------- | | **Type** | A | | **Host** | `@` (or leave blank) | | **Value** | the IP Jolli displays on the Domain tab | Apex domains don't support CNAME at the top level. If your DNS provider supports ALIAS, ANAME, or flattened CNAME at the apex (Cloudflare and a few others), follow their guidance. Leave TTL at the provider default. ### Verify ownership (TXT) Some domains need a second record to prove ownership - usually an apex domain, or one already in use on the hosting side. When Jolli shows a **Verify domain ownership** step with a **TXT** record, add that record too, alongside the CNAME or A record above. If no TXT step appears, none is needed. ### Verification The domain enters the list as **Awaiting DNS**. While any domain is pending, Jolli auto-checks the DNS record. When the record matches, the status moves to **Connected**. If it doesn't match, the status shows **Check DNS** - usually a wrong record type, an existing conflicting record, or a DNS-provider quirk (Cloudflare's proxy mode, for instance, can change CNAME resolution). Click **Verify** to force an immediate re-check. DNS propagation usually takes 30 minutes or less; rarely several hours. To remove a domain, find it in the list and click **Remove**. Jolli stops serving the Site at that domain immediately. Re-adding requires re-verifying DNS. A domain points at exactly one Site. Use subdomains (`docs.`, `help.`) to host multiple Sites under the same root. ## Publishing Each Site shows a status indicator: - **Up to date** - live Site matches current Articles. - **Publishing...** - rebuild in progress. - **Pending Changes** - unpublished edits in the Space; click **Publish** to catch up. - **Build error** - last build failed; click for logs. ### Manual publish Click **Publish** on the Site's **Overview** tab. Jolli rebuilds from the current Space state and deploys. While a site is building, the indicator shows a live progress percentage that updates as the build proceeds. If you started it by mistake, click **Cancel Build** to stop the site publishing. ### Auto-publish schedule Under **Site Settings → Auto-Publish Schedule**, enable the schedule and set: - **Every N day(s)** - daily, every 3 days, weekly, etc. - **Hour** -12-hour picker with AM/PM. We recommend selecting a low-traffic hour for your site. - **Timezone** - read-only, from your profile. Scheduled builds run on the cadence you set, regardless of whether anything changed - each run regenerates and republishes the Site. Pick a low-traffic hour and a sensible interval so you aren't rebuilding more than you need. ### Publish on branch update For a Site whose Space is backed by a git repository, **Site Settings → Publish on Branch Update** republishes the Site automatically whenever its watched branch is updated. Turn on **Enable publish on branch update**, and the panel shows which branch is being watched. Unlike the schedule above, this fires on a push rather than on a clock. ### Source-driven publishing If the Site's Space has connected Sources, [Gap Analysis](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) can trigger rebuilds when tracked code changes. A push lands → Gap Analysis proposes a Changeset → auto-apply (if on) applies it → **Pending Changes** appears → the next auto-publish or manual click rebuilds. Auto-apply is **off** by default for most Spaces (the guided *import* flow is the exception). ### Build errors Common causes of build failures include: - **Malformed Markdown** - usually an unclosed code fence or HTML tag. The build log names the article and line. - **Invalid OpenAPI spec** - JSON or YAML parses but is missing required fields (`openapi`/`swagger`, `info.title`, `info.version`, `paths`). (Both JSON and YAML are accepted; no conversion needed.) - **Broken image references** - an image URL in an article isn't reachable from the build environment. (A Space with no published Articles is *not* a build error - it builds a placeholder page.) Every failure produces a plain-English **What Happened** summary plus the last 500 lines of raw build logs. Open the build error from the changes indicator at the top of the site detail view. ## AI discovery (llms.txt) Every published Site automatically generates two plain-text files at its root for AI clients (Claude, Cursor, ChatGPT, and others) to ingest: - **`/llms.txt`** - a titled, sectioned index of the Site's pages, each with its link and a short description. Sections follow your navigation and folder structure; OpenAPI specs are grouped under an **API Reference** section. - **`/llms-full.txt`** - the full prose corpus: every page's Markdown body concatenated into one document. Both are written on every publish - for git-backed and managed Sites alike - and every page advertises them in its HTML `` (``) so AI clients can discover them automatically. Page descriptions come from each Article's frontmatter `description:`, falling back to its first paragraph. To ship your own version of either file, commit an `llms.txt` or `llms-full.txt` at your docs root - Jolli passes an author-provided file through untouched. A very large `llms-full.txt` (roughly 2 MB or more) still builds but logs a size warning, since a big corpus can slow AI ingestion. On a Restricted Site, both files sit behind the same sign-in gate as the rest of the Site. ## Delete a Site Deleting a Site is permanent. It lives in a **Danger Zone** at the bottom of **Site Settings**, available once the Site has finished its first build (its status is live or shows a build error). - Click **Delete Site**. An inline confirmation appears with a warning that the action can't be undone. - Confirm to permanently delete, or cancel to back out. While the delete runs, the button shows a deleting state. Deleting a Site removes the published website and stops serving it. The [Space](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) it was built from - and all its Articles - are untouched; you can build a new Site from the same Space later. ## Next steps - [Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) - where the content actually lives. - [Editing & Organizing](jrn:/global:docs:article/sync-untitled-mokfrxl9dj57) - the writing surface. - [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) - the AI assistant and review flow that produces what gets published. --- # Editing Source: /jolli-spaces/editing # Editing & Organizing The manual writing surface: the Article editor and the tools for finding and organizing content within a Space. For the AI side - drafting with the Agent, Changesets, and Gap Analysis - see [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f). ## The editor Click any Article to open it. Standard Markdown syntax (`#`, `**bold**`, `[link](url)`) renders live. Folders open the same editor - a Folder can hold its own content. ### Floating toolbar Select text and a small toolbar floats above the selection: bold, italic, underline, strikethrough, inline code, link, blockquote, headings H1–H4, paragraph reset. The toolbar only appears with a selection - nothing always-on at the top of the editor. There are no list or table buttons. Use Markdown directly (`-` for a list, pipes for a table); the editor renders them live. ### Auto-save Every edit auto-saves about two seconds after you stop typing - there's no Save button. Live multi-user editing isn't supported yet: if two people edit the same Article simultaneously, the last save wins. Use Changesets (via the Jolli Agent or Gap Analysis) for any collaborative writing flow. ### Cross-article links Type `[[` to open an inline search popover, type part of another Article's title, pick it. The link tracks the target Article - if it gets renamed, the link text updates. Cross-Space references need full URL links; the popover only searches the current Space. ### Images and uploads Drag images into the editor (PNG, JPEG, GIF, WebP; 10 MB per file). For text files, the Folder's three-dot menu has an **Upload File** option that creates an Article from the upload. Accepted formats are `.md`, `.mdx`, `.txt`, `.json`, `.yaml`, and `.yml`, up to 1 MB; the resulting Article is fully editable like any other. OpenAPI specs (JSON or YAML) are recognized automatically - drop one in and it renders as an interactive API reference page on the published Site. ### Version history Every change creates a history entry, browsable from the right-side rail. You can view, copy from, or restore any past version. Restoring creates a new version with the old content; you don't lose history. ### Delete and restore Soft-delete via the three-dot menu. Articles move to the Space's Trash and can be restored or permanently deleted from there. Folders move with everything inside them. ### Comments Every Article has a comment thread in the right-side rail. Comments are on the Article as a whole, not anchored to paragraphs - quote in your comment if you need to point at one. You can reply (one level deep), edit or delete your own comments, and @-mention a teammate to notify them. Threads update in real time, and comment activity appears in your Inbox. ## Organizing ### Searching within a Space A search box sits above the Article tree. Start typing and the tree narrows to matching Articles as you go. - Search runs a short beat after you stop typing, so you don't need to press Enter. - Click the **X** in the box, or press **Esc**, to clear the search and restore the full tree. - Search is scoped to the current Space. To find something in another Space, switch to it first (or use a cross-Space URL link, covered above). ### Drafts Article drafts - new Articles you or the Jolli Agent started, plus in-progress edits to existing Articles - collect on a dedicated **drafts** page, reachable via **View all** from the drafts list. A draft is standalone until you finish it; it isn't part of the published Space yet. - Each row shows the draft title, a short content preview, when it was last edited, and who created it. - The search box filters the list by title and content (case-insensitive). - **Edit** opens the draft in the editor; the trash icon deletes it after a confirmation prompt. Deleting a draft only discards that unfinished draft - it never touches a published Article. ## Next steps - [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) - let the Agent draft content, and keep docs in sync with Gap Analysis. - [Managing a Space](jrn:/global:docs:article/sync-3d5b8f14-2c7e-4a09-b6d1-0f1e2d3c4b5a) - members, visibility, automation, and storage. - [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) - publish the Space at a URL. --- # Getting Started with Jolli Spaces Source: /jolli-spaces/getting-started-with-jolli-spaces # Jolli Spaces A Space is where documentation lives in Jolli. You bring your existing docs in (or generate them from code); the Jolli Agent and Gap Analysis keep them in sync as the code changes; every edit passes through review before going live. When you're ready to share, you publish a [Site](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) from the Space. ## What lives in a Space - **Articles.** The core unit of content. Markdown by default; JSON content type for OpenAPI specs. - **Folders.** Group Articles. Nestable, drag-and-drop. - **Sources.** External inputs (GitHub repos) the AI reads to import, generate, and detect drift. - **Changesets.** Edits the Jolli Agent or Gap Analysis proposes, batched for review before they go live. - **The Jolli Agent.** Jolli's AI assistant, in its own tab. See [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f). ### Sorting and filtering The controls above the Article tree let everyone browsing the Space narrow what they see: - **Sort** - Default (the Space's manual order), Alphabetical, Last Updated, or Created. Each has ascending/descending variants. - **Filters** - restrict to Articles updated in a window (Today / Last 7 days / Last 30 days / Last 3 months / a custom date) and/or by creator name. ## Who Spaces is for Teams and individuals. On signup, Jolli creates a **Personal Space** for you so you have a place to work right away. On your first sign-in, Jolli also provisions a ready-made **Shared Space** - seeded with a Welcome doc - and drops you into it, so your team has somewhere to collaborate from the start. Create additional shared Spaces any time. ## Finding your way around ### Favorites The sidebar shows a **Spaces** section and a **Sites** section, each capped at six items so the list stays scannable. Hover any Space or Site and click the star to pin it as a favorite. - Favorites sort to the top of their section (alphabetically), then remaining slots fill with your other Spaces or Sites. - A pinned item shows a filled star; hover an unpinned one to reveal its empty star. Click again to unpin. - If you have more than six favorites in a section, all of them show and the cap is lifted. - **View all shared spaces** / **View all sites** appears only when some items are hidden by the cap - click it to open the full list. Favorites are per-section: starring a Space has no effect on the Sites list, and vice versa. Your Personal Space and any Jolli Memory Spaces (Spaces populated by [Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu), Jolli's dev-context capture tool) aren't part of the Spaces favorites list - they have their own spots in the sidebar (Jolli Memory Spaces live under the **Memory** section). ### Your Personal Space in the sidebar Your Personal Space has a fixed spot in the sidebar (the **Personal Space** entry, marked with a person icon), separate from the shared **Spaces** list. Click it to jump straight to your own private Space. - It's the single-user Space Jolli creates for you on signup - a place to draft and experiment before anything is shared. - It never appears in the shared Spaces list or its favorites, so team Spaces and your private one stay visually distinct. - If your account is deleted, Personal Spaces are removed rather than transferred to an admin (unlike shared Spaces). See [Settings](jrn:/global:docs:article/sync-untitled-mokfp9i8vkfx). ## Onboarding On first sign-in, the **Jolli Agent** runs a guided walkthrough that **generates documentation fresh from your source code**. If you already have docs, it reads them as a signal for audience and structure - but still generates from the code so the output stays current. To bring existing Markdown in **as-is** instead, use **Import from GitHub** - a connected GitHub repo, or a public repo URL (no authentication needed) - to pull `.md` files straight into a Space. Once you kick off generation, Jolli creates a new Space and offers next steps, such as creating a Site from it. ### What the import does For a typical docs folder (dozens of files), expect a few minutes. The Agent: - Preserves your folder structure where it makes sense. - Imports Markdown only (`.md` / `.mdx`). Other formats - RST, AsciiDoc, Textile, and anything non-Markdown - are skipped. - Flags issues it finds for you to resolve, rather than silently rewriting them (see below). Two things the import does **not** do automatically - the Jolli Agent offers each as a follow-up step: - **Images.** Imported images still point back to the source repository, so your published Site depends on it staying available. The Agent can re-upload them to Jolli so they're self-hosted instead. - **Internal links.** File-path links from the original repo won't resolve in Jolli; the Agent can match them to the imported Articles and rewrite them on request. Imports land **directly** in the Space - no Changeset review on the import itself. Edits you make later from the Jolli Agent chat (and AI-proposed updates from Gap Analysis) do flow through Changesets. ## Sources A Source is where a Space pulls external content from. | Kind | What it is | Auth | | ---------------------- | --------------------------------------------------- | ------------------------------------------------------ | | **GitHub App** | Private (or public) repos via the Jolli GitHub App. | Install once per org; read-only contents and metadata. | | **Public GitHub repo** | Any public repo by URL. | None. | Sources drive three things: the initial import, ongoing Gap Analysis drift detection, and optional Generate from code. See [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) for how Gap Analysis reads them. ### The two-layer model Sources live at the organization level, not per-Space. One connected Source can feed any number of Spaces. 1. **Organization Sources** - managed at **Settings → Sources**. A GitHub App installation is one row at this level. 2. **Space Sources** - each Space picks which organization Sources it consumes, under **Space Settings → Automation**. Connect once; link from any Space. ### Connecting **GitHub App.** **Settings → Sources → Connect Source → GitHub App** routes you to GitHub's install page. Pick the org and repos (All repositories or Selected). If your org admin needs to approve third-party apps, they review the read-only permissions before allowing. **Public GitHub repo.** **Settings → Sources → Connect Source → Public GitHub Repo**. Paste the URL. Once connected, link a Source to a Space under **Space Settings → Automation → Add sources**. ### Sync Connected Sources stay live. Two modes per Source: - **Webhook events** - near-real-time, default for GitHub App Sources. - **Scheduled polling** - for cases where you'd prefer suggested changes be aggregated. Tracked branch (and which repos a GitHub App can see) is configurable per Source under **Settings → Sources → Configure**. The choice between webhook-driven and scheduled sync lives per Space under **Space Settings → Automation**, because the same Source can feed multiple Spaces with different cadences. ### Source statuses - **Connected** - working normally. - **Needs Attention** - usually a lapsed permission or auth issue. Click in to see the cause. Each Source's menu has **Manage** (which Spaces use it, recent activity), **Configure** (tracked branch, sync mode), and **Disconnect** (removes from the organization; previously imported Articles stay in their Spaces). ## Generate from code If your repo has no existing docs, the Jolli Agent can write Articles directly from the codebase. You can also trigger it later by asking the Agent to generate docs for a specific part of a connected Source. Generate is slower and more variable than Import - output quality scales with how well-commented the code is and how clear module boundaries are. If you have any existing docs, even rough Markdown READMEs, Import is faster and more reliable. ## Next steps - [Editing & Organizing](jrn:/global:docs:article/sync-untitled-mokfrxl9dj57) - the article editor and organizing a Space. - [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) - the AI assistant, Changesets, and Gap Analysis. - [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) - publish the Space at a URL. --- # Managing a Space Source: /jolli-spaces/managing-a-space # Managing a Space Every Space has its own settings, separate from your organization's [Settings](jrn:/global:docs:article/sync-untitled-mokfp9i8vkfx). Space Settings is where you control who can work in a single Space, how automation behaves for it, where its content is stored, and whether the Space exists at all. Space Settings opens with its own left-hand menu, with a link at the top to return to the Space. The tabs you see depend on the type of Space and your role in it. You need the **Admin** or **Owner** role in a Space to change most of these settings. Contributors and Viewers can open the pages but can't modify them. ## The tabs | Tab | What it covers | | --- | --- | | **General** | Name, description, visibility, and the danger zone (delete). | | **Members** | Who belongs to the Space and at what role, plus ownership transfer. | | **Automation** | Connected Sources and the auto-apply / auto-update toggles. | | **Storage** | Binds the Space to a git repository for git-backed publishing. | A **Workflows** tab also appears if [Workflows](jrn:/global:docs:article/sync-9f2b4c6d-1e3a-4b5c-8d7e-0a1b2c3d4e5f) is enabled for your organization. Not every Space exposes every tab: - **Personal Spaces** are private to you. They have no **Members** tab and no **Storage** tab, and their name, description, and visibility are read-only. - **Jolli Memory Spaces** (see [Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu)) have no **Storage** tab and no **Automation** tab (their content arrives through repository pushes rather than Source polling). In place of Storage they show a **Repos in this space** panel. ## Members The **Members** tab lists everyone who belongs to the Space, each with a role badge and the date they were added. Adding, removing, and role changes require the **Owner** or **Admin** role. ### Space roles Space roles are separate from the organization-level roles (Owner / Admin / Member) described in [Settings](jrn:/global:docs:article/sync-untitled-mokfp9i8vkfx). They apply only within a single Space. The two share the name **Admin**, but a Space Admin governs just that one Space, while an organization Admin manages the whole organization. | Role | What it can do | | --- | --- | | **Owner** | Full access within the Space. Exactly one per Space. Manages members and can transfer ownership. | | **Admin** | Manage content and members. Can assign the Contributor and Viewer roles. | | **Contributor** | Create and edit content. | | **Viewer** | Read-only access. | Organization Admins and Owners already have full access to every Space, so they can't be added as explicit Space members. ### Adding members Click **Add member**. What you see depends on your permissions: - If you can view the organization's user directory, you get a searchable list and can select several people at once. - Otherwise, you look people up one at a time by their exact email address. Pick a role for the people you're adding. An Admin can grant **Contributor** or **Viewer**; an Owner can also grant **Admin**. The **Owner** role is never assigned this way - it changes hands only through ownership transfer. ### Changing a member's role Each row has an inline role dropdown. You can change any member whose current role is one you're allowed to assign. You can't change your own role, and you can't change the Owner's role from here. ### Removing a member Use the **Remove** button on the member's row. The Owner can't be removed, and you can't remove yourself. ### Transfer ownership Only the current Space Owner can transfer ownership, and only when the Space has at least one other member. This is an invitation-based flow - ownership doesn't change until the other person accepts. 1. Click **Transfer ownership** at the bottom of the Members tab. 2. Pick an existing member to receive the invitation and confirm. They become the new Owner and you're demoted once they accept. 3. Jolli emails the invitee an acceptance link. A Space can have only one pending ownership invitation at a time; the button is disabled (with an explanation) while one is outstanding. The pending invitation shows who it was sent to and when it expires, with **Resend** and **Cancel** actions. Removing the invited member cancels the invitation automatically. ## General The **General** tab holds the Space's basic identity and access settings. - **Name** and **Description** - edit each inline with the pencil icon. - **Visibility** - **Private** or **Public**. - **Default Member Role** - shown only when visibility is **Public**. ### Private vs. Public - **Private** - only the people you've added on the Members tab can access the Space. - **Public** - every member of your organization gets access automatically, at the **Default Member Role** you choose. For a Public Space, the Default Member Role can be **Contributor** or **Viewer** (Contributor by default). It applies to organization members who reach the Space through its public visibility; anyone you've added explicitly keeps the role you assigned them. Click **Save access settings** after changing visibility or the default role. ## Automation The **Automation** tab has two parts: the **Sources** connected to the Space (add or remove them here - see [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju)), and the automation toggles that govern how proposed changes and Source updates are handled. - **Auto-apply changesets** - when on, routine AI-suggested Changesets apply without manual review. On a git-backed Space this becomes **auto-merge pull requests** (which requires the GitHub App to have merge access), since git-backed Spaces publish through pull requests rather than Changesets. Off by default for most Spaces. - **Auto-update from sources** - when on, connected Sources are watched for changes. On a git-backed Space this reads as creating pull requests when Sources update. When **Auto-update from sources** is on, choose how updates arrive: - **Listen for GitHub events** - near-real-time, driven by webhooks. - **Check on a schedule** - polls on an interval you set (in days), at a time of day, using the timezone from your profile. See [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) for how these toggles fit into drift detection, Changesets, and review. ## Storage The **Storage** tab binds a Space to a GitHub repository so its content lives in git. This is what enables git-backed publishing - the repository becomes the source of truth, and content changes flow through it. Storage appears only on shared (non-Personal, non-Jolli Memory) Spaces, and only when git-backed Spaces are enabled for your deployment. To bind a repository: 1. Click **Connect GitHub repo** and complete the GitHub App install/authorization if you haven't already. 2. Pick a **Source** - the repositories you can use are grouped by GitHub account. A repository already bound to another Space is shown as in use and can't be selected. 3. Set the **Root path** (the folder within the repo that holds your docs) and the **Include** / **Exclude** file globs. Include defaults to Markdown and JSON files (`**/*.md`, `**/*.mdx`, `**/*.json`). Jolli tracks the repository's default branch. 4. Save. The button reads **Enable** on a first bind and **Update** afterward. ### Switching repositories Choosing a different repository re-binds the Space and re-clones from scratch. If the Space already contains content, Jolli asks you to confirm before wiping it, showing exactly how many documents and folders will be removed. The clone runs in the background; while it's in progress the Space's content is temporarily unavailable. Storage also surfaces health banners when something needs your attention - for example, if the bound repository's access was revoked, if the local mirror needs to be reconnected, or if GitHub blocked the last publish because a file contained a secret. ## Deleting a Space Deleting a Space lives in the **Danger zone** at the bottom of the **General** tab. It's available only to Space Owners (and organization Admins/Owners). Deletion is **permanent and can't be undone**. You can't delete: - Your last remaining Space. - A Personal Space. - Your organization's default Jolli Memory Space. Deletion is a two-step, guarded flow: 1. **Choose what happens to the content.** - **Move to another space** - migrate this Space's Articles into a compatible Space you pick, then remove this one. (A git-backed Space can only move into another git-backed Space, and a regular Space into another regular Space.) If there's no compatible target, this option is unavailable. - **Delete all content** - remove the Space and everything in it. 2. **Confirm by typing the Space's name.** The confirm button stays disabled until the name matches exactly. Deleting a git-backed Space carries an extra warning, since its content is tied to a repository. ## Next steps - [Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) - what a Space is and what lives in it. - [Editing & Organizing](jrn:/global:docs:article/sync-untitled-mokfrxl9dj57) - the article editor and organizing a Space. - [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) - publish a Space at a URL. - [Settings](jrn:/global:docs:article/sync-untitled-mokfp9i8vkfx) - organization-level users and roles. --- # The Jolli Agent Source: /jolli-spaces/the-jolli-agent # The Jolli Agent The **Jolli Agent** is Jolli's AI assistant: you give it a documentation task and it drafts the work for you. This article covers the Agent itself, the **Changesets** its edits pass through for review, and **Gap Analysis** - the Agent working on its own to catch docs that have drifted from code. Automation ties them together. For the manual writing surface - the editor, floating toolbar, auto-save, version history - see [Editing & Organizing](jrn:/global:docs:article/sync-untitled-mokfrxl9dj57). ## Working with the Agent The AI Assistant lives in the **Jolli Agent** tab. You give it a task ("write an Article about our API's auth flow"; "update the deployment guide for the new Docker setup"); it drafts content as a Changeset; you review before anything reaches the Space. ### Modes | Mode | Behavior | When | | -------- | ----------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | | **Plan** | The AI proposes each tool call (read file, write Article, search Source) and waits for your approval. Slow, safe. | Significant tasks; unfamiliar territory; anything you want to step through. | | **Exec** | The AI runs tools as it needs them. You see what it's doing but don't approve each step. | Routine tasks where you trust the approach but still want to review the Changeset before applying. | | **Auto** | Like Exec, plus the AI applies the resulting Changeset itself. End-to-end without you. | Truly trusted tasks. Gated by **Allow Auto mode** in [Settings](jrn:/global:docs:article/sync-untitled-mokfp9i8vkfx). | Pick from the toolbar above the chat. **Exec** is the default outside of guided workflows that use **Auto**. ### Context The Jolli Agent tracks which Article, Folder, or Space the conversation is working on. A breadcrumb under the chat header shows it (`Engineering > API Docs > Authentication API`). Context is **dynamic** by default (follows your navigation) or **snapshot** (locked to a specific target, shown with a `(fixed)` label). If context changes mid-conversation, the AI sees a small note in its next turn. Click the breadcrumb to override. ### Multiple conversations Each task gets its own conversation. The left sidebar lists every conversation, grouped by date (Today / Yesterday / Last 7 days / earlier), with a **New Chat** button at the top. Click any past conversation to resume it; the AI sees the prior turns and continues where you left off. Delete a conversation from its three-dot menu - useful for clearing out one-off explorations. ## Changesets & review A Changeset is a group of proposed edits to a Space - like a pull request for documentation. The Jolli Agent's drafts and Gap Analysis's drift fixes both land as Changesets. You review, apply, or cancel before anything reaches the Space. Direct edits in the Article editor save immediately and don't create Changesets. It's the AI-proposed edits that go through this gate. ### Reviewing Open any Changeset from its sidebar entry or from the Inbox notification that announced it. The detail view shows affected Articles on the left, a diff in the middle (additions green, deletions red), and the state / author / history at the top. Click any Article to see its proposed content; you can edit inline and your edits stay in the Changeset. Two primary actions: - **Apply Change Set** - queues the Changeset to merge onto the latest published content, then publishes it into the **Space**. It moves through `Publishing` to `Published`, and the Space's content is now current. The live **Site** is a separate build - it won't reflect the change until its next publish (see [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0)). - **Cancel Change Set** - discards the whole Changeset (`Discarded`). The Space is untouched. You can reject individual Articles within a Changeset before applying - that Article is dropped, the rest proceed. If a Changeset was drafted against content that has since changed, you may also see **Merge** or **Merge & Apply** to reconcile it, and - if a publish hits conflicts - **Force Publish**. Changesets pass through a few intermediate states (`Proposed`, `Reviewing`, `Ready`) on the way to `Published`. ### Git-backed Spaces publish through GitHub Some Spaces are bound to a git repository instead of storing content in Jolli (set up in [Managing a Space](jrn:PENDING-managing-a-space) → Storage). Those Spaces don't use Changesets at all. Their publish flow pushes a work branch (named `jolli-doc-`) and opens a **GitHub Pull Request** against the backing's source branch instead. Jolli opens and tracks those PRs for you. - Review happens on GitHub, not in the Changeset detail view. Open PRs and merged/closed ones show up in the Gap Analysis **Pull Requests** panel, split into **Open** and **Closed** tabs, each with a direct **Open on GitHub** link. - If a PR picks up merge conflicts, the panel shows a "conflicts, awaiting auto-rebase" hint - Jolli auto-rebases the branch on its next sweep, so you usually don't intervene. - The two automation toggles below still work but take on PR semantics: auto-apply reads as "auto-merge pull requests," and auto-update reads as "create pull requests when Sources update." ## Gap Analysis (automated drift) Gap Analysis is the AI scan that compares your Sources (code repos, uploads) against your Articles and flags drift. When it finds drift, it drafts fixes as a Changeset. The difference from a Jolli Agent task you start yourself: **you** start an Agent task. **The system** starts a Gap Analysis run. Drift shows up in a few common ways: - **Missing docs** - a new module, endpoint, or feature has no matching Article. - **Outdated content** - an Article describes the old behavior of something that changed. - **Incomplete coverage** - a section mentions a feature briefly but the Source now has a lot more detail. ### Triggers Configure under **Space Settings → Automation**. Turn on **Auto-update from sources**, then pick how runs fire - one or both: - **Listen for GitHub events** - near-real-time; fires when a push or merge arrives at a connected Source via webhook (requires the GitHub App). - **Check on a schedule** - polls connected Sources on an interval (every N days, at a time you set). Useful when push-driven runs would be too noisy. ### Job Activity Each Gap Analysis run (labeled **Jolli Doc Review**) shows in the Job Activity panel with trigger, status, and timestamp: - **Running** - still working. - **Changes made** - found drift; Changeset produced. - **No changes** - docs in sync. - **Failed** - click for error details. There's no manual run button. To force an immediate run, push a small change to the tracked branch or adjust the schedule to fire now. ## Automation & auto-apply By default, every AI-proposed Changeset waits for a human review. The **auto-apply** toggle removes that wait: when it's on, routine AI-suggested updates apply and publish without a manual pass. - Find it under **Space Settings → Automation** as the **Auto-apply change sets** toggle. On a git-backed Space the same control reads as **Auto-merge pull requests** (and needs the GitHub App to have merge access). - Auto-apply only applies to Changesets from Gap Analysis. Changesets from the Jolli Agent chat always require manual review - for hands-off Agent tasks, use **Auto** mode instead. - It's a shared-Space setting; the toggle is disabled on your Personal Space. - It's **off** by default for most Spaces - reviewing every change is safer than silently publishing every AI suggestion. (The guided *import* flow is the exception: it applies imported Articles without a manual pass.) Turn it on once you trust the pipeline - Spaces where drift detection runs frequently and changes are predictable (small wording fixes, auto-generated reference updates) are the best candidates. For where this setting lives alongside the rest of a Space's configuration, see [Managing a Space](jrn:PENDING-managing-a-space). For *scheduled* automation that generates docs on a cadence or on GitHub activity - distinct from the Agent and Gap Analysis - see [Workflows](jrn:PENDING-workflows). ## Next steps - [Managing a Space](jrn:PENDING-managing-a-space) - Sources, automation settings, and where auto-apply lives. - [Workflows](jrn:PENDING-workflows) - scheduled, hands-off doc automation. - [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) - publish the reviewed content at a URL. --- # Workflows Source: /jolli-spaces/workflows # Workflows > **Availability:** Workflows is available only if it has been enabled for your organization. It's turned on by Jolli for your organization - you can't enable it yourself. If you don't see a **Workflows** entry in the sidebar, it isn't enabled for your organization. A Workflow keeps a Space up to date for you. It watches the Sources you choose, runs a Jolli prompt against them on a trigger you set, and writes the result into a target Space - creating and updating Articles instead of you doing it by hand. Use a Workflow when documentation needs to track something that keeps changing: a codebase, another Space, or a repository's activity. Each run reads the current state of your Sources and produces the Articles that describe them. ## How a Workflow is built Every Workflow is defined by four parts. On the Workflows screen, each Workflow card lays these out as a labeled timeline. - **When** - the trigger that starts a run (Manual, a schedule, or GitHub activity). - **Watching** - the Sources the Workflow reads (repositories and/or Spaces). - **Then run** - the prompt that tells Jolli what to do with those Sources. - **Target** - the Space (and optional Folder) the output lands in, and how it's published. ## Where you manage Workflows There are two places to work with Workflows, and both show the same Workflow cards. - **The Workflows screen** (sidebar → Workflows) lists every Workflow you can see across your organization. Select **New workflow** to create one. - **A Space's Workflows tab** (Space Settings → Workflows) lists only the Workflows that target that Space; creating one here pins the target Space. For a Company Space, its Owners and Admins can see and pause any Workflow that targets it; for your Personal Space, only you can. You can edit any Workflow you created, plus any Workflow that targets a Space you administer. ## Creating a Workflow Select **New workflow** and fill in the form. The **target Space** and the **Workflow type** are fixed once the Workflow is created; everything else can be changed later. ### Workflow type If your organization has published its own Workflow types, a **Workflow type** picker appears so you can choose one; otherwise new Workflows use the standard freeform prompt ("None (freeform prompt)"). ### Name A short, unique label so you can recognize the Workflow in the list. ### Trigger Choose when the Workflow runs. | Trigger | When it runs | |---|---| | **Manual only** | Never runs on its own - only when you choose **Run now**. The default for a new Workflow. | | **On a schedule** | Runs on a recurring schedule at a time you set. Presets cover daily, every weekday, weekly (pick the weekdays), and monthly (by date or by weekday), plus a custom every-N-days/weeks/months option; you can also set an end date or a maximum number of runs. The schedule uses the timezone from your profile, so set that correctly first. | | **On GitHub events** | Runs when Jolli receives selected GitHub activity on a connected repository - **Pushes** and/or **Merged pull requests**. You can optionally limit it to a single `owner/repo`. This trigger requires at least one repository Source. | ### Sources Pick what the Workflow reads - **Repositories** connected to the target Space, and/or **Spaces** (including your Personal Space and Company Spaces). Only repositories connected to your chosen target Space are offered, so choose the target Space first. If some Sources are hidden because you lack access, the form notes how many you can't see. ### Prompt and starting points The **System prompt** is the instruction Jolli follows on each run - for example, "document the attached repository into this Space." Write it from scratch, or click a **Starting point** to fill in a ready-made prompt and then edit it. Starting points stay available after you begin writing your own, and **Undo** restores what was there before your last click. If the prompt uses **Prompt variables** (for example, an intended audience or a maximum number of sections), the form shows a typed field for each. Fill them in to shape the output; you can also override them per run (see below). ### Target Space and Folder - **Target space** - where the resulting Changeset lands. You can only target a Space you can edit, and it can't be changed after creation. - **Target folder** (optional) - write output into a specific Folder instead of the Space root. The Folder *can* be changed later. ### Where the output lands | Setting | After a successful run | |---|---| | **Review first** | Leaves a Changeset in the target Space for you to review before publishing. The default. | | **Auto-commit** | Publishes the run's Changeset automatically, with no review step (the **Auto-commit changes** option). | | **Pull request** | For a git-backed target Space, the run always stages output to a pull request for review - Auto-commit doesn't apply. | For how Changesets are reviewed and published, see [The Jolli Agent](jrn:PENDING-the-jolli-agent). ### Notify on completion Choose whether a finished run notifies anyone. Turn on **Send a summary when a run finishes** and pick who receives it - any combination of **Space owner**, **Workflow owner**, and **All space members**. The default is the Workflow owner; with the switch off (or no recipients selected), a finished run notifies no one. Notifications land in each recipient's **Inbox** as a **Workflow complete** notification, showing how many documents the run affected and whether the result was applied automatically, opened as a pull request, or is awaiting review - with links to the run and the Article(s) it produced. (Inbox delivery today; Linear and Slack are marked coming soon.) ## Running a Workflow - **Run now** - every Workflow, including a Manual-only one, can be run on demand. **Run now** is the workflow card's primary button; the other actions - Cancel, Duplicate, Move, and Delete - live in the card's overflow (⋯) menu. If the prompt uses variables, a dialog lets you review or override them for that run only (those values aren't saved back). A Workflow runs one at a time; if a run is already queued or in progress, Jolli tells you rather than starting a second. - **Cancel** - while a run is queued or in progress the card shows "Run in progress…" and the menu offers **Cancel running workflow**. Nothing is published. - **Pause / Resume** - each card has a toggle. A paused Workflow won't fire on its schedule or on GitHub events, and **Run now** is unavailable until you resume it. Pausing deletes nothing. - **When a Source disconnects** - if a repository Source is no longer connected to the target Space, Jolli pauses the Workflow and the card shows a **Reconnect source** link. Reconnect before re-enabling. - **Delete** - **Delete workflow** permanently removes the Workflow and any schedule attached to it. Past run history is preserved. ### Duplicating or moving a Workflow From a Workflow card's overflow menu you can copy or relocate a Workflow: - **Duplicate** - creates a copy (in the same Space, or a different one you can edit). The copy starts **disabled** and keeps no run history; leave the name blank to name it after the original with "(copy)" appended, or turn on **Enable immediately** to have it start running right away. - **Move to space…** - moves the Workflow to another Space you can edit. The original is removed and its run history does not carry over. Moving needs the same authority as deleting. When you duplicate or move into a different Space, each repository Source is re-checked against the target Space; if a Source isn't connected there, Jolli tells you rather than creating a broken copy. ## Run history Each card's **History** button opens the run history. Per run you can see: - Status - **Queued**, **Running**, **Success**, **Failed**, or **Cancelled**. - How it was triggered - **Manual**, **Schedule**, or **Event**. - Duration and a short summary of what it produced. - How many documents it affected, broken out as **Created**, **Edited**, and **Deleted** (for example, "Affected 3 · Created 1 · Edited 2"), each Article linked when still active. - The publish outcome - **Applied automatically**, **Opened a pull request for review**, **Pending review**, or a **Publish conflict** / **Publish failed** state. - For a git-backed target, the pull request it opened (shown as "PR #N opened"). When a run fails, the history shows a plain-language reason - for example, that a Source could not be read, that the Sources were too large for the model's context window, or that writing to the destination failed. ## Organization defaults Organization admins can set defaults for every Workflow run under **Settings → Workflow Defaults**. These are advanced controls - the built-in defaults are sensible, and any individual Workflow can override them from its own **Advanced execution settings**. A blank field means "use the built-in default." - **Models** - which model each agent role (writer, analyzer, reducer) runs on, plus fallback models by tier. - **Agent counts & limits** - the number of writers and researchers per run, max output tokens, and the per-run timeout (values above the platform limit are capped). - **Destination article index** - whether writer agents are handed the existing target-Space Articles relevant to their task, so they update or avoid duplicating them instead of re-researching. Viewing this page needs Workflows view access; saving needs edit access. ## How Workflows relate to Changesets Unless you turn on Auto-commit, each successful run writes its output as a **Changeset** in the target Space - the same reviewable unit you get editing by hand - which you review and publish exactly as usual. For a git-backed Space, the run stages a pull request instead, and that PR is the review gate. In other words, a Workflow is an automated author feeding the review flow you already use: it proposes Article changes across your Sources, and you stay in control of what actually publishes. See [The Jolli Agent](jrn:PENDING-the-jolli-agent) for that review-and-publish flow. ## Next steps - [The Jolli Agent](jrn:PENDING-the-jolli-agent) - the Jolli Agent, Changesets, and Gap Analysis. - [Managing a Space](jrn:PENDING-managing-a-space) - the per-Space settings a Workflow targets. - [Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) - publish the resulting content at a URL. --- # Settings Source: /settings # Settings Organization and account settings live under the **Settings** menu. This page covers the areas that matter day-to-day: your profile and preferences, the people in the organization, the roles that govern what they can do, and - for developers - API keys and the read-only MCP surface. ## Profile Personal account settings at **Settings → Profile**. - **Name** - edit freely. Shown in the Users list. - **Email** - read-only. Contact support to change it; the change affects sign-in and outstanding invites. - **Password** - set or change it (if you sign in with a password rather than OAuth). - **Timezone** - used where the app schedules things for you, such as auto-publish times. ### Sessions A list of browsers and devices currently signed into your account. Each row shows device, approximate location, and last-active time. - **Logout this device** - ends a specific session. - **Logout other devices** - ends every session except the one you're using. - **Logout from all devices** - ends every session, including the one you're using. A confirmation dialog appears first. Sessions also expire when your Remember Me token does (30 days), or when you reset your password - the reset ends your other sessions as a security precaution. ### Getting Started guide Owners can **Reset Getting Started Guide** here. It brings back the Getting Started conversation so you can walk through setup again; open the Jolli Agent afterward to see it. ## Preferences App preferences at **Settings → Preferences**, grouped into five sections. ### Appearance - **Theme** - Light or Dark for the whole web app. Sites you publish have their own theme controls, independent of this. - **Language** - your preferred language for the interface. ### Interface - **Sidebar default state** - whether the sidebar starts **Expanded** or **Collapsed**. - **Chat panel width** - the default width of the chat panel, from 300 to 800 pixels. ### Articles - **Default draft filter** - which drafts show by default: **All**, **My New Drafts**, or **Shared With Me**. - **Show AI tool details** - show detailed information about AI tool usage in article drafts. ### Agent How the Jolli Agent starts a conversation, each overridable per-conversation: - **Default conversation mode** - Plan, Exec, or Auto. See [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f). - **Allow auto mode** - makes Auto selectable in the Jolli Agent; Auto auto-approves non-destructive agent actions. - **Show extended thinking** - show the AI's thinking blocks in Agent conversations. ### Advanced - **Source view** - view raw source data for debugging. ## Workspace (Owner, Admin roles) **Settings → Workspace** is where you rename your workspace - the name shown to everyone in the organization. Only Owners and Admins see this page. - **Workspace name** - edit it and click **Save** (the button reads **Rename** until you change the value). Up to 255 characters. This sets the organization's display name; the unique slug it was created with doesn't change. ## Users (Owner, Admin roles) The Users page is at **Settings → Users**. ### Inviting your team The Users page leads with an **Invite your team** card offering two paths - **Invite a colleague** (a single person) and **Import a CSV** (bulk). Both open the same **Invite your team** dialog, which has an **Invite someone** tab and an **Import CSV** tab. (For the organization Owner, a dismissible **Invite your team** banner also appears atop the default shared space.) On the **Invite someone** tab, enter an email, pick a role (default Member), and send. The invitee gets an email from Jolli; if they already have a Jolli account the link adds them to this organization, otherwise it takes them through signup first. Invites are per-email - if someone changes their address, they need a fresh invite. The **Import CSV** tab onboards a whole team at once. Each valid row becomes a standard invitation, identical to inviting one person at a time. The file needs an `email` column, plus optional `name` and `role` columns: ``` email,name,role jane@acme.com,Jane Doe,admin sam@acme.com,Sam Lee, ``` - Up to **100 rows** per file. Larger files are rejected - split them or send more than one. - Rows with a blank `role` use the **default role** you pick in the dialog (Member unless you change it). - A preview flags each row before you send: **Ready**, invalid email, unknown role, or duplicate. Only Ready rows are invited. - After sending, each row reports its outcome - invited, already a member, rate-limited, or failed. ### Managing Each row in the Users list has a three-dot menu: - **Edit** - opens a dialog where you can rename the user and change their role to any built-in or custom role. - **Deactivate** / **Activate** - Deactivate revokes their tokens immediately; their data and assignments stay intact. Activate restores access. - **Delete** - permanent. Non-personal **Spaces** owned by the user transfer to **you** (the admin performing the deletion); personal Spaces are soft-deleted. Articles and Changesets keep their original author reference (which now points to an archived user); they are not reassigned. ## Roles Every user has a role. Roles determine what they can see and do - which Articles they can edit, whether they can manage Sources, whether they can invite teammates, and so on. Jolli ships with three built-in roles. Paid organizations can also create custom roles. ### Built-in roles - **Owner** - full access. Exactly one per organization. Can promote, demote, transfer ownership, or delete the organization. - **Admin** - broad day-to-day management. Can manage users, Sources, Sites, and content. Can't transfer ownership, delete the organization, or edit roles (Owner-only by default). - **Member** - the everyday contributor. Can view and edit Articles in the Spaces they have access to. They cannot manage users, roles, integrations, or sites by default. Use a custom role if you need a more restricted contributor. ### The permission matrix Permissions break into categories, each with a **View** and an **Edit** level. | Category | View | Edit | | ---------------- | ------------------------------------------- | ---------------------------------------------------------- | | **Articles** | Read Articles | Create, edit, delete; comment moderation | | **Spaces** | See Spaces and structure | Create, rename, delete Spaces | | **Integrations** | See connected Sources | Connect, configure, disconnect | | **Sites** | See published Sites | Create, customize, publish | | **Users** | See organization users | Invite, deactivate, delete | | **Roles** | See roles | Create, edit, delete custom roles | | **Jolli Memory** | See API keys and Jolli Memory configuration | Create / disable / delete API keys, configure push targets | An additional **Workflows** category (view / run workflows) appears if Workflows is enabled for your organization. Some permissions have cross-category dependencies - for example, Roles (Edit) requires Users (Edit) - and enabling any Edit level automatically includes its View. ### Custom roles To create one: 1. **Settings → Roles → Clone** next to whichever built-in role is closest. 2. Rename, toggle permissions, save. 3. Assign from the Users page or the invite dialog. Editing a custom role takes effect immediately for assigned users (they may need to sign out and back in to pick up new permissions). Built-in roles can't be edited or deleted. ### Ownership transfer Always exactly one Owner on an account. To change an owner on an account, contact [support@jolli.ai](mailto:support@jolli.ai). ## Developer ### API keys API keys let the Jolli CLI and external tools act on your behalf. Manage them under **Settings → Jolli Memory** - create a key, disable it, or delete it. Keys are scoped to what their creator can access. ### Connect an external AI client (MCP) Jolli exposes a read-only **MCP** (Model Context Protocol) surface so an external AI client can read your documentation using one of your organization's API keys. It's on by default; an organization admin can turn it off, which makes the whole surface unavailable. The tools an authorized client can call: | Tool | What it does | | ---- | ------------ | | `list_remote_spaces` | List the Spaces the key's owner can access. | | `search_remote_articles` | Search Article titles across accessible Spaces. | | `get_remote_article_content` | Fetch one published Article's content by its JRN. | - Access is scoped to what the key's creator can view. Personal and Jolli Memory Spaces, and deleted Articles, are never returned; only published content is served. - Create an API key under **Settings → Jolli Memory**. While MCP is enabled, every API key can reach this surface automatically - there's no separate scope to toggle. - Point your client at your organization's Jolli API base (the `/api/mcp` endpoints) and authenticate with the API key. This is distinct from the Jolli Memory MCP server your local coding assistant runs - this surface is hosted by Jolli and reads your Spaces directly. ## Next steps - [Managing a Space](jrn:/global:docs:article/sync-3d5b8f14-2c7e-4a09-b6d1-0f1e2d3c4b5a) - per-Space members and roles, distinct from the organization roles above. - [The Jolli Agent](jrn:/global:docs:article/sync-7e9c1a20-0b3a-4c51-9f2e-1a2b3c4d5e6f) - what the AI mode defaults control. - [Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) - the API keys and MCP settings above power Jolli Memory. --- # Welcome to Jolli Source: /welcome-to-jolli ![jolli-blackbg.png](/api/images/2df6fcc7-2c1d-46be-9bda-ab60b82404e8/df9fe51a-4b98-4f16-a728-7461b7a76f78/jolli-support-docs-1776993369310/219fb895-6a71-46bd-a356-f8b2fb79ce9a.png) Jolli keeps your documentation, reasoning, and shared understanding up to date based on your sources. We do this through three layers that work together: - **Jolli Memory** captures the "why" behind every AI-assisted commit - **Jolli Spaces** is where your team creates, reviews, and maintains docs that stay in sync with code - **Jolli Sites** publishes everything to beautiful, branded documentation sites ## For developers: Never lose context again Tired of your AI coding sessions disappearing into the void? **Jolli Memory** automatically attaches structured summaries to every git commit and your Jolli Memory Bank, so the reasoning behind changes lives on - not just the code. It's available as a CLI, plus editor extensions for VS Code, Cursor, Windsurf, and IntelliJ. Everything runs locally on your machine. → [Get started with Jolli Memory](jrn:/global:docs:article/sync-untitled-mokfokee5oiu) ## For teams: Write your docs once, keep them current **Jolli Spaces** lets you import existing Markdown, use AI to keep docs synced with your codebase, and publish when ready. No more rewriting the same documentation across three different tools. → [Set up Jolli Spaces](jrn:/global:docs:article/sync-untitled-mokfrnbqwhju) ## For publishing: Ship beautiful docs to your domain **Jolli Sites** builds and deploys documentation sites at your own domain (like `docs.yourdomain.com`). Choose from preset themes or customize, set granular access controls, and let Jolli handle the rest. → [Learn about Jolli Sites](jrn:/global:docs:article/sync-untitled-mokfpeha0dm0) --- # What's New in Jolli Source: /whats-new-in-jolli # What's New ## July 24, 2026 Highlights: four new AI assistants captured, `/llms.txt` on every published Site, and workflow run-completion notifications. ### Jolli Memory - **More assistants captured**: Memory now captures **twelve sources across nine assistants**, adding **Cursor CLI** (`cursor-agent`), **Cline** (the VS Code extension and the CLI), **Devin**, and **Antigravity**. All are discovered automatically, no setup. - **Ships as a Claude Code plugin**: add Jolli from the Claude Code plugin marketplace; it bundles the git hooks, the MCP server, and the `/jolli` skills. - **Simpler setup**: if a local Claude Code CLI is detected, `jolli enable` uses it automatically (its subscription, no key, no menu). - **Smarter references**: **Context7** library lookups are now tracked as lightweight bookmarks, and **Codex now captures Slack threads** referenced in a conversation (previously Claude Code only). - **Memory in the web app**: an interactive **knowledge-graph viewer** for your Memory spaces, and a **Copy Recall Prompt** button on Memory summaries. ### Workflows - **Notify on completion**: post a run summary to your **Inbox** when a run finishes, to the Space owner, the Workflow owner, and/or all Space members. - **Duplicate or move a workflow**: copy a workflow, or move it to another Space, right from the workflow card. - **Run now** is now a one-click primary button on every workflow card. - **Richer run history**: each run shows how many documents it created, edited, and deleted, and whether the result was applied automatically or opened as a pull request. ### Jolli Sites - **Built for AI**: every published Site now generates **`/llms.txt`** and **`/llms-full.txt`** at its root and advertises them in each page's ``, so AI clients like Claude, Cursor, and ChatGPT can ingest your docs in one shot. ### Onboarding & Settings - **A friendlier first run**: name-free signup, plus a ready-to-use **Shared Space** (seeded with a Welcome doc) created for you automatically. - **Rename your workspace** anytime from the new **Settings → Workspace** page. - **Invite your team** from a single dialog: one person or a CSV. ## July 17, 2026 Highlights: generate memories with your own local AI, a guided first run of the `jolli` command, three more reference sources, and workflow run history you can click through. ### Jolli Memory - **Write memories with your own AI**: a new **local-agent** provider drives a locally-installed Claude Code to generate your memories using its own login, with no API key and no Jolli proxy call. Turn it on in the extension settings or with `jolli configure --set aiProvider=local-agent`. - **A guided front door**: running `jolli` with no arguments now walks you through signing in, fixing a missing AI provider key, and turning recent commits into memories, all from one prompt. - **Run a workflow from your agent**: the new `/jolli-local-run` skill runs a Jolli workflow on your own machine, with no Jolli AI credits, and lands the result in a git-backed Space through a branch and pull request. Remote runs work too. - **More reference sources**: conversations that mention **monday.com**, **Asana**, or **Confluence** now capture those items as references. - **Your knowledge graph follows you**: graphs now sync across the machines you sign in to, and can be embedded on the web. - **One menu for everything**: type **`/jolli`** in Claude Code for a single menu that lists the Jolli skills (recall, search, PR, run a workflow) and the Jolli tools available in your session, then runs the one you pick. - **More ways to install**: new PowerShell and Windows Command Prompt install scripts, plus one-click install buttons for VS Code, Cursor, and JetBrains. - **Clean uninstall**: `jolli uninstall` finds and removes every Jolli install and config on your machine, and never touches your memories. ### Workflows - **Run history you can click through**: open **History** on any workflow to see past runs, jump straight to the article a run wrote or the pull request it opened, and link directly to a specific run. - **Run now with custom values**: when a workflow's prompt uses variables, **Run now** opens a form to set values for that run only, without changing the workflow's saved defaults. ### Jolli Spaces - **Wiki-style links**: relative links between articles now open the linked article in place, and heading links jump to the right spot on the page. - **Cleaner article links**: article web addresses are now readable and built from the article title instead of an internal id, so a shared link makes sense at a glance. ## July 10, 2026 Highlights: memory that syncs on every push, Slack and Zoom captured as sources, the IntelliJ extension catching up to VS Code, and the Jolli Agent on the newest Claude models. ### Jolli Memory - **Sync on every push**: once you are signed in, `git push` automatically syncs the pushed commits' memory to your Jolli Space in the background, and retries anything that did not make it on the next push. Turn it off with `syncOnPush: false`. - **More reference sources**: **Slack** threads and **Zoom** meetings mentioned in a conversation are now captured as references. - **The IntelliJ extension catches up to VS Code**: the JetBrains plugin gains token usage and estimated cost on each memory, Markdown export, read-only share links, and a card that builds memories from your existing commit history. - **More assistants captured**: **GitHub Copilot** and **Copilot Chat** conversations are now captured, and **Codex** sessions resume correctly and stay scoped to the current repo. - **Usage and cost on shared memories**: pushed memory articles now show a **Task usage** line with total tokens and an estimated cost, now priced by the model that generated each memory rather than a flat rate. - **Global AI instructions are now opt-in**: Jolli asks before adding its skill-preference block to your global instruction files, and will not add it without your go-ahead. ### Jolli Spaces - **Guided Space setup**: creating a Space now lets the Jolli Agent generate documentation from your connected sources or import your existing docs as-is, with a live progress view that keeps running if you step away. - **The newest Claude models**: the Jolli Agent now runs on Claude Opus 4.8 and Sonnet 5 with extended thinking, for stronger document generation and analysis. - **Fewer naming collisions**: creating a folder or document with a name that already exists now adds a number instead of failing. ### Onboarding & Settings - **Clearer access errors**: opening a shared link that belongs to an account you are not a member of now names that account and offers to sign in with a different one.