memfork 0.3.0

Git for agent memory, shared by every AI tool on your machine: fork, merge, rewind and hand off work between agents over MCP.
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
# MemFork client adapter registry (DESIGN ยง6.1).
#
# One entry per MCP client. Adding a client is an entry here plus a fixture
# test โ€” never new code.
#
# `verified` is the date the entry was last checked against `docs`. Nothing in
# this file was confirmed by running the client; it is what the vendor's own
# documentation, or the client's own source, says on that date. Re-check before
# a release. `unverified` says, in a sentence, what could *not* be confirmed
# on that date: it is shown by `memfork doctor`, and it is never left out to
# make an entry look finished.
#
# Each entry has up to two ways in:
#
#   [client.cli]   the client's own `mcp add` command. Preferred, because the
#                  client then writes its own config in its own format and
#                  MemFork never parses a file it does not own. `status` asks
#                  the same command whether MemFork is registered, which is the
#                  only answer that counts: a client may store its servers
#                  somewhere MemFork does not model, or normalise what it was
#                  given, and reading its file would then disagree with it. A
#                  command with no `status` can add but not answer outside an
#                  interactive wizard; registration is then read from its file.
#   [client.file]  direct config editing. Used only when the client ships no
#                  CLI, or its CLI cannot express the requested scope. A client
#                  with no `user` path is one whose user configuration MemFork
#                  will not touch at all; one with no `project` path reads no
#                  configuration from a project.
#
# In `add`, `{scope}` expands to zero or more flag tokens, `{name}` to the
# server name, `{command}` to the memfork binary path and `{args}` to its
# arguments. An expansion that produces nothing drops out of the command line.
#
# `remove` is how a registration that points at the wrong MemFork gets
# corrected: an install moves the binary, and the client keeps launching a path
# that is gone. A client with no documented `remove` is left alone and the
# command to run is printed instead, because guessing at a command that edits
# somebody's configuration is not a thing to do.
#
# Paths may use `$HOME`, `$APPDATA`, `$LOCALAPPDATA`, `$XDG_CONFIG_HOME` and
# `$XDG_DATA_HOME`, with `user_windows`, `user_macos`, `user_linux` (and the
# `project_` equivalents) overriding `user` and `project` for one OS. Each
# variable falls back to the OS's convention under the home directory, and
# when MEMFORK_HOME stands in for the home directory they are all derived from
# it, so a test never reaches the real one.
#
# `format` is `json`, `jsonc` (comments and trailing commas, edited the same
# way โ€” the JSON editor splices one entry and preserves everything else) or
# `toml`. `stdio_type` is the value of a `type` key the client wants on a
# local server, if any; `command_style = "array"` writes the command as one
# list with the program first; `extra` holds keys the client requires on every
# entry.
#
# `mcp_names` is what the client calls itself in MCP `initialize`, taken from
# its source code or its shipped build, since none of these document it. It is
# only used to show what a client wrote under the name a person knows; a
# client that is not listed is shown by the name it gave. A trailing `*`
# matches a prefix.
#
# [client.instructions] lists the files, relative to the repository root, that
# the client reads project instructions from on its own โ€” only files it always
# reads, not ones it reads conditionally. `memfork init --project` writes its
# block into the fewest of these that reach every chosen client.

[[client]]
id = "claude-code"
display = "Claude Code"
docs = "https://code.claude.com/docs/en/mcp"
verified = "2026-09-20"
# The directory this client creates for itself, so "installed but never
# configured" is not mistaken for "not installed".
detect_dir = "$HOME/.claude"
# Found in the shipped build; not documented.
mcp_names = ["claude-code"]

[client.cli]
binary = "claude"
add = ["mcp", "add", "{scope}", "{name}", "--", "{command}", "{args}"]
# Asks about one server by name, rather than listing every server and
# health-checking each by starting it.
status = ["mcp", "get", "{name}"]
# The scope flag follows the name here, unlike `add`.
remove = ["mcp", "remove", "{name}", "{scope}"]
scope_user = ["--scope", "user"]
scope_project = ["--scope", "project"]

[client.file]
format = "json"
server_map = ["mcpServers"]
stdio_type = "stdio"
http_url_key = "url"
project = ".mcp.json"
# No `user` path on purpose. This client keeps user-scope servers in
# `~/.claude.json`, together with its OAuth session, per-project trust settings
# and caches. MemFork neither writes nor reads that file: user scope goes
# through the `claude` command, and if that command is not on PATH, init writes
# project scope instead and says why. Leaving the path out of the registry is
# what makes that structural rather than a rule someone has to remember.

[client.instructions]
# It also reads AGENTS.md, but only when there is no CLAUDE.md at or above the
# working directory, so that is not a file it can be relied on to read.
reads = ["CLAUDE.md"]
docs = "https://code.claude.com/docs/en/memory"
verified = "2026-09-21"

[client.hooks]
# Verified against the hooks reference: `hooks.<Event>` lists of matcher
# groups, `type = "command"` in exec form (`command` plus `args`, no shell),
# `timeout` in seconds, `async` for a hook that must not hold the agent, and
# the events PreToolUse, PostToolUse, PostToolUseFailure and Stop. The local
# settings file is the person's own and the client keeps it out of git.
format = "claude-code"
project_local = ".claude/settings.local.json"
docs = "https://code.claude.com/docs/en/hooks"
verified = "2026-09-22"

[[client]]
id = "cursor"
display = "Cursor"
docs = "https://cursor.com/docs/context/mcp"
verified = "2026-09-22"
# The directory this client creates for itself, so "installed but never
# configured" is not mistaken for "not installed".
detect_dir = "$HOME/.cursor"
# Cursor ships no `mcp add`: its `agent` command lists, enables and disables
# servers but cannot add one, so the config file is the only way in.
#
# No `mcp_names`: its source is closed, its documentation does not say, and
# the only sightings are third-party logs (`cursor-vscode`, and `Cursor`),
# which is not the standard the other entries meet. Its writes are shown under
# whatever name it gives, and doctor says so.
unverified = "the name it sends in MCP initialize: seen as `cursor-vscode` in third-party logs, never in its documentation or a build MemFork could read; its Windows user path, which the documentation gives only as `~/.cursor/mcp.json`"

[client.file]
format = "json"
server_map = ["mcpServers"]
http_url_key = "url"
user = "$HOME/.cursor/mcp.json"
project = ".cursor/mcp.json"

[client.instructions]
# Also `.cursor/rules/*.mdc`, which need front matter; AGENTS.md is plain text.
reads = ["AGENTS.md"]
docs = "https://cursor.com/docs/context/rules"
verified = "2026-09-22"

[[client]]
id = "codex"
display = "Codex CLI"
docs = "https://learn.chatgpt.com/docs/extend/mcp?surface=cli"
verified = "2026-09-20"
# The directory this client creates for itself, so "installed but never
# configured" is not mistaken for "not installed".
detect_dir = "$HOME/.codex"
# From codex-rs/codex-mcp/src/rmcp_client.rs.
mcp_names = ["codex-mcp-client"]

[client.cli]
binary = "codex"
add = ["mcp", "add", "{name}", "--", "{command}", "{args}"]
remove = ["mcp", "remove", "{name}"]
# No `mcp get` is documented for this client, so registration is read off the
# list instead.
status = ["mcp", "list"]
# No scope flag is documented: `codex mcp add` writes the user config. Project
# scope therefore falls back to editing `.codex/config.toml`.
scope_user = []

[client.file]
format = "toml"
server_map = ["mcp_servers"]
http_url_key = "url"
user = "$HOME/.codex/config.toml"
project = ".codex/config.toml"

[client.instructions]
reads = ["AGENTS.md"]
docs = "https://learn.chatgpt.com/docs/agent-configuration/agents-md"
verified = "2026-09-21"

[[client]]
id = "gemini-cli"
display = "Gemini CLI"
docs = "https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md"
verified = "2026-09-20"
# The directory this client creates for itself, so "installed but never
# configured" is not mistaken for "not installed".
detect_dir = "$HOME/.gemini"
# From packages/core/src/tools/mcp-client.ts.
mcp_names = ["gemini-cli-mcp-client"]

[client.cli]
binary = "gemini"
# No `--` separator: the command and its arguments are positional.
add = ["mcp", "add", "{scope}", "{name}", "{command}", "{args}"]
status = ["mcp", "list"]
remove = ["mcp", "remove", "{scope}", "{name}"]
scope_user = ["-s", "user"]
scope_project = ["-s", "project"]

[client.file]
format = "json"
server_map = ["mcpServers"]
# The DESIGN ยง6.1 quirk: Gemini CLI uses `httpUrl` for streamable HTTP and `url`
# for SSE, where most clients use `url` for streamable HTTP. Unused until the
# shared daemon, encoded here so the difference is recorded once.
http_url_key = "httpUrl"
user = "$HOME/.gemini/settings.json"
project = ".gemini/settings.json"

[client.instructions]
# The default; `context.fileName` in its settings can change it.
reads = ["GEMINI.md"]
docs = "https://geminicli.com/docs/cli/gemini-md/"
verified = "2026-09-21"

[[client]]
id = "grok"
display = "Grok Build"
docs = "https://docs.x.ai/build/features/mcp-servers"
verified = "2026-09-20"
# The directory this client creates for itself, so "installed but never
# configured" is not mistaken for "not installed".
detect_dir = "$HOME/.grok"
# From crates/codegen/xai-grok-mcp/src/servers.rs: the configured server's name
# follows the prefix.
mcp_names = ["grok-shell-*"]

[client.cli]
binary = "grok"
add = ["mcp", "add", "{scope}", "{name}", "--", "{command}", "{args}"]
status = ["mcp", "list"]
# No scope flag documented for remove, so none is sent.
remove = ["mcp", "remove", "{name}"]
# User scope is the default and takes no flag.
scope_user = []
scope_project = ["--scope", "project"]

[client.file]
format = "toml"
server_map = ["mcp_servers"]
http_url_key = "url"
user = "$HOME/.grok/config.toml"
project = ".grok/config.toml"

[client.instructions]
# It reads both, so it is reached by whichever the other clients need.
reads = ["AGENTS.md", "CLAUDE.md"]
docs = "https://docs.x.ai/build/features/project-rules"
verified = "2026-09-21"

# ---- the eleven clients after the first five ----------------------------------

[[client]]
id = "cline"
display = "Cline"
docs = "https://docs.cline.bot/mcp/configuring-mcp-servers"
verified = "2026-09-22"
# The CLI's own directory, and the VS Code extension's storage on each OS.
detect_dirs = [
    "$HOME/.cline",
    "$XDG_CONFIG_HOME/Code/User/globalStorage/saoudrizwan.claude-dev",
    "$HOME/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev",
    "$APPDATA/Code/User/globalStorage/saoudrizwan.claude-dev",
]
# `Cline` from apps/vscode/src/services/mcp/McpHub.ts; the newer SDK core
# sends `@cline/core` (sdk/packages/core/src/extensions/mcp/client.ts).
mcp_names = ["Cline", "@cline/core"]
unverified = "whether its CLI can list servers outside its interactive wizard, so a registration made by the `cline` command is confirmed by reading its file; whether the extension reads a project's `.cline/mcp.json`, so MemFork does not write one"

[client.cli]
binary = "cline"
# `--yes` installs without opening the wizard; the command and its arguments
# follow `--`. From apps/cli/src/main.ts. Writes the CLI's own settings file,
# `~/.cline/data/settings/cline_mcp_settings.json`, not the extension's.
add = ["mcp", "add", "{name}", "--yes", "--", "{command}", "{args}"]
remove = ["mcp", "remove", "{name}"]
# No scope flag is documented.
scope_user = []

[client.file]
format = "json"
server_map = ["mcpServers"]
# `type` is optional and defaults to stdio; written for clarity, as its
# documentation's examples do not, so left out.
http_url_key = "url"
# The VS Code extension's file, which the documentation names; the CLI has
# its own (`~/.cline/data/settings/cline_mcp_settings.json`), which the
# `cline` command writes when it is installed.
user_linux = "$XDG_CONFIG_HOME/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
user_macos = "$HOME/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
user_windows = "$APPDATA/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
user = "$XDG_CONFIG_HOME/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json"
# No `project` path: `.cline/mcp.json` is listed for the CLI's project layout
# but its shape, and whether the extension reads it, are not documented.

[client.instructions]
# Also `.clinerules/` and `.cline/rules/`, which are directories of files.
reads = ["AGENTS.md"]
docs = "https://docs.cline.bot/features/cline-rules"
verified = "2026-09-22"

[[client]]
id = "opencode"
display = "OpenCode"
docs = "https://opencode.ai/docs/mcp-servers/"
verified = "2026-09-22"
# Created at start-up on every OS; no APPDATA on Windows, by its own choice.
detect_dirs = ["$XDG_CONFIG_HOME/opencode", "$XDG_DATA_HOME/opencode"]
# From packages/opencode/src/mcp/index.ts.
mcp_names = ["opencode"]
unverified = "how to remove a server: its command has no `remove`, so a registration pointing at another MemFork is corrected by editing the file"

[client.cli]
binary = "opencode"
# Non-interactive when a name and a command after `--` are given; it then
# writes the user config and offers no scope flag.
add = ["mcp", "add", "{name}", "--", "{command}", "{args}"]
# Prints each server with its command.
status = ["mcp", "list"]
scope_user = []

[client.file]
# JSON or JSONC, its documentation says; comments are kept.
format = "jsonc"
server_map = ["mcp"]
# A local server is `"type": "local"` with the command as one list, the
# program first.
stdio_type = "local"
command_style = "array"
http_url_key = "url"
# `~/.config/opencode/opencode.json` on every OS: it uses the XDG layout on
# Windows too.
user = "$XDG_CONFIG_HOME/opencode/opencode.json"
project = "opencode.json"

[client.instructions]
# CLAUDE.md is read only when there is no AGENTS.md.
reads = ["AGENTS.md"]
docs = "https://opencode.ai/docs/rules/"
verified = "2026-09-22"

[[client]]
id = "qwen-code"
display = "Qwen Code"
docs = "https://qwenlm.github.io/qwen-code-docs/en/users/features/mcp/"
verified = "2026-09-22"
detect_dir = "$HOME/.qwen"
# From packages/core/src/tools/mcp-client.ts: `qwen-cli-mcp-client-<server>`
# and `qwen-code-mcp-client`.
mcp_names = ["qwen-*"]

[client.cli]
binary = "qwen"
# The command and its arguments are positional, as in Gemini CLI, which this
# client descends from.
add = ["mcp", "add", "{scope}", "{name}", "{command}", "{args}"]
# Prints each server with its command.
status = ["mcp", "list"]
remove = ["mcp", "remove", "{scope}", "{name}"]
scope_user = ["-s", "user"]
scope_project = ["-s", "project"]

[client.file]
format = "json"
server_map = ["mcpServers"]
# No `type`: the transport is inferred from `command`, `url` or `httpUrl`.
http_url_key = "httpUrl"
user = "$HOME/.qwen/settings.json"
project = ".qwen/settings.json"

[client.instructions]
# QWEN.md is its own; it reads AGENTS.md as well when one is there.
reads = ["QWEN.md", "AGENTS.md"]
docs = "https://qwenlm.github.io/qwen-code-docs/en/users/features/memory/"
verified = "2026-09-22"

[[client]]
id = "kiro"
display = "Kiro"
docs = "https://kiro.dev/docs/mcp/configuration/"
verified = "2026-09-22"
detect_dir = "$HOME/.kiro"
# No `mcp_names`: the product's source is closed and no log of its
# `initialize` was found.
unverified = "the name it sends in MCP initialize (closed source); its Windows user path, which the documentation gives only as `~/.kiro/settings/mcp.json`; `kiro-cli mcp add` takes the command as one quoted string with no documented way to pass arguments, so MemFork edits the file instead"

[client.file]
format = "json"
server_map = ["mcpServers"]
# No `type`: a remote server is one with `url`.
http_url_key = "url"
user = "$HOME/.kiro/settings/mcp.json"
project = ".kiro/settings/mcp.json"

[client.instructions]
# Also `.kiro/steering/*.md`, included always unless their front matter says
# otherwise; AGENTS.md is picked up automatically.
reads = ["AGENTS.md"]
docs = "https://kiro.dev/docs/steering/"
verified = "2026-09-22"

[[client]]
id = "copilot-cli"
display = "GitHub Copilot CLI"
docs = "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers"
verified = "2026-09-22"
detect_dir = "$HOME/.copilot"
# Seen in wire logs pasted into the vendor's own issue tracker (issues 4525
# and 4888), not in a build MemFork could read: it ships as a compressed
# blob.
mcp_names = ["copilot-cli"]
unverified = "the name it sends in MCP initialize is taken from logs in the vendor's issue tracker, not from its source; its Windows user path, which the documentation gives only as `~/.copilot`"

[client.cli]
binary = "copilot"
add = ["mcp", "add", "{name}", "--", "{command}", "{args}"]
# Asks about one server by name.
status = ["mcp", "get", "{name}"]
remove = ["mcp", "remove", "{name}"]
# No scope flag: the command writes the user configuration only.
scope_user = []

[client.file]
format = "json"
server_map = ["mcpServers"]
# Its documentation lists `type` and `tools` as required on every server.
stdio_type = "local"
extra = { tools = ["*"] }
http_url_key = "url"
user = "$HOME/.copilot/mcp-config.json"
# `.github/mcp.json`, the shared project file. It also reads `.mcp.json`,
# which Claude Code owns in the registry; two clients writing one file with
# different required keys is a way to break both.
project = ".github/mcp.json"

[client.instructions]
# All three are read from the repository root.
reads = [".github/copilot-instructions.md", "AGENTS.md", "CLAUDE.md"]
docs = "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-custom-instructions"
verified = "2026-09-22"

[[client]]
id = "devin"
display = "Devin CLI"
docs = "https://docs.devin.ai/cli/extensibility/mcp/configuration"
verified = "2026-09-22"
detect_dirs = ["$XDG_CONFIG_HOME/devin", "$APPDATA/devin"]
# No `mcp_names`: the command is a downloaded binary with no public source,
# and no log of its `initialize` was found.
unverified = "the name it sends in MCP initialize (no public source); its macOS user path, which the documentation gives as `~/.config/devin`, with one page mentioning `~/Library/Application Support/devin`"

[client.cli]
binary = "devin"
# Its default scope is `local`, a gitignored file in the project, so the
# scope is always said.
add = ["mcp", "add", "{scope}", "{name}", "--", "{command}", "{args}"]
status = ["mcp", "get", "{name}"]
remove = ["mcp", "remove", "{scope}", "{name}"]
scope_user = ["-s", "user"]
scope_project = ["-s", "project"]

[client.file]
format = "json"
server_map = ["mcpServers"]
# No `type` for a local server; a remote one has `transport`.
http_url_key = "url"
user = "$XDG_CONFIG_HOME/devin/mcp_config.json"
user_windows = "$APPDATA/devin/mcp_config.json"
project = ".devin/mcp_config.json"

[client.instructions]
reads = ["AGENTS.md", "CLAUDE.md"]
docs = "https://docs.devin.ai/cli/extensibility/rules"
verified = "2026-09-22"

[[client]]
id = "windsurf"
display = "Windsurf"
docs = "https://docs.devin.ai/desktop/cascade/mcp"
verified = "2026-09-22"
detect_dir = "$HOME/.codeium/windsurf"
# No `mcp_names`: closed source, and no log of its `initialize` was found.
#
# The editor is being renamed Devin Desktop and its documentation now moves
# under docs.devin.ai. Its Cascade agent's servers are added by editing the
# file โ€” it has no command for it โ€” and the same documentation says the
# editor's own discovery still reads this long-standing path. Its newer Devin
# Local agent reads the Devin CLI's file, which the `devin` entry writes.
unverified = "the name it sends in MCP initialize (closed source); which of `~/.codeium/windsurf/mcp_config.json` and `~/.config/devin/mcp_config.json` a given build reads, while the editor is renamed Devin Desktop and its documentation moves"

[client.file]
format = "json"
server_map = ["mcpServers"]
# The quirk: a remote server's address is `serverUrl` here.
http_url_key = "serverUrl"
user = "$HOME/.codeium/windsurf/mcp_config.json"
# No project file is documented for Cascade.

[client.instructions]
# `AGENTS.md` at the root is always on; `.windsurf/rules/*.md` carry their own
# triggers.
reads = ["AGENTS.md"]
docs = "https://docs.devin.ai/desktop/cascade/agents-md"
verified = "2026-09-22"

[[client]]
id = "zed"
display = "Zed"
docs = "https://zed.dev/docs/ai/mcp"
verified = "2026-09-22"
# Its data directory on each OS, where extensions are kept.
detect_dirs = [
    "$XDG_DATA_HOME/zed",
    "$HOME/Library/Application Support/Zed",
    "$LOCALAPPDATA/Zed",
    "$XDG_CONFIG_HOME/zed",
]
# From crates/context_server/src/context_server.rs.
mcp_names = ["Zed"]
# Zed ships no command for servers: its Settings UI and this file are the ways in.

[client.file]
# Its settings file carries comments.
format = "jsonc"
server_map = ["context_servers"]
# No `type` or `source`: a local server is one with `command`.
http_url_key = "url"
user = "$XDG_CONFIG_HOME/zed/settings.json"
user_macos = "$HOME/.config/zed/settings.json"
user_windows = "$APPDATA/Zed/settings.json"
project = ".zed/settings.json"

[client.instructions]
# Zed reads the *first* file it finds of `.rules`, `.cursorrules`,
# `.windsurfrules`, `.clinerules`, `.github/copilot-instructions.md`,
# `AGENT.md`, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`. AGENTS.md is the one it
# shares with the others; a repository with a `.rules` file shadows it.
reads = ["AGENTS.md"]
docs = "https://zed.dev/docs/ai/instructions"
verified = "2026-09-22"

[[client]]
id = "vscode"
display = "Visual Studio Code"
docs = "https://code.visualstudio.com/docs/agents/reference/mcp-configuration"
verified = "2026-09-22"
detect_dirs = [
    "$XDG_CONFIG_HOME/Code",
    "$HOME/Library/Application Support/Code",
    "$APPDATA/Code",
]
# Its source builds the name from its product configuration, which is
# `Code - OSS` in the open repository and not published for the Microsoft
# build.
unverified = "the name it sends in MCP initialize: its source uses the product's long name, which is not published for the Microsoft build; `code --add-mcp` exists but cannot list or remove a server, so MemFork writes the file it would write"

[client.file]
format = "jsonc"
server_map = ["servers"]
stdio_type = "stdio"
http_url_key = "url"
user = "$XDG_CONFIG_HOME/Code/User/mcp.json"
user_macos = "$HOME/Library/Application Support/Code/User/mcp.json"
user_windows = "$APPDATA/Code/User/mcp.json"
project = ".vscode/mcp.json"

[client.instructions]
# Each is on by default: `github.copilot.chat.codeGeneration.useInstructionFiles`,
# `chat.useAgentsMdFile`, `chat.useClaudeMdFile`.
reads = [".github/copilot-instructions.md", "AGENTS.md", "CLAUDE.md"]
docs = "https://code.visualstudio.com/docs/agent-customization/custom-instructions"
verified = "2026-09-22"

[[client]]
id = "factory-droid"
display = "Factory Droid"
docs = "https://docs.factory.ai/cli/configuration/mcp"
verified = "2026-09-22"
detect_dir = "$HOME/.factory"
# Read out of the shipped build (`@factory/cli-win32-x64`, `bin/droid.exe`):
# user servers are connected as `factory-cli`.
mcp_names = ["factory-cli"]
unverified = "`droid mcp add` takes the command and its arguments as one quoted string, so MemFork writes the file rather than guess at the quoting"

[client.file]
format = "json"
server_map = ["mcpServers"]
stdio_type = "stdio"
http_url_key = "url"
user = "$HOME/.factory/mcp.json"
project = ".factory/mcp.json"

[client.instructions]
reads = ["AGENTS.md", "CLAUDE.md"]
docs = "https://docs.factory.ai/cli/configuration/agents-md"
verified = "2026-09-22"

[[client]]
id = "openhands"
display = "OpenHands"
docs = "https://docs.openhands.dev/openhands/usage/cli/mcp-servers"
verified = "2026-09-22"
detect_dir = "$HOME/.openhands"
# No `mcp_names`: it sends the Python SDK's default, `mcp`, which names
# nothing in particular and would mislabel every other client built on it.
unverified = "the name it sends in MCP initialize is the SDK's default `mcp`, so its writes cannot be told from another such client's; on Windows it runs under WSL only, so its paths are WSL paths"

[client.cli]
binary = "openhands"
# `--transport` is required; the command is positional and its arguments
# follow `--`.
add = ["mcp", "add", "{name}", "--transport", "stdio", "{command}", "--", "{args}"]
status = ["mcp", "get", "{name}"]
remove = ["mcp", "remove", "{name}"]
# One file, no scope.
scope_user = []

[client.file]
format = "json"
server_map = ["mcpServers"]
http_url_key = "url"
user = "$HOME/.openhands/mcp.json"
# No project file: it reads one file, in the home directory.

[client.instructions]
reads = ["AGENTS.md", "CLAUDE.md"]
docs = "https://docs.openhands.dev/sdk/guides/skill.md"
verified = "2026-09-22"