mcp server

ChatBraid

Braid your AI threads into one: a cross-thread /compact for Claude Code, Codex, ChatGPT and claude.ai

oaishi/ChatBraidcommunitylistedunreviewed

Use tool

Set up

Runs on your computer. Pick your agent and operating system.

This project does not publish an install method we can turn into a config. Follow the README instead.

README

synced Oct 22, 2026

You've got one Claude Code tab fixing the API, a Codex session that built the frontend, and a ChatGPT chat where you settled the database schema. None of them knows what the others did. ChatBraid lets you pick any of those threads, from any of those tools, and fold them into one dense, faithful context. You can then:

continue in the thread you're in,
start a fresh session from it, or
save it and load it somewhere else.

/braid                          ← pick from a list of your recent threads
/braid last-codex               ← pull your latest Codex session into this Claude Code thread
/braid 4afd43c2 019e1d45 focus: auth token refresh
"braid my chats about the results section"      ← on claude.ai / ChatGPT, via the web skill

The merged context always has the same six sections:

Unified goal
Per-thread state
Decisions & facts (tagged with their source thread)
Conflicts between threads
Code & artifacts (exact paths, commands, errors)
Next steps

Which pieces do I need?
Install
Use cases: step-by-step recipes
Picking threads: ids, refs and the pickers
Reference: commands, MCP tools, file mode
Configuration
How it works
Privacy
Troubleshooting
Limitations
Development

1. Which pieces do I need?

ChatBraid comes in three forms. They share one engine and produce identical merges.

Piece	What it is	Runs in
Plugin / MCP server (`chatbraid`)	Python, no dependencies. Reads your local Claude Code and Codex history and any imported web chats.	Claude Code, Codex, Claude Desktop, any MCP app, your terminal
Web skill (`dist/chatbraid-web-skill.zip`)	A `SKILL.md` plus the same engine, run inside the chat's code sandbox	claude.ai, ChatGPT
Browser extension (`extension/`)	Reads your ChatGPT / claude.ai history from your logged-in tabs	Chrome, Edge, Brave, Arc

Install by where you work:

You work in…	Install	You get
Claude Code (terminal)	2.1 + 2.2	`/braid`, `/threads`, auto-skill, thread id in each tab
Claude Code in VS Code / JetBrains / desktop	2.1 + 2.2	same, because the plugin is shared through `~/.claude`
Codex CLI	2.1 + 2.3	MCP tools, `$merge-threads` skill, `/prompts:braid`
Codex in the Codex / ChatGPT desktop app or the IDE extension	2.1 + 2.3	same, because they share `~/.codex/config.toml`
claude.ai (web, desktop, mobile)	2.4 and/or 2.6	skill: merge past chats or uploaded files · extension: one-click merges, full transcripts
chatgpt.com	2.5 and/or 2.6	skill: merge uploaded exports/bundles · extension: one-click merges
Claude Desktop (chat), Cursor, other MCP apps	2.1 + 2.7	MCP tools over your local threads
Just a terminal	2.1	`chatbraid pick`, `merge`, `--copy`, `--launch`

Which threads each surface can reach:

Surface ↓ / threads →	Claude Code	Codex	ChatGPT	claude.ai
Claude Code, Codex, Claude Desktop, terminal	✅ direct	✅ direct	✅ after export¹	✅ after export¹
claude.ai + web skill	✅ upload bundle²	✅ upload bundle²	✅ upload export	✅ past-chat search or upload export
ChatGPT + web skill	✅ upload bundle²	✅ upload bundle²	✅ upload export	✅ upload export
Browser extension	via paste³	via paste³	✅ direct	✅ direct

¹ The extension's Send to terminal button, or chatbraid import <data-export.zip>. ² chatbraid export <refs> -o threads.chatbraid.json, then upload that file. ³ chatbraid merge … --copy, then paste into the chat.

2. Install

2.1 Core CLI: required for every terminal / app integration

Requirements: Python 3.9+ (no packages needed) and macOS, Linux or WSL.

git clone https://github.com/oaishi/ChatBraid && cd ChatBraid
./install.sh            # Codex + Claude Code + ~/.local/bin/chatbraid   (or: ./install.sh codex | ./install.sh claude)

Check that it sees your history:

chatbraid list -n 10        # if "command not found": add ~/.local/bin to PATH, or use  python3 bin/chatbraid

You should see a numbered list of your recent Claude Code ([claude]) and Codex ([codex]) threads.

Optional: install fzf (brew install fzf) for a multi-select picker with live previews.

2.2 Claude Code (CLI, VS Code / JetBrains, desktop)

Install the plugin from GitHub inside any Claude Code session:

/plugin marketplace add oaishi/ChatBraid
/plugin install chatbraid@chatbraid

Then restart Claude Code. That gives you:

MCP server chatbraid, with the tools list_threads, merge_threads, save_merge, load_merge, read_thread, tag_thread.
/braid [refs] [focus: …]: merge threads into this one. With no arguments it lists threads and asks you to pick.
/threads [source] [words]: just list threads.
merge-threads skill: Claude uses it on its own when you say things like "pull in my Codex session".
SessionStart hook: tells each session its own thread id, so it never merges itself and can tell you the id. It also labels the terminal tab 🧵 <id> where the terminal allows.

Plugins live in ~/.claude, so the same install works in the VS Code / JetBrains extensions and the desktop app.

Optional: show each tab's thread id in the status line. Add this to ~/.claude/settings.json:

"statusLine": { "type": "command", "command": "python3 /path/to/ChatBraid/bin/chatbraid statusline" }

Verify: in a new session, ask "what's this thread's chatbraid id?". It should answer from the session-start note. Then try /threads.

2.3 Codex (CLI, Codex / ChatGPT desktop app, IDE extension)

./install.sh codex          # or: chatbraid install --codex

This:

appends this to ~/.codex/config.toml, without touching your other servers:

[mcp_servers.chatbraid]
command = "/absolute/path/to/python3"
args = ["/path/to/ChatBraid/bin/chatbraid", "mcp"]

copies the skill to ~/.codex/skills/merge-threads/SKILL.md;
copies the prompt to ~/.codex/prompts/braid.md.

Then fully restart Codex. For the desktop app, quit with ⌘Q; closing the window isn't enough. The CLI, desktop app and IDE extension all read the same ~/.codex.

Verify:

codex mcp list              # should list chatbraid

In a Codex thread, type $merge-threads or just ask: "use chatbraid to list my recent threads". Newer Codex versions favor skills over custom prompts, so /prompts:braid may not appear. Natural language and $merge-threads always work.

Codex cloud tasks (chatgpt.com/codex) run in a remote container and can't see your local history. For those, use the web skill or --copy.

2.4 claude.ai web UI: skill

The same skill works in the claude.ai website, desktop app and mobile app.

Get the zip: download dist/chatbraid-web-skill.zip from this repo, or build it with scripts/build-web-skill.sh.
In claude.ai, open Settings → Capabilities and turn on:
- Code execution and file creation, which skills need, and
- Search and reference chats, which lets the skill find your past chats. This is a paid-plan feature.
Settings → Capabilities → Skills → Upload skill → choose chatbraid-web-skill.zip. Menu names may differ slightly between versions.
Verify: in a new chat, say "braid my recent chats". Claude should list recent chats and ask which to merge.

2.5 ChatGPT web UI: skill

The same zip works in ChatGPT, which supports the same SKILL.md format.

Get dist/chatbraid-web-skill.zip (as in 2.4).
In ChatGPT, open the Skills page (under Plugins / Skills) → Create → Upload from your computer → choose the zip. Skills availability depends on your plan and workspace settings, so check OpenAI's help center if you don't see it.
Verify: upload a ChatGPT data export (see UC5) and say "braid these". ChatGPT should run the engine and list the conversations inside.

ChatGPT has no tool for fetching a specific past chat on demand. Its built-in memory works implicitly. So in ChatGPT the skill works on uploaded files: data exports, .chatbraid.json bundles, or Claude Code / Codex transcripts. For one-click merges of your live ChatGPT history, use the extension (2.6).

2.6 Browser extension (ChatGPT + claude.ai)

Open chrome://extensions (Edge: edge://extensions).
Turn on Developer mode.
Click Load unpacked → select the extension/ folder of this repo.
Pin 🧵 ChatBraid from the puzzle-piece menu.
Open and sign in to chatgpt.com and/or claude.ai. Reload any tabs that were already open.
Verify: click the icon. You should see ChatGPT: N conversations / Claude: N conversations and a checklist.

The popup gives you four buttons:

Merge → new chat: opens a new chat with the merge prompt in the message box, ready for you to review and send.
Merge → this chat: inserts the merge prompt into the chat in the current tab.
Copy: puts the merge prompt on your clipboard.
Send to terminal: saves the selected chats to ~/Downloads/chatbraid/, where Claude Code, Codex and the CLI see them automatically.

2.7 Claude Desktop chat app & other MCP hosts

Any app that runs local stdio MCP servers can use ChatBraid. For example, Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "chatbraid": { "command": "python3", "args": ["/path/to/ChatBraid/bin/chatbraid", "mcp"] }
  }
}

Restart the app, then ask "use chatbraid to merge my last Claude Code and Codex threads". Cursor, Windsurf and others take the same command + args.

3. Use cases: step-by-step recipes

Each recipe lists the options for that case. ★ marks the recommended one.

Terminal & apps

UC1: Codex threads only

"I have two Codex sessions and want one to know what the other did."

★ Inside Codex (CLI, desktop app or IDE):
1. Open the Codex thread you want to continue.
2. Type $merge-threads, or ask "use chatbraid to list my Codex threads".
3. Reply with numbers (e.g. 2), or name a ref like last-codex or an id prefix.
4. Codex writes the merged context and saves it with save_merge, then you carry on.

From a terminal, into a fresh Codex session:

chatbraid pick -s codex --launch codex       # pick several → new Codex session seeded with the merge
chatbraid merge 019e1d45 019e22a7 --launch codex

Find a Codex thread's id: run /status in Codex, or chatbraid list -s codex.

UC2: Claude Code threads only

"Two Claude Code tabs worked on related things."

★ Inside Claude Code:
1. In the tab you want to continue, run /braid.
2. Tick threads in the multi-select, or run /braid <id> [<id> …] directly.
3. Claude writes the merged context and continues.
Find another tab's id: with the hook, every session knows its id (ask "what's this thread's id?"). With the status line, it's displayed in each tab as 🧵 4afd43c2. /threads shows which terminal each live session runs in.
Fresh session: chatbraid pick -s claude --launch claude.
Tip: name a thread once (chatbraid tag 4afd43c2 api-auth) and use /braid api-auth from then on.

UC3: Claude Code + Codex, mixed

"Claude Code did the backend, Codex did the frontend."

★ In Claude Code: /braid last-codex, or /braid 019e1d45 focus: the API contract.
★ In Codex: "use chatbraid to merge last-claude into this thread".
Terminal: chatbraid pick --here lists both tools' threads for the current directory; pick, then --launch claude or --launch codex.
Hand the result over: after a merge in tool A, tool B can run load_merge ("load the latest chatbraid merge"). Or run chatbraid last in a terminal to print it.

UC4: Start a brand-new session from several threads

chatbraid pick --launch claude                     # or --launch codex
chatbraid merge last-claude last-codex -f "release checklist" --launch claude

The new session's first message is the merge prompt. The agent replies with the merged context and waits for your next instruction.

Web UIs

UC5: ChatGPT threads only

"Several ChatGPT chats about one project."

★ Extension, one click:
1. On chatgpt.com, open the ChatBraid popup.
2. Tick the chats and add a focus if you like.
3. Click Merge → new chat (or → this chat).
4. Review the inserted prompt and press Enter.
Web skill, no extension:
1. Export your data: ChatGPT → Settings → Data controls → Export data. You'll get an email with a zip.
2. In a ChatGPT chat with the skill installed, upload the zip (or the conversations.json inside it).
3. Say "braid my chats about ". The skill runs braid.py files …, lists matching conversations, and you reply with numbers.
4. It writes the merged context.
Manual: copy the chats' text into one message and say "braid these". The skill treats pasted text as threads.

UC6: claude.ai threads only

★ Web skill with past-chat search (no files needed):
1. Enable Search and reference chats (2.4).
2. In a new chat say "braid my recent chats about ", or paste claude.ai/chat/… links.
3. Pick numbers from the list, and Claude writes the merged context.
This uses retrieval, so very long chats come through as excerpts. Claude flags anything thin.
Extension, full transcripts: on claude.ai, open the popup → tick chats → Merge → new chat.
Web skill + export, full transcripts, no extension:
1. claude.ai → Settings → Privacy → Export data.
2. Upload the zip to a chat and say "braid these".

UC7: ChatGPT + claude.ai, mixed

★ Extension:
1. Keep one chatgpt.com tab and one claude.ai tab open, both signed in.
2. The popup lists conversations from both sites in one checklist. Tick across them.
3. Merge → new chat on whichever site you're in.
Web skill: upload the ChatGPT export to a claude.ai chat, or the claude.ai export to a ChatGPT chat, and say "braid these".
On claude.ai, combine both sources: pull in claude.ai chats with past-chat search plus an uploaded ChatGPT export, in one request: "braid my claude chats about X with the ChatGPT chats in this export".

Across terminal ↔ web

UC8: Web chats → Claude Code / Codex

"I designed it in ChatGPT/claude.ai; now I want the coding agent to know."

★ Extension:
1. Tick the chats in the popup → Send to terminal. They're saved to ~/Downloads/chatbraid/.
2. In Claude Code run /braid last-web (or pick them from /braid, where they show up as [gpt] / [claude.ai]). In Codex, ask it to merge last-web.

Data export instead:

chatbraid import ~/Downloads/chatgpt-export.zip ~/Downloads/claude-export.zip
chatbraid list -s web -q "schema"         # find them

Then use /braid <id>, or a chat URL: /braid https://chatgpt.com/c/6720….

UC9: Claude Code / Codex threads → ChatGPT / claude.ai

"I want to discuss what my coding agents did in a regular chat."

★ Clipboard:

chatbraid pick --copy                              # or: chatbraid merge last-claude last-codex --copy

Paste into a new ChatGPT or claude.ai chat and send.

Upload a bundle to the web skill. Better when you want to pick inside the chat, or mix with web chats:
```
chatbraid export last-claude last-codex 019e1d45 -o threads.chatbraid.json
```
Upload threads.chatbraid.json and say "braid these".
Raw transcripts work too. You can upload ~/.claude/projects/<project>/<id>.jsonl or ~/.codex/sessions/…/rollout-….jsonl straight to the web skill.

UC10: Everything mixed: Claude Code + Codex + ChatGPT + claude.ai

★ From Claude Code or Codex:
1. Bring the web chats local (UC8: Send to terminal or chatbraid import).
2. Run /braid and tick threads from all four sources. They're listed together, newest first.
From claude.ai or ChatGPT:
1. Run chatbraid export <local refs> -o local.chatbraid.json.
2. Upload it plus the web exports to a chat with the skill, and say "braid these". On claude.ai you can add past chats via search in the same request.
Terminal only: chatbraid import <exports>, then chatbraid pick --launch claude.

UC11: Reuse one merge in several places

Every merge is saved to ~/.chatbraid/merges/ (latest.md is always the newest):

Claude Code / Codex / MCP apps: "load the latest chatbraid merge" (load_merge), or /prompts:braid last in Codex.
Terminal: chatbraid last, chatbraid merges, chatbraid last | pbcopy.
Web: the skill offers merged-context.md as a download after each merge. Paste or upload it anywhere.

4. Picking threads: ids, refs and the pickers

A ref can be any of these, anywhere ChatBraid asks for threads:

Ref	Example
Full id	`4afd43c2-b638-4108-9be9-25c1d8fcc1a2`
Id prefix (≥ 4 chars)	`4afd43c2`
Tag	`api-auth` (after `chatbraid tag 4afd api-auth`)
Chat URL	`https://chatgpt.com/c/6720…`, `https://claude.ai/chat/0b1e…`
Source-qualified	`codex:019e1d45`, `claude-code:4afd`, `chatgpt:6720…`
Most recent	`last`, `last-claude`, `last-codex`, `last-web`
File path	`~/.codex/sessions/2026/10/12/rollout-….jsonl`

Finding the id of a thread:

Where	How
Claude Code	Ask "what's this thread's id?" (the hook told it), check the `🧵` status line, or run `/threads`
Codex	`/status`
ChatGPT	the URL: `chatgpt.com/c/<id>`
claude.ai	the URL: `claude.ai/chat/<id>`
Anywhere	`chatbraid list [-s source] [-q words] [--here]`

The pickers:

Claude Code /braid: a multi-select question. Type extra ids under "Other".
Codex: a numbered table. Answer 1 3 or 2-4.
Terminal chatbraid pick: fzf multi-select (TAB to tick, ENTER to merge) with a live preview, or a numbered prompt without fzf.
Extension: a searchable checklist across both sites.
Web skill: a numbered list from your past chats or uploaded files. Reply with numbers.

5. Reference

Slash commands & skills

Where	Command	Does
Claude Code	`/braid [refs…] [focus: …]`	Merge into this thread (no args → pick)
Claude Code	`/threads [source] [words]`	List threads + this thread's id
Claude Code / Codex	skill `merge-threads` (`$merge-threads` in Codex)	Triggered by "merge my other thread", etc.
Codex	`/prompts:braid [refs…] \| last`	Merge, or adopt the latest saved merge
claude.ai / ChatGPT	skill `chatbraid`	"braid my chats about X", "braid these" (uploads)

CLI

chatbraid list   [-s SRC] [-q WORDS] [--here] [-n N] [--json]     list threads
chatbraid pick   [filters] [merge options] [--no-fzf]              interactive multi-select → merge
chatbraid merge  REF... [merge options]                            merge specific threads
chatbraid show   REF [--max-chars N] [--detail low|normal|high]    one thread, compacted
chatbraid files  FILE... [--select 1,3|all|words] [-q] [-s] [merge options]
                                                                   list / merge straight from files (exports, bundles, .jsonl)
chatbraid export REF... [-o threads.chatbraid.json]                bundle local threads for upload to the web skill
chatbraid import FILE...                                           import ChatGPT / claude.ai data exports or bundles
chatbraid tag    REF NAME                                          friendly alias
chatbraid last | merges                                            latest / all saved merges
chatbraid install [--codex] [--claude] [--link]                    wire into Codex / Claude Code
chatbraid mcp                                                      run the MCP server (stdio)

merge options:  -f/--focus TEXT   --llm   --max-chars N (default 100000)   --detail low|normal|high
                -c/--copy   -l/--launch claude|codex   -o/--output FILE
SRC:            all | claude | codex | web | chatgpt | claude.ai | local

Without --copy, --launch or -o, the merge prompt goes to stdout, so it pipes: chatbraid merge last-codex | pbcopy.

MCP tools

Tool	Arguments	Purpose
`list_threads`	`source, query, cwd, limit, exclude`	Browse threads, newest first
`merge_threads`	`refs, focus, mode (handoff\|llm), max_chars, detail`	Build the merge. `handoff`: the agent writes it. `llm`: an API model writes it and it's saved.
`save_merge`	`content, title, refs`	Persist a merged context
`load_merge`	`name` (`latest` / `list` / part of a name)	Reuse a merged context
`read_thread`	`ref, max_chars, detail`	Inspect one thread in detail
`tag_thread`	`ref, name`	Create an alias

Detail levels

`--detail`	Includes
`low`	user + assistant text
`normal` (default)	plus one-line tool calls (commands, files edited)
`high`	plus tool output

Errors from tools are always included.

6. Configuration

Env var	Default	Purpose
`CHATBRAID_HOME`	`~/.chatbraid`	Saved merges, tags, imported web chats, index cache
`CLAUDE_CONFIG_DIR`	`~/.claude`	Where Claude Code transcripts live
`CODEX_HOME`	`~/.codex`	Where Codex sessions live
`CHATBRAID_WEB_DIRS`	`~/Downloads/chatbraid`	`:`-separated extra folders scanned for web chats (replaces the default)
`CHATBRAID_PROVIDER`	auto	`anthropic` or `openai` for `--llm` / `mode=llm`
`ANTHROPIC_API_KEY` / `OPENAI_API_KEY`	none	Only needed for `--llm`
`CHATBRAID_ANTHROPIC_MODEL` / `CHATBRAID_OPENAI_MODEL`	`claude-sonnet-5-5` / `gpt-5`	Models for `--llm`
`CHATBRAID_TAB_TITLE=0`	on	Don't retitle the terminal tab at session start

7. How it works

 Claude Code  ~/.claude/projects/*/<id>.jsonl ─┐
 Codex        ~/.codex/sessions/**/rollout-*  ─┤               ┌─ MCP server ─→ Claude Code · Codex · Claude Desktop · Cursor…
 ChatGPT  ┐  extension / data export / bundle ├─ adapters ─→ digest ─┼─ CLI ────────→ pick · merge · --copy · --launch
 claude.ai┘                                   ┘  (one model)   │      └─ web skill ──→ same engine in claude.ai / ChatGPT sandbox
                                                               └─ extension: JS port of digest (kept byte-identical by tests)

Collect. Per-tool adapters turn each transcript format into one thread model. They drop the noise:
- thinking blocks, injected system and environment text, sidechains;
- abandoned edit/retry branches on the web;
- Codex's encrypted reasoning.
Compact. Each thread is fitted into a character budget:
- always kept: the original ask, the latest /compact summary, and the latest user and assistant turns;
- filled newest-first from what's left;
- long messages keep their head and tail;
- tool calls become one-liners, and files modified and recent commands go in a header.
The budget is split across threads by water-filling, so a short thread doesn't waste its share.
Merge. The digests are wrapped in the six-section merge prompt.
- handoff (default): the agent you're talking to writes the merged context. No API key, and it's that agent's own understanding.
- llm: an Anthropic or OpenAI model writes it ahead of time, with map-reduce for very large inputs.
Persist. save_merge writes ~/.chatbraid/merges/<time>-<title>.md and latest.md.

8. Privacy

Local by default. The plugin, CLI and MCP server only read files on your machine. Nothing leaves it unless you use --llm, which sends the digest to the provider you configured.
Extension. It talks to chatgpt.com / claude.ai only from inside your own logged-in tabs. No tokens or data go anywhere else. Downloads go to your Downloads folder.
Web skill. It runs inside your chat's sandbox, on files you uploaded to that chat.
Think before merging. Transcripts can contain secrets you pasted, such as API keys or .env contents. Merged contexts include verbatim snippets, so review before sharing a merge.

9. Troubleshooting

Symptom	Fix
`chatbraid: command not found`	Add `~/.local/bin` to `PATH`, or use `python3 /path/to/ChatBraid/bin/chatbraid`
`chatbraid list` is empty	Check that `~/.claude/projects` / `~/.codex/sessions` exist. If you use custom locations, set `CLAUDE_CONFIG_DIR` / `CODEX_HOME`.
Claude Code: no `/braid`	Run `/plugin` to check that it's installed and enabled, then restart Claude Code
Codex doesn't see the tools	Quit Codex completely (⌘Q for the app) and reopen. Check `tail ~/.codex/config.toml` and `codex mcp list`.
MCP server fails to start	Run the configured command by hand: `python3 …/bin/chatbraid mcp`, then type `{}` + Enter. It should print a JSON error, not a traceback.
A thread merges itself	Claude Code passes its own id automatically. In Codex, give the id from `/status` and ask it to exclude it.
`ref is ambiguous`	Use more characters of the id, or `source:id`
Chat URL doesn't resolve	Web chats must be exported first (extension Send to terminal or `chatbraid import`)
Extension: "API 401/403/404"	Sign in again / reload the tab. If it persists, the site changed its internal API: open an issue with the message.
Extension: text didn't appear in the box	It's on your clipboard: click the box and press ⌘V / Ctrl+V
claude.ai skill can't list chats	Enable Search and reference chats (paid plans), or upload an export instead
ChatGPT: no Skills page	Depends on plan / workspace. Use the extension or `--copy` instead.
Merge is too long / too short	`--max-chars 40000` / `150000`, or `--detail low` / `high`

10. Limitations

Merging is lossy by design. It's a compact. If a detail matters, the agent can read_thread the original.
The extension relies on internal endpoints. It uses the same internal endpoints the ChatGPT and claude.ai web apps use. They aren't public APIs and can change without notice. Data exports + chatbraid import / the web skill always work as a fallback.
claude.ai past-chat search is retrieval-based. For long chats, upload an export or use the extension when you need everything.
ChatGPT web can't fetch past chats on demand. Its skill works on uploaded files.
Codex cloud tasks can't see local history.
Codex's encrypted compaction summaries are skipped. The plaintext messages and tool calls around them are kept.

11. Development

python3 -m unittest discover tests -v   # all 4 parsers, file mode, export round-trip, MCP protocol, hook, budget, Python↔JS parity
scripts/build-web-skill.sh              # rebuild dist/chatbraid-web-skill.zip after changing chatbraid/ or skills-web/

chatbraid/            core engine (stdlib only): sources/, digest, index, files (file mode), mcp_server, cli, llm
bin/chatbraid         entry point (CLI + `mcp`)
.claude-plugin/ .mcp.json commands/ hooks/ skills/    Claude Code plugin (+ Codex skill)
codex/prompts/        Codex custom prompt
skills-web/chatbraid/ web skill source (SKILL.md + scripts/braid.py)
dist/                 built web skill zip
extension/            browser extension (MV3)
tests/                unit + integration tests

MIT licensed.