Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

40.1 KB
Raw Blame
package library

import (
	"fmt"
	"os"
	"path/filepath"
	"slices"
	"strings"

	"github.com/tidwall/gjson"
	"github.com/tidwall/jsonc"

	"github.com/yetone/magpie/internal/agent"
	"github.com/yetone/magpie/internal/agentplug"
	"github.com/yetone/magpie/internal/appdir"
	"github.com/yetone/magpie/internal/desktopdir"
	"github.com/yetone/magpie/internal/edit"
	"github.com/yetone/magpie/internal/plugin"
)

// Target is where one agent keeps each of the three: an empty path is
// something it has no user-wide place for.
type Target struct {
	Agent *agent.Agent
	// Instructions is the file the agent reads before every conversation;
	// Override, when it exists, is read instead of it (Codex's
	// AGENTS.override.md), which the page warns of.
	Instructions, Override string
	MCP                    *mcpFile
	Skills                 string // the folder the agent finds skills in
	// SkillsAlso are agents whose skills this one reads as well, as
	// OpenCode reads Claude Code's.
	SkillsAlso []string
	// MCPVia is the extension the agent reads its MCP servers through, for
	// one that has none of its own.
	MCPVia string
	// Note is what the page says of the agent's instructions file.
	Note string
	// Copy is an agent that gets a copy of each skill, made again when
	// the library's changes, rather than a link: one in a WSL distro,
	// which can't follow a link to a Windows folder.
	Copy bool
	// Desktop are Claude Desktop's skills-plugin folders, one for each
	// account (desktop_skills.go): each gets a copy of the skills and their
	// entries in its manifest.json. Skills is the first one's skills.
	Desktop []string
	// Settings is Claude Code's settings.json, whose permissions.deny
	// leaves out the tools of a server turned off (mcp_tools_off.go)
	Settings string
	// Gone is an agent no longer installed here that still has what magpie
	// gave it (held): a sync only takes things out of it, as they are
	// unticked, and gives it nothing.
	Gone bool
	// Profile says the instructions file is the user's profile to the
	// agent, not instructions alone (Alma's USER.md): magpie adds its part
	// after the user's, but never moves the user's own lines out of it
	// (ImportInstructions), as the agent reads who its owner is there.
	Profile bool
}

func home() string { h, _ := os.UserHomeDir(); return h }

// grokDir is where Grok Build keeps its config.toml: $GROK_HOME, else ~/.grok
// (internal/agent/grok.go grokIn).
func grokDir() string {
	if d := appdir.Getenv("GROK_HOME"); d != "" {
		return d
	}
	return filepath.Join(home(), ".grok")
}

func claudeDir() string { return appdir.ClaudeDirIn(home()) }

// claudeJSON is where Claude Code keeps its user-wide MCP servers: beside
// its folder, or in it when CLAUDE_CONFIG_DIR moves it.
func claudeJSON() string {
	if d := appdir.Getenv("CLAUDE_CONFIG_DIR"); d != "" {
		return filepath.Join(d, ".claude.json")
	}
	return filepath.Join(home(), ".claude.json")
}

// codebuddyMCP is the file CodeBuddy Code, its folder dir, reads its
// user-wide MCP servers from (see targetOf).
func codebuddyMCP(dir string) string {
	base := appdir.Getenv("CODEBUDDY_CONFIG_DIR")
	if base == "" {
		base = home()
	}
	return codebuddyMCPIn(dir, base)
}

// codebuddyMCPIn is codebuddyMCP with base as where .codebuddy.json is
// beside: a WSL distro's home for the CodeBuddy Code there.
func codebuddyMCPIn(dir, base string) string {
	all := []string{filepath.Join(dir, ".mcp.json"), filepath.Join(dir, "mcp.json"), filepath.Join(base, ".codebuddy.json")}
	for _, p := range all {
		if _, err := os.Stat(p); err == nil {
			return p
		}
	}
	return all[0]
}

func codexDir() string { return appdir.CodexHomeIn(home()) }

// targetOf is where a known agent keeps them, or nil for one magpie can't
// give any of them to.
func targetOf(a *agent.Agent) *Target {
	if a.WSL != "" {
		return wslTargetOf(a)
	}
	h := home()
	t := &Target{Agent: a}
	if n := a.SharedName(); n != a.Name {
		// the files are another app's too (the Cursor editor's ~/.cursor):
		// named for both, not for the CLI alone
		named := *a
		named.Name = n
		t.Agent = &named
	}
	switch a.ID {
	case "claude":
		d := claudeDir()
		t.Instructions = filepath.Join(d, "CLAUDE.md")
		t.MCP = &mcpFile{Path: claudeJSON(), Format: fmtClaude}
		t.Skills = filepath.Join(d, "skills")
		t.Settings = filepath.Join(d, "settings.json")
	case "codex":
		d := codexDir()
		t.Instructions = filepath.Join(d, "AGENTS.md")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "config.toml"), Format: fmtCodex}
		t.Skills = filepath.Join(d, "skills")
	case "gemini":
		d := filepath.Join(h, ".gemini")
		t.Instructions = filepath.Join(d, "GEMINI.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "settings.json"), Format: fmtGemini}
		t.Skills = filepath.Join(d, "skills")
	case "agy":
		// Antigravity — the app and agy alike — reads its user-wide
		// customizations from ~/.gemini/config: GEMINI.md there (as well as
		// Gemini CLI's ~/.gemini/GEMINI.md), mcp_config.json and skills
		// (antigravity.google/docs/rules, /mcp, /skills; agy 1.2's `mcp
		// add` writes that file); agy 1.2 reads no mcp_config.json from the
		// IDE's older ~/.gemini/antigravity.
		d := filepath.Join(h, ".gemini", "config")
		t.Instructions = filepath.Join(d, "GEMINI.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp_config.json"), Format: fmtAntigravity}
		t.Skills = filepath.Join(d, "skills")
	case "opencode", "deveco":
		// DevEco Code is OpenCode's fork and reads as it does: AGENTS.md
		// in its config folder, else Claude Code's CLAUDE.md, skills there
		// and under ~/.claude and ~/.agents (packages/opencode/src/session
		// /instruction.ts, skill/index.ts)
		d := filepath.Dir(a.Path)
		t.Instructions = filepath.Join(d, "AGENTS.md")
		t.Note = "opencode-claude"
		t.MCP = &mcpFile{Path: a.Path, Format: fmtOpenCode}
		t.Skills = filepath.Join(d, "skills")
		t.SkillsAlso = []string{"claude"}
	case "mimocode":
		// MiMo Code is OpenCode's config shape; it reads Claude Code's
		// CLAUDE.md but its own skills only (a flag opens .claude's), so the
		// shared skills go into its own folder, not Claude Code's.
		d := filepath.Dir(a.Path)
		t.Instructions = filepath.Join(d, "AGENTS.md")
		t.MCP = &mcpFile{Path: a.Path, Format: fmtOpenCode}
		t.Skills = filepath.Join(d, "skills")
	case "pi":
		// PI_CODING_AGENT_DIR's, else ~/.pi/agent (agent.piDir). Pi reads
		// AGENTS.override.md there when it is there, else the first there
		// is of AGENTS.md, AGENTS.MD, CLAUDE.md and CLAUDE.MD
		// (loadContextFileFromDir in dist/core/resource-loader.js,
		// @earendil-works/pi-coding-agent 1.2.0; the older
		// @mariozechner/pi-coding-agent has the same order without the
		// override), so a CLAUDE.md of the user's own is the one to edit
		d := a.Dir
		t.Instructions = firstThere(d, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		// Pi 0.99 reads MCP servers itself, from its mcp.json; before it,
		// and while an MCP extension replaces its own (pi-mcp-adapter,
		// pi-mcp-extension), each extension reads its own file (pimcp.go)
		t.MCP, t.MCPVia = piMCP(h, d, piVersion(a), piGlobalRoots())
		t.Skills = filepath.Join(d, "skills")
	case "dsh":
		// DeepSeek Harness reads $DSH_HOME/AGENTS.md and $DSH_HOME/skills;
		// its MCP servers are @deepseek-ai/dsh-mcp-client rows its patch
		// lists insert, every profile's
		d := a.Dir
		t.Instructions = filepath.Join(d, "AGENTS.md")
		files := agent.DshPatchFiles(d)
		t.MCP = &mcpFile{Path: files[0], Also: files[1:], Format: fmtDsh}
		t.Skills = filepath.Join(d, "skills")
	case "omp":
		// ~/.omp/agent, or where omp's variables move it (agent.ompDir)
		d := a.Dir
		t.Instructions = filepath.Join(d, "AGENTS.md")
		// omp reads mcpServers from its agent folder's mcp.json
		// (discovery/builtin.ts), type choosing the transport
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp.json"), Format: fmtOmp}
		t.Skills = filepath.Join(d, "skills")
	case "omo":
		// OmO's engine (senpi, a fork of Pi) reads its agent folder's
		// AGENTS.md, skills and mcp.json — mcpServers in the shape Pi 0.99's
		// own has (command/args/env, url/headers), any other key refusing
		// the whole file (docs/mcp.md, config-schema.js). Its instructions
		// are found as Pi's are: AGENTS.override.md, else the first there
		// is of AGENTS.md, AGENTS.MD, CLAUDE.md and CLAUDE.MD
		// (loadContextFileFromDir, @code-yeongyu/senpi 2026.10.12)
		d := a.Dir
		t.Instructions = firstThere(d, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp.json"), Format: fmtPiNative}
		t.Skills = filepath.Join(d, "skills")
	case "goose":
		t.Instructions = filepath.Join(filepath.Dir(a.Path), ".goosehints")
		t.MCP = &mcpFile{Path: a.Path, Format: fmtGoose}
		// Goose finds skills in ~/.agents/skills first, its docs say
		t.Skills = sharedSkillsDir()
	case "cursor":
		d := filepath.Join(h, ".cursor")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp.json"), Format: fmtCursor}
		t.Skills = filepath.Join(d, "skills")
	case "copilot":
		d := appdir.Getenv("COPILOT_HOME")
		if d == "" {
			d = filepath.Join(h, ".copilot")
		}
		t.Instructions = filepath.Join(d, "copilot-instructions.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp-config.json"), Format: fmtCopilot}
		t.Skills = filepath.Join(d, "skills")
	case "crush":
		// Crush reads CRUSH.md from its config folder, ~/.config/crush on
		// Windows too since Crush 0.14; the crush.json magpie edits there is
		// %LOCALAPPDATA%\crush's, where Crush keeps its own picks and reads
		// skills but no CRUSH.md
		cfg := appdir.Getenv("XDG_CONFIG_HOME")
		if cfg == "" {
			cfg = filepath.Join(h, ".config")
		}
		t.Instructions = filepath.Join(cfg, "crush", "CRUSH.md")
		t.MCP = &mcpFile{Path: a.Path, Format: fmtCrush}
		t.Skills = filepath.Join(filepath.Dir(a.Path), "skills")
		t.SkillsAlso = []string{"claude"}
	case "zcode":
		// ZCode's own servers are its cli/config.json's mcp.servers (the
		// app's MCP settings write there); AGENTS.md and skills beside it
		// under the home ZCode reads, HOME first on Windows too
		d := filepath.Join(appdir.ZCodeHome(h), ".zcode")
		t.Instructions = filepath.Join(d, "AGENTS.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "cli", "config.json"), Format: fmtZCode}
		t.Skills = filepath.Join(d, "skills")
	case "kimi":
		// Kimi Code reads one user-wide folder of each kind, the first there
		// is: ~/.kimi/skills, ~/.claude/skills, ~/.codex/skills — so one of
		// its own would hide Claude Code's from it — and ~/.config/agents/
		// skills, ~/.agents/skills (kimi_cli/skill), wherever KIMI_SHARE_DIR
		// is; before its 1.x brand/generic split, only the first of all five.
		// The new Kimi Code (2.x) reads its own and ~/.agents/skills only.
		//
		// Its MCP servers are the mcp.json in its folder, which the old
		// kimi-cli (fastmcp's MCPConfig) and the new Kimi Code read alike.
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtKimi}
		if _, legacy := agent.KimiDir(h); !legacy {
			// the new Kimi Code reads AGENTS.md in its folder ($KIMI_CODE_HOME,
			// else ~/.kimi-code) before every conversation; kimi-cli reads no
			// user-wide one (loadAgentsMdForRoots in packages/agent-core-v2/
			// src/agent/profile/context.ts, MoonshotAI/kimi-code afd95f64)
			t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
			t.Skills = sharedSkillsDir()
		} else if d := filepath.Join(h, ".config", "agents", "skills"); isDir(d) {
			t.Skills = d
		} else {
			t.Skills = sharedSkillsDir()
		}
	case "alma":
		// Alma reads personal skills from ~/.config/alma/skills, on every
		// system (its home, not its data folder), and Claude Code's, Codex's
		// and ~/.agents/skills besides (its skills service, #824). Its MCP
		// servers are ~/.config/alma/mcp.json's mcpServers, read as Alma
		// starts and when its MCP settings refresh (0.4.164's
		// out/main/index.js, #1292). Its main chat puts ~/.config/alma/
		// USER.md, on every system, in its system prompt as its owner's
		// profile ("name, preferences, habits"), unless the thread's
		// workspace has a USER.md of its own (0.4.164's out/main/index.js,
		// #2315): magpie's part goes after what the user has there. The
		// file's YAML front matter is where Alma's Telegram and Discord
		// bots read who the owner is, so it is a Profile: the user's own
		// lines are never moved out of it
		t.Instructions = filepath.Join(h, ".config", "alma", "USER.md")
		t.Profile = true
		t.Skills = filepath.Join(h, ".config", "alma", "skills")
		t.MCP = &mcpFile{Path: filepath.Join(h, ".config", "alma", "mcp.json"), Format: fmtAlma}
		t.SkillsAlso = []string{"claude", "codex"}
	case "cindy":
		// Cindy keeps its user-wide skills in ~/.agents/skills
		t.Skills = sharedSkillsDir()
	case "hermes":
		// Hermes Agent reads mcp_servers from $HERMES_HOME/config.yaml, the
		// file magpie sets its model in too (tools/mcp_tool.py), and skills
		// from $HERMES_HOME/skills
		t.MCP = &mcpFile{Path: a.Path, Format: fmtHermes}
		t.Skills = filepath.Join(a.Dir, "skills")
	case "minimax-code":
		// MiniMax Code loads the skills in its data folder ($MINIMAX_DATA_DIR,
		// else ~/.minimax); it has no user-wide MCP file, only plugins' own
		t.Skills = filepath.Join(a.Dir, "skills")
	case "devin":
		// Devin reads its user-wide MCP servers from mcp_config.json
		// beside its config.json (devin mcp add --scope user)
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp_config.json"), Format: fmtDevin}
		t.Skills = filepath.Join(a.Dir, "skills")
		// and its global rules from AGENTS.md there, else the singular
		// AGENT.md it also reads, at the start of every session (Rules &
		// AGENTS.md → Global Rules in the docs Devin CLI 3000.11.92 ships,
		// share/devin/docs/extensibility/rules.mdx, #3151)
		t.Instructions = firstThere(a.Dir, "AGENTS.md", "AGENT.md")
	case "grok":
		// Grok Build reads [mcp_servers.<name>] from its config.toml, as
		// `grok mcp add` writes them; its user-wide instructions are
		// $GROK_HOME/AGENTS.md, loaded before a project's own
		t.MCP = &mcpFile{Path: a.Path, Format: fmtGrok}
		t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
		t.Skills = filepath.Join(a.Dir, "skills")
	case "grok-app":
		// Independent mode (Use on a custom provider) starts the CLI with
		// GROK_HOME at agent-home, beside config.toml (grok-app's
		// providers.md). Shared mode keeps ~/.grok, which is Grok Build's
		// row. Skills there are read as well as ~/.agents/skills.
		home := filepath.Dir(a.Path)
		t.MCP = &mcpFile{Path: a.Path, Format: fmtGrok}
		t.Instructions = filepath.Join(home, "AGENTS.md")
		t.Skills = filepath.Join(home, "skills")
	case "droid":
		// Droid's user-wide servers are ~/.factory/mcp.json's mcpServers,
		// type stdio, http or sse as Claude Code's (docs.factory.ai/cli/
		// configuration/mcp); its personal instructions are ~/.factory/
		// AGENTS.md, which project files override (cli/configuration/agents-md)
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtClaude}
		t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
		t.Skills = filepath.Join(a.Dir, "skills")
	case "qoder", "qoder-cn":
		// Qoder's user-wide servers are its settings.json's mcpServers
		// (docs.qoder.com/cli/mcp-reference), beside magpie's provider
		t.MCP = &mcpFile{Path: a.Path, Format: fmtOmp}
		t.Skills = filepath.Join(a.Dir, "skills")
		// and AGENTS.md in its folder before every conversation, which its
		// settings' context.fileName renames as Qwen Code's does
		// (discoverMemoryPaths, @qoder-ai/qodercli 1.1.69's bundle)
		t.Instructions = filepath.Join(a.Dir, contextFile(a.Path, "AGENTS.md"))
	case "cline":
		// Cline's CLI reads its MCP servers from settings/
		// cline_mcp_settings.json beside providers.json, or
		// $CLINE_MCP_SETTINGS_PATH (@cline/shared's storage)
		p := appdir.Getenv("CLINE_MCP_SETTINGS_PATH")
		if p == "" {
			p = filepath.Join(filepath.Dir(a.Path), "cline_mcp_settings.json")
		}
		t.MCP = &mcpFile{Path: p, Format: fmtCline}
		t.Skills = filepath.Join(a.Dir, "skills")
	case "commandcode":
		// Command Code reads ~/.commandcode/mcp.json (getUserMcpConfigPath)
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtCommandCode}
		t.Skills = filepath.Join(a.Dir, "skills")
		// and ~/.commandcode/AGENTS.md before every conversation
		// (getUserMemoryPath, command-code 1.81.0's dist/cli.mjs)
		t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
	case "workbuddy", "workbuddy-ai":
		// WorkBuddy's own servers are mcp.json in its folder (WorkBuddy
		// AI's, ~/.workbuddy-ai, for the international build)
		// ($WORKBUDDY_CONFIG_DIR, else ~/.workbuddy: ConnectorService's
		// customMcpConfigPath in 5.5.6's app.asar), mcpServers as Claude
		// Code's, which its CodeBuddy engine runs (type stdio, http or sse).
		// WorkBuddy connects one only once it is trusted there: a server
		// mcp-approvals.json has no approval for (its command, args and env
		// names, or its URL's origin) is listed as needing approval until it
		// is switched on in WorkBuddy, which magpie leaves to the user
		// (#1266). Its skills are in skills/ there.
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtClaude}
		t.Skills = filepath.Join(a.Dir, "skills")
	case "codebuddy":
		// CodeBuddy Code's user-wide servers are in the first of
		// .mcp.json, mcp.json (in its folder) and .codebuddy.json (beside
		// it, or in $CODEBUDDY_CONFIG_DIR) that is there, else the first,
		// as it reads them and `codebuddy mcp add -s user` writes them
		// (PathUtils.resolveMcpFilePath, @tencent-ai/codebuddy-code
		// 2.162.0); mcpServers as Claude Code's, and no approval for a
		// user's server (isAllowed asks only of a project's). Its skills
		// are in skills/ in its folder (getHomeSkillsDir) (#1266).
		t.MCP = &mcpFile{Path: codebuddyMCP(a.Dir), Format: fmtClaude}
		t.Skills = filepath.Join(a.Dir, "skills")
		// Its user-wide instructions are CODEBUDDY.md in its folder, else
		// CODEBUDDY.mdc there (MemoryLoader.loadUserMemories, 2.164.0)
		t.Instructions = firstThere(a.Dir, "CODEBUDDY.md", "CODEBUDDY.mdc")
	case "hanako", "fx":
		// a skills folder in the agent's own: Hanako's $HANA_HOME, fx's
		// ~/.fx — each said by its docs or source. No MCP servers:
		// OpenHanako runs one only once switched on for each agent and
		// tool, and fx's mcp.json, which one entry it refuses makes it read
		// none of, isn't one magpie could try.
		t.Skills = filepath.Join(a.Dir, "skills")
		if a.ID == "fx" {
			// fx reads ~/.fx/AGENTS.md before a project's own
			// (src/builtins/context.zig, vercel-labs/fx c3b4b926)
			t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
		}
	case "prime-agent":
		// Prime Agent reads the first there is of AGENTS.md, AGENTS.MD,
		// CLAUDE.md and CLAUDE.MD in its agent folder
		// ($PRIME_AGENT_CODING_AGENT_DIR, else ~/.prime/agent)
		// (CONTEXT_FILE_CANDIDATES in crates/pa-core/src/resources/mod.rs,
		// prime-agent d592d5e7)
		t.Instructions = firstThere(a.Dir, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
	case "stepcode":
		// StepCode reads AGENTS.override.md in its agent folder
		// ($STEP_CODING_AGENT_DIR, else agent/ in its config folder) when
		// it is there, else the first there is of AGENTS.md, AGENTS.MD,
		// CLAUDE.md and CLAUDE.MD (resolveStepAgentDir in step/
		// environment.ts, loadContextFileFromDir in core/resource-loader.ts,
		// stepfun-ai/Step-Code 3ba89e0c)
		d := strings.TrimSpace(appdir.Getenv("STEP_CODING_AGENT_DIR"))
		if !filepath.IsAbs(d) {
			d = filepath.Join(a.Dir, "agent")
		}
		t.Instructions = firstThere(d, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
		t.Override = filepath.Join(d, "AGENTS.override.md")
	case "jcode":
		// jcode's own user-wide file is prompt-overlay.md in its folder
		// ($JCODE_HOME, else ~/.jcode), added to every conversation's
		// prompt; the AGENTS.md it also reads is the one in the home folder
		// itself, which isn't jcode's (load_prompt_overlay_files_from_dir in
		// crates/jcode-base/src/prompt.rs, jcode_dir in crates/jcode-storage,
		// 1jehuang/jcode 0d240f1d)
		t.Instructions = filepath.Join(a.Dir, "prompt-overlay.md")
	case "atomcode":
		// AtomCode reads ~/.atomcode/ATOMCODE.md before every conversation
		// (its ATOMCODE.md, beside AGENTS.md and CLAUDE.md), its MCP servers
		// from mcp.json in its folder (`atomcode mcp add --global`, the same
		// mcpServers as omp's) and its skills from skills/ there
		t.Instructions = filepath.Join(a.Dir, "ATOMCODE.md")
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtOmp}
		t.Skills = filepath.Join(a.Dir, "skills")
	case "qwen":
		// Qwen Code reads QWEN.md (and AGENTS.md) in its global folder,
		// $QWEN_HOME else ~/.qwen, before every conversation; its settings'
		// context.fileName renames them, the first name being the one it
		// writes itself (getGlobalQwenDir in packages/core/src/config/
		// storage.ts, getMemoryFilePaths in memory/memoryDiscovery.ts,
		// getCurrentMemoryFilename in utils/memory-constants.ts,
		// QwenLM/qwen-code c5098a27)
		t.Instructions = filepath.Join(a.Dir, contextFile(a.Path, "QWEN.md"))
	case "reasonix":
		// Reasonix reads every one there is of REASONIX.md, AGENTS.md and
		// CLAUDE.md in its state folder; REASONIX.md is its own
		// (DocumentNames in internal/state/instruction/resolver.go,
		// MemoryUserDir in internal/contract/config/paths.go, esengine/
		// DeepSeek-Reasonix d460758e)
		t.Instructions = filepath.Join(reasonixState(a), "REASONIX.md")
	case "zed":
		// Zed reads its MCP servers from context_servers in the settings.json
		// magpie sets its model in (~/.config/zed, $XDG_CONFIG_HOME/zed,
		// %APPDATA%\Zed or $MAGPIE_ZED_CONFIG_DIR: agent.zed), and reloads
		// the file as it changes (crates/settings_content/src/project.rs
		// ProjectSettingsContent.context_servers, zed-industries/zed
		// 2c99f547; lc on Discord)
		t.MCP = &mcpFile{Path: a.Path, Format: fmtZed}
	case "claude-desktop":
		// Claude Desktop reads only commands from its file: a remote server
		// is added in its own Connectors settings. In its 3p mode (magpie's
		// gateway, or any other) it reads the file in Claude-3p instead, so
		// where that folder is the servers go into both: each mode finds
		// them, a switch between the two leaves nothing behind in either
		t.MCP = &mcpFile{Path: filepath.Join(filepath.Dir(a.Path), "claude_desktop_config.json"), Format: fmtDesktop}
		for _, p := range agent.DesktopConfigs3p(h) {
			if p != t.MCP.Path && isDir(filepath.Dir(p)) {
				t.MCP.Also = append(t.MCP.Also, p)
			}
		}
		// Cowork's skills, in every account's skills-plugin (#638)
		if t.Desktop = desktopSkillRoots(a.Dir); len(t.Desktop) > 0 {
			t.Skills = filepath.Join(t.Desktop[0], "skills")
		}
	default:
		if a.Plugin != "" {
			return pluginTarget(a)
		}
		return nil
	}
	return t
}

// firstThere is the first of names in dir that is there, as an agent that
// reads only the first of them finds it; the first name when none is.
func firstThere(dir string, names ...string) string {
	for _, n := range names {
		if _, err := os.Stat(filepath.Join(dir, n)); err == nil {
			return filepath.Join(dir, n)
		}
	}
	return filepath.Join(dir, names[0])
}

// contextFile is the name of the file Qwen Code, or Qoder, reads its
// user-wide instructions from: the first of its settings' context.fileName,
// a name or a list of them, else def (Qwen's packages/cli/src/config/
// config.ts sets it with setMemoryFilename, which trims each name and skips
// an empty one).
func contextFile(settings, def string) string {
	raw, _ := os.ReadFile(settings)
	v := gjson.GetBytes(jsonc.ToJSON(raw), "context.fileName")
	names := []gjson.Result{v}
	if v.IsArray() {
		names = v.Array()
	}
	for _, n := range names {
		if name := strings.TrimSpace(n.String()); n.Type == gjson.String && name != "" {
			return name
		}
	}
	return def
}

// reasonixState is Reasonix's state folder: $REASONIX_STATE_HOME, else
// [storage] state in its config.toml, else its home (Roots.Dir in
// internal/contract/config/storage_roots.go, readStorageDirs in
// storage_config.go).
func reasonixState(a *agent.Agent) string {
	d := appdir.Getenv("REASONIX_STATE_HOME")
	if strings.TrimSpace(d) == "" {
		st, _ := edit.GetTOMLTable(a.Path, "storage")
		d = st["state"]
	}
	if d = strings.TrimSpace(os.ExpandEnv(d)); d == "" {
		return a.Dir
	}
	if d == "~" || strings.HasPrefix(d, "~/") || strings.HasPrefix(d, `~\`) {
		d = filepath.Join(home(), strings.TrimLeft(d[1:], `/\`))
	}
	if abs, err := filepath.Abs(d); err == nil {
		d = abs
	}
	return d
}

// pluginMCP is each MCP format an agent plugin may name
// (agentplug.MCPFormats), by name.
var pluginMCP = map[string]mcpFormat{
	"alma": fmtAlma, "antigravity": fmtAntigravity, "claude": fmtClaude,
	"cline": fmtCline, "codex": fmtCodex, "commandcode": fmtCommandCode,
	"copilot": fmtCopilot, "crush": fmtCrush, "cursor": fmtCursor,
	"devin": fmtDevin, "gemini": fmtGemini, "goose": fmtGoose, "grok": fmtGrok,
	"hermes": fmtHermes, "kimi": fmtKimi, "omp": fmtOmp, "opencode": fmtOpenCode,
	"zed": fmtZed,
}

// pluginTarget is where an agent a plugin adds reads the Library's three,
// as its agent.library says; nil when it names none. A path that isn't
// absolute once ~ and $VAR are expanded is left out: relative to what, no
// one knows.
func pluginTarget(a *agent.Agent) *Target {
	list, _ := agentplug.List()
	var l agentplug.Places
	for _, p := range list {
		if p.Spec == a.Plugin {
			l = p.Desc.Library
		}
	}
	at := func(p string) string {
		if p == "" {
			return ""
		}
		if p = agent.PluginPath(p); !filepath.IsAbs(p) {
			return ""
		}
		return p
	}
	t := &Target{Agent: a, Instructions: at(l.Instructions), Skills: at(l.Skills)}
	if f, ok := pluginMCP[l.MCPFormat]; ok && at(l.MCP) != "" {
		t.MCP = &mcpFile{Path: at(l.MCP), Format: f}
	}
	if t.Instructions == "" && t.MCP == nil && t.Skills == "" {
		return nil
	}
	return t
}

// wslTargetOf is where an agent in a WSL distro keeps them: its files at
// their defaults under the distro's $HOME (the distro's variables that
// move them aren't read), opened through \\wsl.localhost; nil while the
// distro is stopped, which opening them would start (asked again here: the
// agent may have been made before the user stopped it). What is written is
// the same as for this machine's agent: nothing in it names a place on
// Windows, and each skill is a copy.
func wslTargetOf(a *agent.Agent) *Target {
	h := a.Home
	if h == "" || !agent.WSLRunning(a.WSL) {
		return nil
	}
	t := &Target{Agent: a, Copy: true}
	id, _, _ := strings.Cut(a.ID, "@")
	switch id {
	case "claude":
		d := filepath.Join(h, ".claude")
		t.Instructions = filepath.Join(d, "CLAUDE.md")
		t.MCP = &mcpFile{Path: filepath.Join(h, ".claude.json"), Format: fmtClaude}
		t.Skills = filepath.Join(d, "skills")
		t.Settings = filepath.Join(d, "settings.json")
	case "codex":
		d := filepath.Join(h, ".codex")
		t.Instructions = filepath.Join(d, "AGENTS.md")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "config.toml"), Format: fmtCodex}
		t.Skills = filepath.Join(d, "skills")
	case "pi":
		// its MCP servers go where the Pi installed there reads them, as on
		// this machine (piMCP): its version is what the distro's pi said
		// at the probe, and its extensions are those its settings.json and
		// the distro's npm folders have (leokon on Discord: only the
		// Windows Pi was offered MCP servers)
		d := filepath.Join(h, ".pi", "agent")
		t.Instructions = firstThere(d, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		t.MCP, t.MCPVia = piMCP(h, d, piVersion(a), wslPiRoots(h))
		t.Skills = filepath.Join(d, "skills")
	case "omo":
		d := filepath.Join(h, ".omo", "agent")
		t.Instructions = firstThere(d, "AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD")
		t.Override = filepath.Join(d, "AGENTS.override.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp.json"), Format: fmtPiNative}
		t.Skills = filepath.Join(d, "skills")
	case "gemini":
		// as targetOf's, under the distro's home
		d := filepath.Join(h, ".gemini")
		t.Instructions = filepath.Join(d, "GEMINI.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "settings.json"), Format: fmtGemini}
		t.Skills = filepath.Join(d, "skills")
	case "agy":
		d := filepath.Join(h, ".gemini", "config")
		t.Instructions = filepath.Join(d, "GEMINI.md")
		t.MCP = &mcpFile{Path: filepath.Join(d, "mcp_config.json"), Format: fmtAntigravity}
		t.Skills = filepath.Join(d, "skills")
	case "crush":
		// its crush.json is the distro's ~/.config/crush's (agent.crushIn),
		// CRUSH.md and skills beside it
		d := filepath.Dir(a.Path)
		t.Instructions = filepath.Join(d, "CRUSH.md")
		t.MCP = &mcpFile{Path: a.Path, Format: fmtCrush}
		t.Skills = filepath.Join(d, "skills")
		t.SkillsAlso = []string{"claude@" + strings.SplitN(a.ID, "@", 2)[1]}
	case "cline":
		// beside its providers.json; the distro's CLINE_MCP_SETTINGS_PATH
		// isn't read
		t.MCP = &mcpFile{Path: filepath.Join(filepath.Dir(a.Path), "cline_mcp_settings.json"), Format: fmtCline}
		t.Skills = filepath.Join(a.Dir, "skills")
	case "codebuddy":
		t.MCP = &mcpFile{Path: codebuddyMCPIn(a.Dir, h), Format: fmtClaude}
		t.Skills = filepath.Join(a.Dir, "skills")
		t.Instructions = firstThere(a.Dir, "CODEBUDDY.md", "CODEBUDDY.mdc")
	case "kimi":
		// its folder is the distro's (agent.kimiDir); the new Kimi Code's
		// AGENTS.md is in it. The skills it shares with other agents (the
		// distro's ~/.agents/skills) aren't given here
		t.MCP = &mcpFile{Path: filepath.Join(a.Dir, "mcp.json"), Format: fmtKimi}
		if filepath.Base(a.Dir) == ".kimi-code" {
			t.Instructions = filepath.Join(a.Dir, "AGENTS.md")
		}
	case "goose":
		// its config.yaml is the distro's ~/.config/goose's; the skills it
		// reads first are the distro's ~/.agents/skills, which aren't
		// given here
		t.Instructions = filepath.Join(filepath.Dir(a.Path), ".goosehints")
		t.MCP = &mcpFile{Path: a.Path, Format: fmtGoose}
	default:
		return wslOwnFolder(a)
	}
	if t.MCP != nil {
		// a Windows program isn't given to it (mcpFile.side)
		t.MCP.WSL, t.MCP.Distro, t.MCP.Home = true, a.WSL, linuxHome(h)
	}
	return t
}

// ownFolder are the agents that keep all the library gives them in their
// own folder (a.Dir, or beside a.Path), read from no variable of this
// machine's and from nothing under its home: one magpie found in a distro
// has that folder at the distro's home already, so its target there is
// the one targetOf makes on this machine, given copies (#1323).
var ownFolder = map[string]bool{
	"hermes": true, "omp": true, "opencode": true, "mimocode": true, "droid": true,
	"grok": true, "commandcode": true, "atomcode": true, "qoder": true, "qoder-cn": true,
	"minimax-code": true, "fx": true, "dsh": true, "qwen": true,
}

// wslOwnFolder is the target of a, an agent in a running WSL distro that
// keeps everything in its own folder; nil for any other.
func wslOwnFolder(a *agent.Agent) *Target {
	id, at, _ := strings.Cut(a.ID, "@")
	if !ownFolder[id] {
		return nil
	}
	local := *a
	local.ID, local.WSL = id, ""
	t := targetOf(&local)
	if t == nil {
		return nil
	}
	t.Agent, t.Copy = a, true
	if t.MCP != nil {
		t.MCP.WSL, t.MCP.Distro, t.MCP.Home = true, a.WSL, linuxHome(a.Home)
	}
	// the skills it reads besides its own are those agents' in the same
	// distro, not this machine's
	for i, o := range t.SkillsAlso {
		t.SkillsAlso[i] = o + "@" + at
	}
	return t
}

// apps are what the library can give MCP servers to that aren't agents
// magpie sets up: known by the folder they keep their settings in.
func apps() []*agent.Agent {
	// Desktop's own folder (%APPDATA%\Claude on Windows, the MSIX
	// package's for a packaged Desktop, which doesn't see a file written
	// into %APPDATA%). Desktop only ever run in its 3p mode has no Claude
	// folder, only Claude-3p: its file is the one there
	d := desktopdir.Here()
	dir := d.Data
	if !isDir(dir) && isDir(d.ThreeP) {
		dir = d.ThreeP
	}
	return []*agent.Agent{
		{ID: "claude-desktop", Name: "Claude Desktop", Icon: "claude-color", Dir: dir, Path: filepath.Join(dir, "claude_desktop_config.json")},
	}
}

// Targets are the agents on this machine that magpie can give any of the
// three to, in the order the rest of magpie lists them.
func Targets() []*Target { return targets(false) }

// everyTarget is Targets with the agents gone for their CLI too: a folder
// an uninstall left behind is still that agent's own, which a project or
// an instruction set is never kept in.
func everyTarget() []*Target { return targets(true) }

func targets(gone bool) []*Target {
	out, _ := targetsAsleep(gone)
	return out
}

// targetsAsleep is targets, and the agents in WSL distros that aren't
// running now: none is a target, as its files can't be opened without
// starting the distro, but the page lists them (asleepView). Each running
// one's places are kept for when it is stopped (keepShape).
func targetsAsleep(gone bool) ([]*Target, []*agent.Agent) {
	var out []*Target
	var asleep []*agent.Agent
	own := map[string]bool{}
	for _, a := range apps() {
		own[a.ID] = true
	}
	for _, a := range agent.All() {
		// the agents here, and a folder an agent shares with its vendor's
		// other app when only that app is here: the Cursor editor reads
		// ~/.cursor's mcp.json and skills with no cursor-agent installed
		if !a.Detected() && !a.SharedHere() {
			continue
		}
		// an app magpie also sets up as an agent (Claude Desktop) keeps its
		// MCP servers where apps says, once
		if own[a.ID] {
			continue
		}
		// an uninstall that left the folder behind (#2177, #2173): the
		// Agents page calls the agent gone and offers none of its settings,
		// since nothing reads them; the library gives nothing to it either
		if !gone && a.CLIMissing() {
			continue
		}
		if isAsleep(a) {
			asleep = append(asleep, a)
			noteUp(a.WSL, false)
			continue
		}
		if t := targetOf(a); t != nil && t.open() {
			out = append(out, t)
		}
	}
	for _, a := range apps() {
		if !a.Detected() && !a.SharedHere() {
			continue
		}
		if t := targetOf(a); t != nil && t.open() {
			out = append(out, t)
		}
	}
	readsWith(out)
	for _, t := range out {
		if t.Agent.WSL != "" {
			keepShape(t)
		}
	}
	return out, asleep
}

// held are the agents not among have (Targets) — uninstalled, or gone for
// their CLI — that the library still gives something, or that hold a skill,
// server or hook magpie put there: each is listed on the rows of what it
// has, for that to be unticked and taken out of it, and on no other row
// (@jiahao_jayden on X: an agent that isn't installed was on every row). A
// sync gives them nothing new (Gone).
func (l *Library) held(have []*Target) []*Target {
	in := map[string]bool{}
	for _, t := range have {
		in[t.Agent.ID] = true
	}
	has := func(id string) bool {
		if a := l.Applied[id]; a != nil && (len(a.Skills) > 0 || len(a.MCP) > 0 || len(a.Hooks) > 0) {
			return true
		}
		return slices.ContainsFunc(l.Skills, func(s *Skill) bool { return s.gives(id) }) ||
			slices.ContainsFunc(l.MCP, func(s *Server) bool { return slices.Contains(s.Agents, id) }) ||
			slices.ContainsFunc(l.Hooks, func(h *Hook) bool { return slices.Contains(h.Agents, id) })
	}
	var out []*Target
	for _, a := range append(apps(), agent.All()...) {
		if in[a.ID] || a.WSL != "" || !has(a.ID) {
			continue
		}
		in[a.ID] = true
		if t := targetOf(a); t != nil && t.open() {
			t.Gone = true
			out = append(out, t)
		}
	}
	return out
}

// readsShared are the agents that read ~/.agents/skills as well as their
// own folder (each one's docs or source).
var readsShared = []string{"codex", "gemini", "opencode", "deveco", "crush", "dsh", "commandcode", "devin", "droid", "cline", "grok", "grok-app", "fx", "alma"}

// readsWith adds to each agent's SkillsAlso the agents whose folder it
// reads skills from too: one that is the very same folder (Kimi Code's,
// Goose's and Cindy's, all ~/.agents/skills), or ~/.agents/skills for one
// that reads it besides its own — a skill magpie gives there once, for
// any of them, every one of them has.
func readsWith(ts []*Target) {
	real := make([]string, len(ts))
	for i, t := range ts {
		if t.Skills != "" {
			real[i] = realDir(t.Skills)
		}
	}
	shared := realDir(sharedSkillsDir())
	for i, t := range ts {
		for j, o := range ts {
			if i == j || real[i] == "" || real[j] == "" || slices.Contains(t.SkillsAlso, o.Agent.ID) {
				continue
			}
			if real[j] == real[i] || real[j] == shared && slices.Contains(readsShared, t.Agent.ID) {
				t.SkillsAlso = append(t.SkillsAlso, o.Agent.ID)
			}
		}
	}
}

// open leaves out of the target each place a file stands where a folder
// of it would be — another tool's ~/.dsh or ~/.gemini: nothing can be
// written there, and the agent isn't reading anything from it — and says
// whether any place is left.
func (t *Target) open() bool {
	if t.Instructions != "" && agent.Taken(filepath.Dir(t.Instructions)) {
		t.Instructions, t.Override, t.Note, t.Profile = "", "", "", false
	}
	if t.MCP != nil && slices.ContainsFunc(t.MCP.files(), func(p string) bool { return agent.Taken(filepath.Dir(p)) }) {
		t.MCP, t.MCPVia = nil, ""
	}
	if t.Skills != "" && agent.Taken(t.Skills) {
		t.Skills, t.SkillsAlso = "", nil
	}
	return t.Instructions != "" || t.MCP != nil || t.Skills != ""
}

func targetByID(id string) *Target {
	for _, t := range Targets() {
		if t.Agent.ID == id {
			return t
		}
	}
	return nil
}

// Takes is the id of the agent q names (its id, an alias, its name) when
// the library can give it kind — "instructions", "mcp" or "skills" — or
// why not: an agent it has no place for isn't recorded as getting it and
// then given nothing.
func Takes(q, kind string) (string, error) {
	var a *agent.Agent
	for _, app := range apps() {
		if strings.EqualFold(app.ID, q) || strings.EqualFold(app.Name, q) {
			a = app
		}
	}
	if a == nil {
		var err error
		if a, err = agent.Find(q); err != nil {
			return "", err
		}
	}
	what := map[string]string{"instructions": "instructions", "mcp": "MCP servers", "skills": "skills"}[kind]
	// gone for its CLI, as Targets leaves it out (#2254): told so, not
	// recorded and then given nothing ("every agent already has it")
	if a.CLIMissing() {
		return "", fmt.Errorf("%s's CLI isn't installed here; nothing reads its %s until it is installed again%s", a.Name, what, takenBy(kind, what))
	}
	t := targetOf(a)
	var has bool
	if t == nil && isAsleep(a) {
		// one magpie saw it give MCP servers or skills a place to is
		// recorded, and given them when the distro next runs (Woken)
		if sh := shapeOf(a); sh != nil && (kind == "mcp" && sh.MCP != "" || kind == "skills" && sh.Skills != "") {
			return a.ID, nil
		}
		return "", fmt.Errorf("WSL %s isn't running: start it, and %s can be given %s", a.WSL, a.Name, what)
	}
	if t != nil {
		switch kind {
		case "instructions":
			has = t.Instructions != ""
		case "mcp":
			has = t.MCP != nil
		case "skills":
			has = t.Skills != ""
		}
	}
	if !has {
		return "", fmt.Errorf("%s%s", noPlace(a, kind, what), takenBy(kind, what))
	}
	return a.ID, nil
}

// noPlace says why an agent can't be given kind, and where it gets it
// instead when another agent's files are what it reads (MOMO on Discord).
func noPlace(a *agent.Agent, kind, what string) string {
	switch {
	case a.ID == "openchamber":
		// OpenChamber's server reads the global AGENTS.md, skills folder
		// and opencode.json from OpenCode's config folder
		// (packages/web/server/lib/opencode/shared.js), and the OpenCode it
		// runs reads them there too
		return fmt.Sprintf("OpenChamber has no place of its own for %s: it runs OpenCode on OpenCode's config, so it has what OpenCode is given · give them to opencode", what)
	case a.ID == "claude-desktop" && kind == "instructions":
		// Desktop's chat takes its instructions in its own settings, kept
		// with the Claude account, not in a file; its Code tab is Claude
		// Code, which reads Claude Code's CLAUDE.md
		return "Claude Desktop keeps its instructions in its own settings, with your Claude account, not in a file magpie can write; its Code tab runs Claude Code, which reads Claude Code's · give them to claude"
	case a.Plugin != "":
		return fmt.Sprintf("%s's plugin (%s) says no place for %s: its agent.library.%s names none", a.Name, plugin.Name(a.Plugin), what, kind)
	}
	return fmt.Sprintf("%s has no user-wide place for %s that magpie knows of", a.Name, what)
}

// takenBy lists the agents here that kind can be given to.
func takenBy(kind, what string) string {
	var ids []string
	for _, t := range Targets() {
		if kind == "instructions" && t.Instructions != "" || kind == "mcp" && t.MCP != nil || kind == "skills" && t.Skills != "" {
			ids = append(ids, t.Agent.ID)
		}
	}
	if len(ids) == 0 {
		return ""
	}
	return "\n  agents here that take " + what + ": " + strings.Join(ids, ", ")
}