agent-guild 1.2.0__tar.gz → 1.3.0__tar.gz

{agent_guild-1.2.0 → agent_guild-1.3.0}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-10-22
+
+- Cursor and Codex support. The installer detects the tools a project uses (`.claude/` or `CLAUDE.md`, `.cursor/`,
+  `.codex/` or `.agents/`; Claude Code when none) and installs for each one, or for `--tools claude,cursor,codex`.
+  Agents are written in each tool's format (Cursor `readonly`, Codex TOML), skills go to `.cursor/skills/` and
+  `.codex/skills/`, and the jevmem and language-coder MCP servers to `.cursor/mcp.json` and `.codex/config.toml`.
+  Hooks, auto-memory and the model setting stay Claude Code only.
+- The rules sections now go to `AGENTS.md` (created if missing; `CLAUDE.md` only when it is the sole file). With Claude
+  Code, `CLAUDE.md` gets an `@AGENTS.md` import.
+
+## [1.2.1] - 2026-10-22
+
+- The install log says `skipped ... section '<name>' is already in CLAUDE.md or AGENTS.md` instead of the confusing
+  `unchanged`, notes when `.claude/skills` is a symlink and where skills are written, and ends with a hint to merge
+  skipped files that differ by hand.
+- README: a section on adding agent-guild to a project that already has its own agents, skills and rules.
+
 ## [1.2.0] - 2026-10-22
 
 - Follow the updated sdd-feature skill: Phase 0 has a UI track (wireframe) and a system track (`DESIGN.md` with Mermaid

agent_guild-1.2.0/README.md → agent_guild-1.3.0/PKG-INFO

@@ -1,9 +1,29 @@
+Metadata-Version: 2.5
+Name: agent-guild
+Version: 1.3.0
+Summary: A multi-agent setup for Claude Code, Cursor and Codex (orchestrator + architect, coder, grader, utility subagents) with memory-bank, jevmem and Spec-Driven Development wired in, installed into a project with one command.
+Project-URL: Homepage, https://github.com/illescasDaniel/agent-guild
+Project-URL: Issues, https://github.com/illescasDaniel/agent-guild/issues
+Author-email: Daniel Illescas Romero <illescas.daniel@protonmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude,claude-code,codex,cursor,memory,multi-agent,orchestrator,sdd,spec-driven-development,subagents
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
 # agent-guild
 
 [![PyPI](https://img.shields.io/pypi/v/agent-guild)](https://pypi.org/project/agent-guild/)
 
-A ready-made **multi-agent setup for [Claude Code](https://claude.com/claude-code)**, installed into a project with one
-command. A Sonnet **orchestrator** delegates to specialist subagents (Opus architect and grader, Sonnet coders, Haiku
+A ready-made **multi-agent setup for [Claude Code](https://claude.com/claude-code), [Cursor](https://cursor.com) and
+[Codex](https://developers.openai.com/codex)**, installed into a project with one command. (The Sonnet/Opus/Haiku
+tiering below is Claude Code's; Cursor and Codex agents inherit the session model.) A Sonnet **orchestrator** delegates to specialist subagents (Opus architect and grader, Sonnet coders, Haiku
 utility), and three features come wired in:
 
 - **Multiple agents**: `architect`, `coder` (parallel-safe), `code-grader` and `utility`, plus the orchestrator rules
@@ -38,7 +58,7 @@ uvx agent-guild /path/to/project
 
 ## Files
 
-| File | Install to | Role |
+| File | Install to (Claude Code) | Role |
 |---|---|---|
 | [development-workflow.md](development-workflow.md) | imported from `~/.claude/CLAUDE.md` | Orchestrator rules: knowledge layers, routing, SDD phase → agent map, briefs, memory protocol |
 | [agents/architect.md](agents/architect.md) | `~/.claude/agents/` | Opus, read-only. Plans, SDD Phase 1 design decisions, Phase 2 interfaces, root causes |
@@ -46,6 +66,8 @@ uvx agent-guild /path/to/project
 | [agents/code-grader.md](agents/code-grader.md) | `~/.claude/agents/` | Opus, read-only. SDD Phase 5. Body identical to the sdd-feature skill's grader; only the frontmatter differs |
 | [agents/utility.md](agents/utility.md) | `~/.claude/agents/` | Haiku. Checks, git, moves, bulk edits |
 
+These are the Claude Code sources; the installer converts them for Cursor and Codex.
+
 ## Install
 
 ### Quick: the installer (per project)
@@ -61,26 +83,37 @@ uvx agent-guild /path/to/project --dry-run
 uvx agent-guild /path/to/project
 ```
 
-It does, in the project:
-
-- copies `agents/*.md` and `development-workflow.md` into `.claude/`;
-- copies the `memory-bank`, `jev-memory` and `sdd-feature` skills into `.claude/skills/` (cloned from GitHub, or from
-  local clones with `--sources-dir DIR`);
-- adds three removable sections to `CLAUDE.md`: *Agents and delegation*, *Memory bank* and *Phase Gate Protocol*. They
-  live in `CLAUDE.md`, not `AGENTS.md`, because they are rules for Claude Code and its subagents; `AGENTS.md` stays
-  tool-neutral. If the project has an `AGENTS.md`, `CLAUDE.md` starts with `@AGENTS.md`. A section that `CLAUDE.md` or
-  `AGENTS.md` already has is not added again;
-- adds the pinned jevmem server to `.mcp.json` and the jevmem hooks to `.claude/settings.json`, merging into existing
-  files;
-- sets `autoMemoryEnabled: false` and the project's model to `sonnet`.
+It does, in the project, for each coding tool it finds (see **Tools** below):
+
+- copies the agents in that tool's format and folder (`.claude/agents/*.md`; `.cursor/agents/*.md` with `readonly`
+  instead of `disallowedTools`; `.codex/agents/*.toml`), and one shared `development-workflow.md` next to the first
+  tool's agents;
+- copies the `memory-bank`, `jev-memory` and `sdd-feature` skills into that tool's skills folder (`.claude/skills/`,
+  `.cursor/skills/`, `.codex/skills/` for Codex), cloned from GitHub, or from local clones with `--sources-dir DIR`;
+- adds three removable sections to `AGENTS.md`: *Agents and delegation*, *Memory bank* and *Phase Gate Protocol*. If the
+  project has only a `CLAUDE.md`, they go there instead; with neither, `AGENTS.md` is created. When Claude Code is one
+  of the tools, `CLAUDE.md` gets an `@AGENTS.md` import (Claude Code doesn't read `AGENTS.md`). A section that either
+  file already has is not added again;
+- adds the pinned jevmem server to the tool's MCP config (`.mcp.json`, `.cursor/mcp.json`, `.codex/config.toml`),
+  merging into existing files;
+- for Claude Code only: adds the jevmem hooks to `.claude/settings.json`, sets `autoMemoryEnabled: false` and the
+  project's model to `sonnet`.
+
+**Tools.** The installer detects what the project uses: `.claude/` or `CLAUDE.md` → Claude Code, `.cursor/` → Cursor,
+`.codex/` or `.agents/` → Codex; with several, it installs for all of them, and with none, for Claude Code. Override
+with `--tools claude,cursor,codex`. Cursor and Codex agents don't carry the Claude model tiering (Cursor gets
+`model: inherit`, Codex inherits the session model) and Codex has no read-only switch for an agent, so the read-only
+agents say it in their instructions. Cursor also reads `.claude/` and `.agents/` folders, so with several tools
+installed it may list a skill twice.
 
 | Flag | Effect |
 |---|---|
-| `--with coder-python` / `coder-swift` / `coder-typescript` | Add a language coder (repeatable): the generic coder, required to use that language's code-navigation MCP ([codenav-mcp](https://github.com/illescasDaniel/codenav-mcp), [codenav-swift-mcp](https://github.com/illescasDaniel/codenav-swift-mcp), [webnav-ts-mcp](https://github.com/illescasDaniel/webnav-ts-mcp)). Also adds the MCP server to `.mcp.json` (an existing entry is kept) and a `CLAUDE.md` rule that routes that language's work to it. The MCP's own prerequisites (uv, a Swift toolchain, Node) are printed after the install |
-| `--coders-only` | With `--with`: install only the language coders (agent, MCP server, `CLAUDE.md` rule) and nothing else. After a normal install, the tool detects Python, Swift and TypeScript/JS projects and prints this command for the coders you don't have yet |
+| `--tools claude,cursor,codex` | Install for these tools instead of the detected ones |
+| `--with coder-python` / `coder-swift` / `coder-typescript` | Add a language coder (repeatable): the generic coder, required to use that language's code-navigation MCP ([codenav-mcp](https://github.com/illescasDaniel/codenav-mcp), [codenav-swift-mcp](https://github.com/illescasDaniel/codenav-swift-mcp), [webnav-ts-mcp](https://github.com/illescasDaniel/webnav-ts-mcp)). Also adds the MCP server to `.mcp.json` (an existing entry is kept) and an `AGENTS.md` rule that routes that language's work to it. The MCP's own prerequisites (uv, a Swift toolchain, Node) are printed after the install |
+| `--coders-only` | With `--with`: install only the language coders (agent, MCP server, `AGENTS.md` rule) and nothing else. After a normal install, the tool detects Python, Swift and TypeScript/JS projects and prints this command for the coders you don't have yet |
 | `--without sdd` / `memory-bank` / `jevmem` | Leave a component out. `sdd` also drops `code-grader` and the gate section; `jevmem` drops its skill, server, hooks and the auto-memory switch |
 | `--model ALIAS` | Project main-session model; default `sonnet` (the per-project alternative to the global setting below), `none` leaves it unset |
-| `--import-cursor-skills` | Also copy the project's `.cursor/skills/*` into `.claude/skills/`; skills that already exist are kept |
+| `--import-cursor-skills` | Also copy the project's `.cursor/skills/*` into `.claude/skills/` (needs `claude` among the tools); skills that already exist are kept |
 | `--personal-settings` | Put `--model` and `autoMemoryEnabled` in the git-ignored `.claude/settings.local.json` |
 | `--import-auto-memory` | First import the project's existing auto-memory notes into jevmem |
 | `--keep-auto-memory` | Don't switch auto-memory off |
@@ -104,6 +137,24 @@ uv run agent-guild /path/to/project --dry-run
 From a checkout, the CLI reads `agents/`, `templates/` and `development-workflow.md` at the repo root; the published
 wheel bundles them.
 
+## Adding it to a project that already has its own setup
+
+The installer never overwrites a file that differs from the shipped one (and skips rules sections that `AGENTS.md`
+or `CLAUDE.md` already has), so it is safe to run on a project with its own agents, skills and rules. After it runs:
+
+- **Skipped files are yours.** Anything the log marks `skipped ... differs` keeps your version. If it is an older or
+  customised copy of a shipped one (the `sdd-feature` skill, `code-grader`, `jev-memory`), diff it against the shipped
+  file and merge what you want by hand. `--force` replaces it instead.
+- **New files can land next to yours.** A skill folder you already have keeps its `SKILL.md`, but the shipped files
+  that are missing (templates, scripts) are added beside it. If `.claude/skills` is a symlink to `.cursor/skills`, the
+  log says so, and the skills are written there.
+- **Cursor reads `.claude/agents/` too.** The agents installed here work in Cursor without copies in `.cursor/agents/`
+  (`.cursor/agents/` wins on a name clash). Cursor ignores `tools`, `disallowedTools` and `effort`, so the read-only
+  agents are not read-only there. If your project has a test that requires every `.claude/agents/*.md` to have a
+  `.cursor/agents/` twin, relax it to require the twin only for the Cursor agents.
+- **Skip what you already have** with `--without memory-bank` / `jevmem` / `sdd`, for example when your own memory-bank
+  skill has a different name.
+
 ## Design choices
 
 - **The orchestrator is the only writer of memory.** Parallel coders writing `memory/` would conflict, and someone has
@@ -120,7 +171,7 @@ wheel bundles them.
   navigation MCPs; in practice it still reached for `grep` and `sed`, because the MCP tools arrive deferred (name
   only) and the brief or its own habits point elsewhere. `coder-python`, `coder-swift` and `coder-typescript`
   (`--with`) are generated from `coder.md` plus a navigation section that names the MCP's tools, and list those tools
-  in `tools:` so they load up front. A `CLAUDE.md` rule routes that language's work to them. Without `--with`, nothing
+  in `tools:` so they load up front. An `AGENTS.md` rule routes that language's work to them. Without `--with`, nothing
   changes.
 - **The grader runs on Opus.** The code it grades was written by Sonnet coders, so a different, stronger model gives
   a more independent review.

agent_guild-1.2.0/PKG-INFO → agent_guild-1.3.0/README.md

@@ -1,28 +1,10 @@
-Metadata-Version: 2.5
-Name: agent-guild
-Version: 1.2.0
-Summary: A multi-agent setup for Claude Code (orchestrator + architect, coder, grader, utility subagents) with memory-bank, jevmem and Spec-Driven Development wired in, installed into a project with one command.
-Project-URL: Homepage, https://github.com/illescasDaniel/agent-guild
-Project-URL: Issues, https://github.com/illescasDaniel/agent-guild/issues
-Author-email: Daniel Illescas Romero <illescas.daniel@protonmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: claude,claude-code,memory,multi-agent,orchestrator,sdd,spec-driven-development,subagents
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Software Development
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
 # agent-guild
 
 [![PyPI](https://img.shields.io/pypi/v/agent-guild)](https://pypi.org/project/agent-guild/)
 
-A ready-made **multi-agent setup for [Claude Code](https://claude.com/claude-code)**, installed into a project with one
-command. A Sonnet **orchestrator** delegates to specialist subagents (Opus architect and grader, Sonnet coders, Haiku
+A ready-made **multi-agent setup for [Claude Code](https://claude.com/claude-code), [Cursor](https://cursor.com) and
+[Codex](https://developers.openai.com/codex)**, installed into a project with one command. (The Sonnet/Opus/Haiku
+tiering below is Claude Code's; Cursor and Codex agents inherit the session model.) A Sonnet **orchestrator** delegates to specialist subagents (Opus architect and grader, Sonnet coders, Haiku
 utility), and three features come wired in:
 
 - **Multiple agents**: `architect`, `coder` (parallel-safe), `code-grader` and `utility`, plus the orchestrator rules
@@ -57,7 +39,7 @@ uvx agent-guild /path/to/project
 
 ## Files
 
-| File | Install to | Role |
+| File | Install to (Claude Code) | Role |
 |---|---|---|
 | [development-workflow.md](development-workflow.md) | imported from `~/.claude/CLAUDE.md` | Orchestrator rules: knowledge layers, routing, SDD phase → agent map, briefs, memory protocol |
 | [agents/architect.md](agents/architect.md) | `~/.claude/agents/` | Opus, read-only. Plans, SDD Phase 1 design decisions, Phase 2 interfaces, root causes |
@@ -65,6 +47,8 @@ uvx agent-guild /path/to/project
 | [agents/code-grader.md](agents/code-grader.md) | `~/.claude/agents/` | Opus, read-only. SDD Phase 5. Body identical to the sdd-feature skill's grader; only the frontmatter differs |
 | [agents/utility.md](agents/utility.md) | `~/.claude/agents/` | Haiku. Checks, git, moves, bulk edits |
 
+These are the Claude Code sources; the installer converts them for Cursor and Codex.
+
 ## Install
 
 ### Quick: the installer (per project)
@@ -80,26 +64,37 @@ uvx agent-guild /path/to/project --dry-run
 uvx agent-guild /path/to/project
 ```
 
-It does, in the project:
-
-- copies `agents/*.md` and `development-workflow.md` into `.claude/`;
-- copies the `memory-bank`, `jev-memory` and `sdd-feature` skills into `.claude/skills/` (cloned from GitHub, or from
-  local clones with `--sources-dir DIR`);
-- adds three removable sections to `CLAUDE.md`: *Agents and delegation*, *Memory bank* and *Phase Gate Protocol*. They
-  live in `CLAUDE.md`, not `AGENTS.md`, because they are rules for Claude Code and its subagents; `AGENTS.md` stays
-  tool-neutral. If the project has an `AGENTS.md`, `CLAUDE.md` starts with `@AGENTS.md`. A section that `CLAUDE.md` or
-  `AGENTS.md` already has is not added again;
-- adds the pinned jevmem server to `.mcp.json` and the jevmem hooks to `.claude/settings.json`, merging into existing
-  files;
-- sets `autoMemoryEnabled: false` and the project's model to `sonnet`.
+It does, in the project, for each coding tool it finds (see **Tools** below):
+
+- copies the agents in that tool's format and folder (`.claude/agents/*.md`; `.cursor/agents/*.md` with `readonly`
+  instead of `disallowedTools`; `.codex/agents/*.toml`), and one shared `development-workflow.md` next to the first
+  tool's agents;
+- copies the `memory-bank`, `jev-memory` and `sdd-feature` skills into that tool's skills folder (`.claude/skills/`,
+  `.cursor/skills/`, `.codex/skills/` for Codex), cloned from GitHub, or from local clones with `--sources-dir DIR`;
+- adds three removable sections to `AGENTS.md`: *Agents and delegation*, *Memory bank* and *Phase Gate Protocol*. If the
+  project has only a `CLAUDE.md`, they go there instead; with neither, `AGENTS.md` is created. When Claude Code is one
+  of the tools, `CLAUDE.md` gets an `@AGENTS.md` import (Claude Code doesn't read `AGENTS.md`). A section that either
+  file already has is not added again;
+- adds the pinned jevmem server to the tool's MCP config (`.mcp.json`, `.cursor/mcp.json`, `.codex/config.toml`),
+  merging into existing files;
+- for Claude Code only: adds the jevmem hooks to `.claude/settings.json`, sets `autoMemoryEnabled: false` and the
+  project's model to `sonnet`.
+
+**Tools.** The installer detects what the project uses: `.claude/` or `CLAUDE.md` → Claude Code, `.cursor/` → Cursor,
+`.codex/` or `.agents/` → Codex; with several, it installs for all of them, and with none, for Claude Code. Override
+with `--tools claude,cursor,codex`. Cursor and Codex agents don't carry the Claude model tiering (Cursor gets
+`model: inherit`, Codex inherits the session model) and Codex has no read-only switch for an agent, so the read-only
+agents say it in their instructions. Cursor also reads `.claude/` and `.agents/` folders, so with several tools
+installed it may list a skill twice.
 
 | Flag | Effect |
 |---|---|
-| `--with coder-python` / `coder-swift` / `coder-typescript` | Add a language coder (repeatable): the generic coder, required to use that language's code-navigation MCP ([codenav-mcp](https://github.com/illescasDaniel/codenav-mcp), [codenav-swift-mcp](https://github.com/illescasDaniel/codenav-swift-mcp), [webnav-ts-mcp](https://github.com/illescasDaniel/webnav-ts-mcp)). Also adds the MCP server to `.mcp.json` (an existing entry is kept) and a `CLAUDE.md` rule that routes that language's work to it. The MCP's own prerequisites (uv, a Swift toolchain, Node) are printed after the install |
-| `--coders-only` | With `--with`: install only the language coders (agent, MCP server, `CLAUDE.md` rule) and nothing else. After a normal install, the tool detects Python, Swift and TypeScript/JS projects and prints this command for the coders you don't have yet |
+| `--tools claude,cursor,codex` | Install for these tools instead of the detected ones |
+| `--with coder-python` / `coder-swift` / `coder-typescript` | Add a language coder (repeatable): the generic coder, required to use that language's code-navigation MCP ([codenav-mcp](https://github.com/illescasDaniel/codenav-mcp), [codenav-swift-mcp](https://github.com/illescasDaniel/codenav-swift-mcp), [webnav-ts-mcp](https://github.com/illescasDaniel/webnav-ts-mcp)). Also adds the MCP server to `.mcp.json` (an existing entry is kept) and an `AGENTS.md` rule that routes that language's work to it. The MCP's own prerequisites (uv, a Swift toolchain, Node) are printed after the install |
+| `--coders-only` | With `--with`: install only the language coders (agent, MCP server, `AGENTS.md` rule) and nothing else. After a normal install, the tool detects Python, Swift and TypeScript/JS projects and prints this command for the coders you don't have yet |
 | `--without sdd` / `memory-bank` / `jevmem` | Leave a component out. `sdd` also drops `code-grader` and the gate section; `jevmem` drops its skill, server, hooks and the auto-memory switch |
 | `--model ALIAS` | Project main-session model; default `sonnet` (the per-project alternative to the global setting below), `none` leaves it unset |
-| `--import-cursor-skills` | Also copy the project's `.cursor/skills/*` into `.claude/skills/`; skills that already exist are kept |
+| `--import-cursor-skills` | Also copy the project's `.cursor/skills/*` into `.claude/skills/` (needs `claude` among the tools); skills that already exist are kept |
 | `--personal-settings` | Put `--model` and `autoMemoryEnabled` in the git-ignored `.claude/settings.local.json` |
 | `--import-auto-memory` | First import the project's existing auto-memory notes into jevmem |
 | `--keep-auto-memory` | Don't switch auto-memory off |
@@ -123,6 +118,24 @@ uv run agent-guild /path/to/project --dry-run
 From a checkout, the CLI reads `agents/`, `templates/` and `development-workflow.md` at the repo root; the published
 wheel bundles them.
 
+## Adding it to a project that already has its own setup
+
+The installer never overwrites a file that differs from the shipped one (and skips rules sections that `AGENTS.md`
+or `CLAUDE.md` already has), so it is safe to run on a project with its own agents, skills and rules. After it runs:
+
+- **Skipped files are yours.** Anything the log marks `skipped ... differs` keeps your version. If it is an older or
+  customised copy of a shipped one (the `sdd-feature` skill, `code-grader`, `jev-memory`), diff it against the shipped
+  file and merge what you want by hand. `--force` replaces it instead.
+- **New files can land next to yours.** A skill folder you already have keeps its `SKILL.md`, but the shipped files
+  that are missing (templates, scripts) are added beside it. If `.claude/skills` is a symlink to `.cursor/skills`, the
+  log says so, and the skills are written there.
+- **Cursor reads `.claude/agents/` too.** The agents installed here work in Cursor without copies in `.cursor/agents/`
+  (`.cursor/agents/` wins on a name clash). Cursor ignores `tools`, `disallowedTools` and `effort`, so the read-only
+  agents are not read-only there. If your project has a test that requires every `.claude/agents/*.md` to have a
+  `.cursor/agents/` twin, relax it to require the twin only for the Cursor agents.
+- **Skip what you already have** with `--without memory-bank` / `jevmem` / `sdd`, for example when your own memory-bank
+  skill has a different name.
+
 ## Design choices
 
 - **The orchestrator is the only writer of memory.** Parallel coders writing `memory/` would conflict, and someone has
@@ -139,7 +152,7 @@ wheel bundles them.
   navigation MCPs; in practice it still reached for `grep` and `sed`, because the MCP tools arrive deferred (name
   only) and the brief or its own habits point elsewhere. `coder-python`, `coder-swift` and `coder-typescript`
   (`--with`) are generated from `coder.md` plus a navigation section that names the MCP's tools, and list those tools
-  in `tools:` so they load up front. A `CLAUDE.md` rule routes that language's work to them. Without `--with`, nothing
+  in `tools:` so they load up front. An `AGENTS.md` rule routes that language's work to them. Without `--with`, nothing
   changes.
 - **The grader runs on Opus.** The code it grades was written by Sonnet coders, so a different, stronger model gives
   a more independent review.

{agent_guild-1.2.0 → agent_guild-1.3.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "agent-guild"
-version = "1.2.0"
-description = "A multi-agent setup for Claude Code (orchestrator + architect, coder, grader, utility subagents) with memory-bank, jevmem and Spec-Driven Development wired in, installed into a project with one command."
+version = "1.3.0"
+description = "A multi-agent setup for Claude Code, Cursor and Codex (orchestrator + architect, coder, grader, utility subagents) with memory-bank, jevmem and Spec-Driven Development wired in, installed into a project with one command."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Daniel Illescas Romero", email = "illescas.daniel@protonmail.com" }]
-keywords = ["claude-code", "claude", "subagents", "multi-agent", "orchestrator", "memory", "spec-driven-development", "sdd"]
+keywords = ["claude-code", "cursor", "codex", "claude", "subagents", "multi-agent", "orchestrator", "memory", "spec-driven-development", "sdd"]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Environment :: Console",

{agent_guild-1.2.0 → agent_guild-1.3.0}/src/agent_guild/cli.py

@@ -6,32 +6,36 @@ from pathlib import Path
 from .files import Ctx
 from .installer import COMPONENTS, Options, run_all
 from .specialists import SPECIALISTS, detect_languages
+from .vendors import TOOLS, VENDORS, agent_filename, detect_tools, parse_tools
 
 _BUNDLED = Path(__file__).resolve().parent / "_assets"  # present in installed wheels
 DEFAULT_ASSETS = _BUNDLED if _BUNDLED.is_dir() else Path(__file__).resolve().parents[2]  # else: a source checkout
 
+KEPT_HINT = """Files marked "skipped ... differs" keep your version. If a skill or agent of yours is an older or customised
+copy of a shipped one, diff it against the shipped file and merge the changes by hand (--force replaces it)."""
+
 NEXT_STEPS = """Next steps:
-  - Review the diff (git status / git diff); edit or delete any copied file or CLAUDE.md section you don't want.
+  - Review the diff (git status / git diff); edit or delete any copied file or AGENTS.md section you don't want.
   - Per machine, once: `uvx jevmem config init` and `uvx --from jevmem jevmem warmup`.
   - With memory-bank: ask Claude to "set up the memory bank".
-  - Restart Claude Code in the project so the agents, skills, hooks and MCP server load."""
+  - Restart your coding tool (Claude Code, Cursor, Codex) in the project so the agents, skills, hooks and MCP server load."""
 
 
 CODERS_NEXT_STEPS = """Next steps:
   - Review the diff (git status / git diff).
-  - Restart Claude Code in the project so the agents and MCP server load."""
+  - Restart your coding tool in the project so the agents and MCP server load."""
 
 
 def suggest_coders(project: Path, chosen: list[str]) -> None:
     """After an install, point at the language coders that fit the project and are not installed yet."""
     missing = [
         name for name in detect_languages(project)
-        if name not in chosen and not (project / ".claude" / "agents" / f"{name}.md").exists()
+        if name not in chosen and not any((project / v.agents_dir / agent_filename(t, name)).exists() for t, v in VENDORS.items())
     ]
     if not missing:
         return
     print("\nThis project looks like it uses code that a language coder can navigate and refactor with a "
-          "code-navigation MCP (optional; adds only the agent, the MCP server and a CLAUDE.md routing rule):")
+          "code-navigation MCP (optional; adds only the agent, the MCP server and an AGENTS.md routing rule):")
     for name in missing:
         spec = SPECIALISTS[name]
         print(f"  - {spec.label}:  uvx agent-guild {project} --with {name} --coders-only")
@@ -45,13 +49,17 @@ def build_parser() -> argparse.ArgumentParser:
         "unless --force.",
     )
     p.add_argument("project", type=Path, help="path to the project's root")
+    p.add_argument("--tools", metavar="LIST",
+                   help=f"comma-separated tools to install for: {', '.join(TOOLS)}. Default: the ones the project already "
+                        "uses (.claude/ or CLAUDE.md, .cursor/, .codex/ or .agents/), or claude when none is found. Each gets "
+                        "agents and skills in its own format and folder, and an MCP config")
     p.add_argument("--without", action="append", default=[], choices=COMPONENTS, metavar="COMPONENT",
                    help=f"leave a component out (repeatable): {', '.join(COMPONENTS)}. "
                         "'sdd' also drops the code-grader agent; 'jevmem' drops skill, MCP server, hooks and the auto-memory switch")
     p.add_argument("--with", dest="with_coders", action="append", default=[], choices=sorted(SPECIALISTS),
                    metavar="CODER",
                    help=f"add a language coder (repeatable): {', '.join(sorted(SPECIALISTS))}. Each is the generic coder plus "
-                        "a code-navigation MCP it must use for that language; the MCP server and a CLAUDE.md routing rule "
+                        "a code-navigation MCP it must use for that language; the MCP server and an AGENTS.md routing rule "
                         "are added too. Off by default")
     p.add_argument("--coders-only", action="store_true",
                    help="with --with: install only the language coders (agent, MCP server, routing rule) and leave "
@@ -86,6 +94,7 @@ def main(argv: list[str] | None = None) -> int:
         raise SystemExit(f"error: {project} is not a directory")
     if not (args.assets / "agents").is_dir():
         raise SystemExit(f"error: no agents/ in {args.assets}; run from a checkout of agent-guild or pass --assets")
+    tools = parse_tools(args.tools) if args.tools else detect_tools(project)
     ctx = Ctx(project=project, dry_run=args.dry_run, force=args.force)
     opts = Options(
         assets=args.assets,
@@ -99,12 +108,16 @@ def main(argv: list[str] | None = None) -> int:
         import_auto_memory=args.import_auto_memory,
         import_cursor_skills=args.import_cursor_skills,
         git_exclude=args.git_exclude,
+        tools=frozenset(tools),
     )
     run_all(ctx, opts)
     print(f"{'Dry run for' if args.dry_run else 'Installed into'} {project}")
+    print(f"  tools: {', '.join(tools)} ({'--tools' if args.tools else 'detected'})")
     print("\n".join(ctx.lines))
     for w in ctx.warnings:
         print(f"warning: {w}")
+    if any(line.lstrip().startswith("skipped") and "differs" in line for line in ctx.lines):
+        print(f"\n{KEPT_HINT}")
     if not args.dry_run:
         print(CODERS_NEXT_STEPS if args.coders_only else NEXT_STEPS)
         for name in sorted(args.with_coders):

{agent_guild-1.2.0 → agent_guild-1.3.0}/src/agent_guild/installer.py

@@ -8,11 +8,13 @@ import re
 import shutil
 import subprocess
 import tempfile
+import tomllib
 from dataclasses import dataclass
 from pathlib import Path
 
 from .files import Ctx, copy_tree, read_json, write_bytes, write_json
 from .specialists import SPECIALISTS, render
+from .vendors import TOOLS, VENDORS, agent_filename, codex_server_block, convert_agent, cursor_server, workflow_path
 
 JEVMEM_SPEC = "jevmem>=0.4.0,<0.5"
 JEVMEM_SERVER = {"type": "stdio", "command": "uvx", "args": ["--from", JEVMEM_SPEC, "jevmem-mcp"]}
@@ -20,7 +22,6 @@ JEVMEM_HOOKS = {
     "SessionStart": ("jevmem hook session-start", 15),
     "UserPromptSubmit": ("jevmem hook user-prompt", 20),
 }
-WORKFLOW_IMPORT = "@.claude/development-workflow.md"
 
 # name -> (git url, skill folder inside the repo, name under .claude/skills/)
 SKILL_SOURCES = {
@@ -52,26 +53,36 @@ class Options:
     import_auto_memory: bool = False
     import_cursor_skills: bool = False
     git_exclude: bool = False
+    tools: frozenset[str] = frozenset({"claude"})
+
+    def selected(self) -> list[str]:
+        return [t for t in TOOLS if t in self.tools]
 
     def wants(self, component: str) -> bool:
         return component not in self.without
 
 
+def _write_agent(ctx: Ctx, opts: Options, name: str, claude_format: bytes) -> None:
+    for tool in opts.selected():
+        dest = ctx.project / VENDORS[tool].agents_dir / agent_filename(tool, name)
+        write_bytes(ctx, dest, convert_agent(tool, claude_format))
+
+
 def install_agents(ctx: Ctx, opts: Options) -> None:
     for agent in sorted((opts.assets / "agents").glob("*.md")):
         if agent.name == "code-grader.md" and not opts.wants("sdd"):
             continue
-        write_bytes(ctx, ctx.project / ".claude" / "agents" / agent.name, agent.read_bytes())
+        _write_agent(ctx, opts, agent.stem, agent.read_bytes())
     write_bytes(
         ctx,
-        ctx.project / ".claude" / "development-workflow.md",
+        ctx.project / workflow_path(opts.tools),
         (opts.assets / "development-workflow.md").read_bytes(),
     )
 
 
 def install_specialists(ctx: Ctx, opts: Options) -> None:
     for name in sorted(opts.with_coders):
-        write_bytes(ctx, ctx.project / ".claude" / "agents" / f"{name}.md", render(SPECIALISTS[name], opts.assets))
+        _write_agent(ctx, opts, name, render(SPECIALISTS[name], opts.assets))
 
 
 def _fetch(url: str, into: Path) -> Path:
@@ -85,6 +96,10 @@ def install_skills(ctx: Ctx, opts: Options) -> None:
     wanted = [c for c in COMPONENTS if opts.wants(c)]
     if not wanted:
         return
+    skills_dirs = [ctx.project / VENDORS[t].skills_dir for t in opts.selected()]
+    for skills_dir in skills_dirs:
+        if skills_dir.is_symlink():
+            ctx.log("note", skills_dir, f"is a symlink to {os.readlink(skills_dir)}: skills are written there")
     with tempfile.TemporaryDirectory(prefix="agent-guild-") as tmp:
         for component in wanted:
             url, subpath, skill_name = SKILL_SOURCES[component]
@@ -93,24 +108,28 @@ def install_skills(ctx: Ctx, opts: Options) -> None:
                 if not repo.is_dir():
                     raise SystemExit(f"error: {repo} not found (expected a clone of {url})")
             elif ctx.dry_run:
-                ctx.log("would fetch", url, f"-> .claude/skills/{skill_name}")
+                ctx.log("would fetch", url, "-> " + ", ".join(f"{d.relative_to(ctx.project).as_posix()}/{skill_name}" for d in skills_dirs))
                 continue
             else:
                 repo = _fetch(url, Path(tmp) / REPO_DIRS[component])
             src = repo / subpath
             if not (src / "SKILL.md").is_file():
                 raise SystemExit(f"error: no SKILL.md in {src}")
-            copy_tree(ctx, src, ctx.project / ".claude" / "skills" / skill_name)
+            for skills_dir in skills_dirs:
+                copy_tree(ctx, src, skills_dir / skill_name)
 
 
 def _rule_sections(opts: Options) -> list[tuple[str, str]]:
-    """(heading that marks the section as present, body) for every CLAUDE.md section to add, in order."""
+    """(heading that marks the section as present, body) for every rules section to add, in order."""
     if opts.coders_only:
         return [(SPECIALISTS[n].agent, SPECIALISTS[n].rule_body) for n in sorted(opts.with_coders)]
     sections = []
     for heading, template, component in RULE_SECTIONS:
         if component is None or opts.wants(component):
             body = (opts.assets / "templates" / template).read_text(encoding="utf-8").strip()
+            names = [f"`{VENDORS[t].agents_dir}/`" for t in opts.selected()]
+            dirs = ", ".join(names[:-1]) + (" and " if len(names) > 1 else "") + names[-1]
+            body = body.replace("{{AGENTS_DIRS}}", dirs).replace("{{WORKFLOW}}", workflow_path(opts.tools))
             sections.append((heading, body))
         if heading == "Agents and delegation":
             sections += [(SPECIALISTS[n].agent, SPECIALISTS[n].rule_body) for n in sorted(opts.with_coders)]
@@ -118,33 +137,56 @@ def _rule_sections(opts: Options) -> list[tuple[str, str]]:
 
 
 def install_rules(ctx: Ctx, opts: Options) -> None:
-    """The new sections live in CLAUDE.md (Claude-only rules); AGENTS.md stays tool-neutral and is just imported."""
+    """Add the rules sections to AGENTS.md (read by Codex, Cursor and others); CLAUDE.md only when it is the sole file.
+
+    Claude Code does not read AGENTS.md, so when it is a selected tool CLAUDE.md gets an `@AGENTS.md` import.
+    """
     agents_md, claude_md = ctx.project / "AGENTS.md", ctx.project / "CLAUDE.md"
-    existed = claude_md.exists()
-    text = claude_md.read_text(encoding="utf-8") if existed else ""
-    known = text + (agents_md.read_text(encoding="utf-8") if agents_md.exists() else "")
+    target = claude_md if claude_md.exists() and not agents_md.exists() else agents_md
+    other = claude_md if target == agents_md else agents_md
+    existed = target.exists()
+    text = target.read_text(encoding="utf-8") if existed else ""
+    known = text + (other.read_text(encoding="utf-8") if other.exists() else "")
     added = []
-    if agents_md.exists() and "@AGENTS.md" not in text:
-        text = "@AGENTS.md\n" + (("\n" + text) if text.strip() else "")
-        added.append("@AGENTS.md import")
     for heading, body in _rule_sections(opts):
         if re.search(rf"^#+ .*{re.escape(heading)}", known, re.MULTILINE):
-            ctx.log("unchanged", claude_md, f"already has '{heading}' (CLAUDE.md or AGENTS.md)")
+            ctx.log("skipped", target, f"section '{heading}' is already in AGENTS.md or CLAUDE.md")
             continue
         text = text.rstrip("\n") + ("\n\n" if text.strip() else "") + body + "\n"
         added.append(heading)
     if added:
         if not ctx.dry_run:
-            claude_md.write_text(text, encoding="utf-8")
+            target.write_text(text, encoding="utf-8")
         verb = "edited" if existed else "created"
-        (ctx.edited_existing.append(claude_md) if existed else ctx.track_new(claude_md))
-        ctx.log(f"would {verb[:-1]}" if ctx.dry_run else verb, claude_md, "+ " + ", ".join(added))
+        (ctx.edited_existing.append(target) if existed else ctx.track_new(target))
+        ctx.log(f"would {verb[:-1]}" if ctx.dry_run else verb, target, "+ " + ", ".join(added))
+    if target == agents_md and "claude" in opts.tools:
+        _import_agents_md(ctx, claude_md)
+    if target == claude_md and opts.tools - {"claude"}:
+        ctx.warn("this project only has a CLAUDE.md, which Codex and Cursor don't read: rename it to AGENTS.md "
+                 "(and keep a CLAUDE.md containing `@AGENTS.md`) so every tool gets the rules.")
+
+
+def _import_agents_md(ctx: Ctx, claude_md: Path) -> None:
+    existed = claude_md.exists()
+    text = claude_md.read_text(encoding="utf-8") if existed else ""
+    if "@AGENTS.md" in text:
+        return
+    text = "@AGENTS.md\n" + (("\n" + text) if text.strip() else "")
+    if not ctx.dry_run:
+        claude_md.write_text(text, encoding="utf-8")
+    (ctx.edited_existing.append(claude_md) if existed else ctx.track_new(claude_md))
+    verb = "edit" if existed else "create"
+    ctx.log(f"would {verb}" if ctx.dry_run else ("edited" if existed else "created"), claude_md, "+ @AGENTS.md import")
 
 
 def import_cursor_skills(ctx: Ctx, opts: Options) -> None:
     """Copy the project's Cursor skills (.cursor/skills/*) into .claude/skills/. Existing skills are never replaced."""
     if not opts.import_cursor_skills:
         return
+    if "claude" not in opts.tools:
+        ctx.log("skipped", ".cursor/skills", "--import-cursor-skills copies into .claude/skills, and claude is not a selected tool")
+        return
     src_root = ctx.project / ".cursor" / "skills"
     if not src_root.is_dir():
         ctx.log("skipped", ".cursor/skills", "not found")
@@ -162,6 +204,12 @@ def _has_hook(groups: list, marker: str) -> bool:
 
 
 def install_settings(ctx: Ctx, opts: Options) -> None:
+    """Claude Code only: hooks, auto-memory switch and model are its settings."""
+    if "claude" not in opts.tools:
+        if opts.wants("jevmem"):
+            ctx.warn("jevmem's session hooks are only set up for Claude Code; in Cursor and Codex the agents call "
+                     "memory_recall themselves.")
+        return
     shared_path = ctx.project / ".claude" / "settings.json"
     personal_path = ctx.project / ".claude" / "settings.local.json"
     scalar_path = personal_path if opts.personal_settings else shared_path
@@ -208,16 +256,10 @@ def install_mcp(ctx: Ctx, opts: Options) -> None:
         servers_to_add[spec.server_key] = spec.server
     if not servers_to_add:
         return
-    path = ctx.project / ".mcp.json"
-    data, indent = read_json(path)
-    servers = data.setdefault("mcpServers", {})
-    changes = []
-    for key, server in servers_to_add.items():
-        if key not in servers:
-            servers[key] = server
-            changes.append(f"{key} server")
+    for tool in opts.selected():
+        _write_mcp(ctx, tool, servers_to_add)
     user_config = Path.home() / ".claude.json"
-    if user_config.exists():
+    if user_config.exists() and "claude" in opts.tools:
         try:
             registered = json.loads(user_config.read_text(encoding="utf-8")).get("mcpServers", {})
             for key in servers_to_add:
@@ -225,9 +267,43 @@ def install_mcp(ctx: Ctx, opts: Options) -> None:
                     ctx.warn(f"{key} is also registered at user scope; keep one registration so the server isn't listed twice.")
         except (json.JSONDecodeError, AttributeError):
             pass
+
+
+def _write_mcp(ctx: Ctx, tool: str, servers_to_add: dict) -> None:
+    path = ctx.project / VENDORS[tool].mcp_file
+    if tool == "codex":
+        _write_codex_mcp(ctx, path, servers_to_add)
+        return
+    data, indent = read_json(path)
+    servers = data.setdefault("mcpServers", {})
+    changes = []
+    for key, server in servers_to_add.items():
+        if key not in servers:
+            servers[key] = cursor_server(server) if tool == "cursor" else server
+            changes.append(f"{key} server")
     write_json(ctx, path, data, indent, changes)
 
 
+def _write_codex_mcp(ctx: Ctx, path: Path, servers_to_add: dict) -> None:
+    """Append [mcp_servers.<key>] tables to .codex/config.toml; existing entries and the rest of the file are kept."""
+    text = path.read_text(encoding="utf-8") if path.exists() else ""
+    try:
+        registered = tomllib.loads(text).get("mcp_servers", {})
+    except tomllib.TOMLDecodeError as exc:
+        raise SystemExit(f"error: {path} is not valid TOML ({exc}); fix it or move it away and re-run")
+    blocks = [codex_server_block(k, v) for k, v in servers_to_add.items() if k not in registered]
+    if not blocks:
+        ctx.log("unchanged", path)
+        return
+    existed = path.exists()
+    if not ctx.dry_run:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text.rstrip("\n") + ("\n\n" if text.strip() else "") + "\n".join(blocks), encoding="utf-8")
+    (ctx.edited_existing.append(path) if existed else ctx.track_new(path))
+    changes = "+ " + ", ".join(f"{k} server" for k in servers_to_add if k not in registered)
+    ctx.log(f"would {'edit' if existed else 'create'}" if ctx.dry_run else ("edited" if existed else "created"), path, changes)
+
+
 def encoded_memory_dir(project: Path) -> Path:
     """Claude Code names a project's auto-memory folder after its absolute path, every non-alphanumeric char -> '-'."""
     return Path.home() / ".claude" / "projects" / re.sub(r"[^A-Za-z0-9]", "-", str(project))

{agent_guild-1.2.0 → agent_guild-1.3.0}/src/agent_guild/specialists.py

@@ -73,7 +73,7 @@ SPECIALISTS = {
             server={"type": "stdio", "command": "uvx", "args": ["--from", "codenav-mcp>=0.2.1,<0.3", "codenav-mcp"]},
             tools=PYTHON_TOOLS,
             prerequisite="coder-python: needs uv and Python 3.11+ (codenav-mcp runs through uvx). For a src layout, "
-            "set CODENAV_MCP_SOURCE_ROOT in the codenav entry of .mcp.json.",
+            "set CODENAV_MCP_SOURCE_ROOT on the codenav MCP server.",
             fragment="python.md",
         ),
         Specialist(

agent_guild-1.3.0/src/agent_guild/vendors.py

@@ -0,0 +1,119 @@
+"""The coding tools the setup can be installed for, where each one keeps its files, and the format it expects.
+
+Agents are authored in Claude Code's format (`agents/*.md`); the other tools get a converted copy:
+
+- Cursor: Markdown + YAML frontmatter, but with `readonly` instead of `disallowedTools`, no `color`/`effort`, and
+  `model: inherit` (Cursor's model ids are not Claude's aliases). https://cursor.com/docs/context/subagents
+- Codex: one TOML file per agent with `name`, `description` and `developer_instructions`; it has no read-only switch
+  for an agent, so that is stated in the instructions. https://learn.chatgpt.com/docs/agent-configuration/subagents
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+TOOLS = ("claude", "cursor", "codex")
+
+
+@dataclass(frozen=True)
+class Vendor:
+    name: str
+    agents_dir: str
+    skills_dir: str
+    agent_suffix: str
+    mcp_file: str
+
+
+VENDORS = {
+    "claude": Vendor("claude", ".claude/agents", ".claude/skills", ".md", ".mcp.json"),
+    "cursor": Vendor("cursor", ".cursor/agents", ".cursor/skills", ".md", ".cursor/mcp.json"),
+    "codex": Vendor("codex", ".codex/agents", ".codex/skills", ".toml", ".codex/config.toml"),
+}
+
+
+def detect_tools(project: Path) -> list[str]:
+    """Tools the project already uses, judged by their folders; Claude Code when nothing is found."""
+    signs = {
+        "claude": (".claude", "CLAUDE.md", ".mcp.json"),
+        "cursor": (".cursor",),
+        "codex": (".codex", ".agents"),
+    }
+    found = [t for t in TOOLS if any((project / s).exists() for s in signs[t])]
+    return found or ["claude"]
+
+
+def parse_tools(value: str) -> list[str]:
+    names = [n.strip().lower() for n in value.split(",") if n.strip()]
+    unknown = [n for n in names if n not in TOOLS]
+    if unknown or not names:
+        raise SystemExit(f"error: --tools takes a comma-separated list of {', '.join(TOOLS)} (got {value!r})")
+    return [t for t in TOOLS if t in names]
+
+
+def agent_filename(tool: str, agent: str) -> str:
+    return agent + VENDORS[tool].agent_suffix
+
+
+def workflow_path(tools: list[str] | frozenset[str]) -> str:
+    """One shared copy of the workflow doc, inside the first selected tool's folder."""
+    first = next(t for t in TOOLS if t in tools)
+    return f"{Path(VENDORS[first].agents_dir).parent.as_posix()}/development-workflow.md"
+
+
+def _split(source: str) -> tuple[dict[str, str], str]:
+    _, frontmatter, body = source.replace("\r\n", "\n").split("---\n", 2)
+    fields = {}
+    for line in frontmatter.splitlines():
+        key, _, value = line.partition(":")
+        fields[key.strip()] = value.strip()
+    return fields, body
+
+
+def _is_read_only(fields: dict[str, str]) -> bool:
+    return "Edit" in {t.strip() for t in fields.get("disallowedTools", "").split(",")}
+
+
+def convert_agent(tool: str, source: bytes) -> bytes:
+    """Turn a Claude Code agent file into `tool`'s format."""
+    if tool == "claude":
+        return source
+    fields, body = _split(source.decode("utf-8"))
+    read_only = _is_read_only(fields)
+    if tool == "cursor":
+        head = [f"name: {fields['name']}", f"description: {json.dumps(fields['description'], ensure_ascii=False)}",
+                "model: inherit"]
+        if read_only:
+            head.append("readonly: true")
+        return ("---\n" + "\n".join(head) + "\n---\n" + body).encode("utf-8")
+    if tool == "codex":
+        instructions = body.strip("\n")
+        if read_only:
+            instructions = "You are read-only: never edit, create or delete files.\n\n" + instructions
+        escaped = instructions.replace("\\", "\\\\").replace('"""', '\\"\\"\\"')
+        lines = [f"name = {json.dumps(fields['name'])}",
+                 f"description = {json.dumps(fields['description'], ensure_ascii=False)}"]
+        if fields.get("effort") in ("low", "medium", "high", "xhigh", "max"):
+            lines.append(f'model_reasoning_effort = "{"high" if fields["effort"] in ("xhigh", "max") else fields["effort"]}"')
+        lines.append(f'developer_instructions = """\n{escaped}\n"""')
+        return ("\n".join(lines) + "\n").encode("utf-8")
+    raise ValueError(tool)
+
+
+def cursor_server(server: dict) -> dict:
+    return {k: v for k, v in server.items() if k != "type"}
+
+
+def _toml_value(value) -> str:
+    if isinstance(value, dict):
+        return "{ " + ", ".join(f"{json.dumps(k)} = {_toml_value(v)}" for k, v in value.items()) + " }"
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(v) for v in value) + "]"
+    return json.dumps(value, ensure_ascii=False)
+
+
+def codex_server_block(key: str, server: dict) -> str:
+    lines = [f"[mcp_servers.{key}]"]
+    lines += [f"{k} = {_toml_value(v)}" for k, v in server.items() if k != "type"]
+    return "\n".join(lines) + "\n"

agent_guild-1.3.0/templates/agents-rules.md

@@ -0,0 +1,7 @@
+## Agents and delegation
+
+You are the orchestrator: delegate to the `architect`, `coder`, `code-grader` and `utility` subagents in
+{{AGENTS_DIRS}}, and own every approval gate and memory write. Routing, briefs and the memory protocol (read this file
+before delegating):
+
+@{{WORKFLOW}}

{agent_guild-1.2.0 → agent_guild-1.3.0}/tests/test_cli.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import pytest
 
 from agent_guild.cli import main
+from agent_guild.vendors import convert_agent
 
 REPOS = {"memory-bank": "skills/memory-bank", "jev-mem": ".claude/skills/jev-memory",
          "sdd-feature-skill": "skills/sdd-feature"}
@@ -40,16 +41,17 @@ def test_given_empty_project_when_installed_then_everything_is_copied(tmp_path,
     assert (project / ".claude/development-workflow.md").is_file()
     for skill in ("memory-bank", "jev-memory", "sdd-feature"):
         assert (project / ".claude/skills" / skill / "SKILL.md").is_file()
-    claude_md = (project / "CLAUDE.md").read_text()
-    assert "@.claude/development-workflow.md" in claude_md
-    assert "## Memory bank" in claude_md and "Phase Gate Protocol" in claude_md
+    assert (project / "CLAUDE.md").read_text() == "@AGENTS.md\n"
+    agents_md = (project / "AGENTS.md").read_text()
+    assert "@.claude/development-workflow.md" in agents_md
+    assert "## Memory bank" in agents_md and "Phase Gate Protocol" in agents_md
     settings = json.loads((project / ".claude/settings.json").read_text())
     assert settings["model"] == "sonnet" and settings["autoMemoryEnabled"] is False
     assert set(settings["hooks"]) == {"SessionStart", "UserPromptSubmit"}
     assert "jevmem" in json.loads((project / ".mcp.json").read_text())["mcpServers"]
 
 
-def test_given_agents_md_only_when_installed_then_claude_md_imports_it_and_holds_the_sections(tmp_path, sources):
+def test_given_agents_md_only_when_installed_then_it_holds_the_sections_and_claude_md_imports_it(tmp_path, sources):
     # given
     project = tmp_path / "p"
     project.mkdir()
@@ -57,9 +59,34 @@ def test_given_agents_md_only_when_installed_then_claude_md_imports_it_and_holds
     # when
     run(project, sources)
     # then
-    assert (project / "CLAUDE.md").read_text().startswith("@AGENTS.md\n")
+    assert (project / "CLAUDE.md").read_text() == "@AGENTS.md\n"
+    assert (project / "AGENTS.md").read_text().startswith("# Rules\n")
+    assert "## Agents and delegation" in (project / "AGENTS.md").read_text()
+
+
+def test_given_claude_md_only_when_installed_then_the_sections_go_there(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    project.mkdir()
+    (project / "CLAUDE.md").write_text("# Mine\n")
+    # when
+    run(project, sources)
+    # then
+    assert not (project / "AGENTS.md").exists()
     assert "## Agents and delegation" in (project / "CLAUDE.md").read_text()
-    assert (project / "AGENTS.md").read_text() == "# Rules\n"
+
+
+def test_given_both_files_when_installed_then_agents_md_gets_the_sections_and_claude_md_keeps_its_text(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    project.mkdir()
+    (project / "AGENTS.md").write_text("# Rules\n")
+    (project / "CLAUDE.md").write_text("# Claude only\n")
+    # when
+    run(project, sources)
+    # then
+    assert "## Agents and delegation" in (project / "AGENTS.md").read_text()
+    assert (project / "CLAUDE.md").read_text() == "@AGENTS.md\n\n# Claude only\n"
 
 
 def test_given_installed_project_when_run_again_then_nothing_changes(tmp_path, sources):
@@ -100,7 +127,7 @@ def test_given_without_sdd_and_jevmem_then_those_parts_are_left_out(tmp_path, so
     assert not (project / ".claude/skills/jev-memory").exists()
     assert not (project / ".mcp.json").exists()
     assert json.loads((project / ".claude/settings.json").read_text()) == {"model": "sonnet"}
-    assert "Phase Gate" not in (project / "CLAUDE.md").read_text()
+    assert "Phase Gate" not in (project / "AGENTS.md").read_text()
 
 
 def test_given_existing_settings_when_installed_then_they_are_merged_with_indent_kept(tmp_path, sources):
@@ -150,7 +177,7 @@ def test_given_model_none_then_model_is_not_set(tmp_path, sources):
     assert "model" not in json.loads((project / ".claude/settings.json").read_text())
 
 
-def test_given_sections_already_in_agents_md_then_claude_md_does_not_repeat_them(tmp_path, sources):
+def test_given_sections_already_in_agents_md_then_they_are_not_repeated(tmp_path, sources):
     # given
     project = tmp_path / "p"
     project.mkdir()
@@ -158,9 +185,9 @@ def test_given_sections_already_in_agents_md_then_claude_md_does_not_repeat_them
     # when
     run(project, sources)
     # then
-    text = (project / "CLAUDE.md").read_text()
+    text = (project / "AGENTS.md").read_text()
     assert "## Agents and delegation" in text
-    assert "## Memory bank" not in text and "Phase Gate" not in text
+    assert text.count("## Memory bank") == 1 and text.count("Phase Gate") == 1
 
 
 def test_given_cursor_skills_when_importing_then_copied_without_replacing_existing(tmp_path, sources):
@@ -171,7 +198,7 @@ def test_given_cursor_skills_when_importing_then_copied_without_replacing_existi
     (project / ".cursor/skills/sdd-feature").mkdir()
     (project / ".cursor/skills/sdd-feature/SKILL.md").write_text("cursor version")
     # when
-    run(project, sources, "--import-cursor-skills")
+    run(project, sources, "--tools", "claude,cursor", "--import-cursor-skills")
     # then
     assert (project / ".claude/skills/mine/SKILL.md").read_text() == "mine"
     assert (project / ".claude/skills/sdd-feature/SKILL.md").read_text() != "cursor version"
@@ -222,7 +249,7 @@ def test_given_no_with_flag_then_no_language_coder_or_navigation_server_is_insta
     # then
     assert sorted(p.name for p in (project / ".claude/agents").glob("coder-*.md")) == []
     assert set(json.loads((project / ".mcp.json").read_text())["mcpServers"]) == {"jevmem"}
-    assert "coder-python" not in (project / "CLAUDE.md").read_text()
+    assert "coder-python" not in (project / "AGENTS.md").read_text()
 
 
 @pytest.mark.parametrize("agent, server_key, tool", [
@@ -246,9 +273,9 @@ def test_given_with_coder_then_agent_server_and_routing_rule_are_installed(tmp_p
     assert "model: sonnet" in frontmatter
     assert "## Rules" in body and "navigation (" in body
     assert server_key in json.loads((project / ".mcp.json").read_text())["mcpServers"]
-    claude_md = (project / "CLAUDE.md").read_text()
-    assert f"`{agent}`" in claude_md
-    assert claude_md.index(f"`{agent}`") < claude_md.index("## Memory bank")
+    agents_md = (project / "AGENTS.md").read_text()
+    assert f"`{agent}`" in agents_md
+    assert agents_md.index(f"`{agent}`") < agents_md.index("## Memory bank")
 
 
 def test_given_with_coder_when_run_again_then_nothing_changes_and_rule_is_not_repeated(tmp_path, sources):
@@ -261,7 +288,7 @@ def test_given_with_coder_when_run_again_then_nothing_changes_and_rule_is_not_re
     run(project, sources, "--with", "coder-python", "--with", "coder-swift")
     # then
     assert {p: p.read_bytes() for p in project.rglob("*") if p.is_file()} == before
-    assert (project / "CLAUDE.md").read_text().count("## Python code goes to") == 1
+    assert (project / "AGENTS.md").read_text().count("## Python code goes to") == 1
 
 
 def test_given_existing_server_entry_when_with_coder_then_it_is_kept(tmp_path, sources):
@@ -364,3 +391,163 @@ def test_given_coders_only_without_with_then_it_is_refused(tmp_path, sources):
     # when / then
     with pytest.raises(SystemExit):
         run(project, sources, "--coders-only")
+
+
+def test_given_edited_agent_when_run_again_then_the_merge_hint_is_printed(tmp_path, sources, capsys):
+    # given
+    project = tmp_path / "p"
+    project.mkdir()
+    run(project, sources)
+    (project / ".claude/agents/coder.md").write_text("mine")
+    capsys.readouterr()
+    # when
+    run(project, sources)
+    # then
+    assert "merge the changes by hand" in capsys.readouterr().out
+
+
+def test_given_sections_already_in_agents_md_then_the_log_says_skipped_not_unchanged(tmp_path, sources, capsys):
+    # given
+    project = tmp_path / "p"
+    project.mkdir()
+    (project / "AGENTS.md").write_text("## Memory bank\n\n## Phase Gate Protocol\n")
+    # when
+    run(project, sources)
+    # then
+    out = capsys.readouterr().out
+    assert "skipped    AGENTS.md  section 'Phase Gate Protocol' is already in AGENTS.md or CLAUDE.md" in out
+
+
+def test_given_symlinked_skills_dir_then_the_log_notes_where_skills_are_written(tmp_path, sources, capsys):
+    # given
+    project = tmp_path / "p"
+    (project / ".cursor/skills").mkdir(parents=True)
+    (project / ".claude").mkdir()
+    try:
+        (project / ".claude/skills").symlink_to(project / ".cursor/skills", target_is_directory=True)
+    except (OSError, NotImplementedError):
+        pytest.skip("symlinks are not available here")
+    # when
+    run(project, sources)
+    # then
+    assert "is a symlink to" in capsys.readouterr().out
+    assert (project / ".cursor/skills/sdd-feature/SKILL.md").is_file()
+
+
+def _tree(project):
+    return sorted(p.relative_to(project).as_posix() for p in project.rglob("*") if p.is_file())
+
+
+def test_given_cursor_folder_when_installed_then_cursor_gets_its_own_format_and_no_claude_files(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    (project / ".cursor").mkdir(parents=True)
+    # when
+    run(project, sources)
+    # then
+    files = _tree(project)
+    assert not any(f.startswith(".claude/") or f in ("CLAUDE.md", ".mcp.json") for f in files)
+    architect = (project / ".cursor/agents/architect.md").read_text()
+    assert 'readonly: true' in architect and "model: inherit" in architect
+    assert "disallowedTools" not in architect and "color:" not in architect and "effort:" not in architect
+    assert "readonly" not in (project / ".cursor/agents/coder.md").read_text()
+    for skill in ("memory-bank", "jev-memory", "sdd-feature"):
+        assert (project / ".cursor/skills" / skill / "SKILL.md").is_file()
+    assert (project / ".cursor/development-workflow.md").is_file()
+    assert "@.cursor/development-workflow.md" in (project / "AGENTS.md").read_text()
+    assert "jevmem" in json.loads((project / ".cursor/mcp.json").read_text())["mcpServers"]
+    assert "type" not in json.loads((project / ".cursor/mcp.json").read_text())["mcpServers"]["jevmem"]
+
+
+def test_given_codex_folder_when_installed_then_agents_are_toml_and_skills_go_to_codex_skills(tmp_path, sources, capsys):
+    # given
+    import tomllib
+    project = tmp_path / "p"
+    (project / ".codex").mkdir(parents=True)
+    # when
+    run(project, sources, "--with", "coder-python")
+    # then
+    for name in ("architect", "coder", "code-grader", "utility", "coder-python"):
+        agent = tomllib.loads((project / ".codex/agents" / f"{name}.toml").read_text())
+        assert agent["name"] == name and agent["description"] and agent["developer_instructions"].strip()
+    architect = tomllib.loads((project / ".codex/agents/architect.toml").read_text())
+    assert architect["model_reasoning_effort"] == "high"
+    assert architect["developer_instructions"].startswith("You are read-only")
+    assert not tomllib.loads((project / ".codex/agents/coder.toml").read_text())["developer_instructions"].startswith("You are read-only")
+    assert (project / ".codex/skills/sdd-feature/SKILL.md").is_file()
+    assert not (project / ".agents").exists()
+    config = tomllib.loads((project / ".codex/config.toml").read_text())
+    assert config["mcp_servers"]["jevmem"]["command"] == "uvx"
+    assert config["mcp_servers"]["codenav"]["args"][0] == "--from"
+    assert not (project / ".claude").exists()
+    assert "jevmem's session hooks are only set up for Claude Code" in capsys.readouterr().out
+
+
+def test_given_several_tools_detected_then_all_of_them_are_installed_and_share_one_workflow_doc(tmp_path, sources, capsys):
+    # given
+    project = tmp_path / "p"
+    for folder in (".claude", ".cursor", ".codex"):
+        (project / folder).mkdir(parents=True)
+    # when
+    run(project, sources)
+    # then
+    files = _tree(project)
+    assert ".claude/agents/coder.md" in files and ".cursor/agents/coder.md" in files and ".codex/agents/coder.toml" in files
+    assert [f for f in files if f.endswith("development-workflow.md")] == [".claude/development-workflow.md"]
+    assert "tools: claude, cursor, codex (detected)" in capsys.readouterr().out
+    rules = (project / "AGENTS.md").read_text()
+    assert "`.claude/agents/`, `.cursor/agents/` and `.codex/agents/`" in rules
+
+
+def test_given_tools_flag_then_it_overrides_detection(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    (project / ".cursor").mkdir(parents=True)
+    # when
+    run(project, sources, "--tools", "codex")
+    # then
+    assert (project / ".codex/agents/coder.toml").is_file()
+    assert not (project / ".cursor/agents").exists() and not (project / ".claude").exists()
+
+
+def test_given_unknown_tool_then_it_is_refused(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    project.mkdir()
+    # when / then
+    with pytest.raises(SystemExit):
+        run(project, sources, "--tools", "emacs")
+
+
+def test_given_codex_config_with_other_settings_then_servers_are_appended_and_run_again_changes_nothing(tmp_path, sources):
+    # given
+    project = tmp_path / "p"
+    (project / ".codex").mkdir(parents=True)
+    (project / ".codex/config.toml").write_text('model = "x"\n\n[mcp_servers.jevmem]\ncommand = "mine"\n')
+    # when
+    run(project, sources, "--with", "coder-swift")
+    run(project, sources, "--with", "coder-swift")
+    # then
+    import tomllib
+    config = tomllib.loads((project / ".codex/config.toml").read_text())
+    assert config["model"] == "x" and config["mcp_servers"]["jevmem"]["command"] == "mine"
+    assert config["mcp_servers"]["codenav-swift"]["env"] == {"CODENAV_SWIFT_WRITE": "1"}
+    assert (project / ".codex/config.toml").read_text().count("[mcp_servers.codenav-swift]") == 1
+
+
+def test_given_claude_md_only_and_codex_then_a_warning_says_codex_will_not_read_it(tmp_path, sources, capsys):
+    # given
+    project = tmp_path / "p"
+    (project / ".codex").mkdir(parents=True)
+    (project / "CLAUDE.md").write_text("# Mine\n")
+    # when
+    run(project, sources)
+    # then
+    assert "only has a CLAUDE.md" in capsys.readouterr().out
+
+
+def test_given_crlf_agent_source_when_converting_then_same_result_as_lf():
+    # Windows checkouts may turn the shipped agent files into CRLF
+    lf = b'---\nname: x\ndescription: d\ndisallowedTools: Edit, Write\n---\nBody\n'
+    for tool in ("cursor", "codex"):
+        assert convert_agent(tool, lf.replace(b"\n", b"\r\n")) == convert_agent(tool, lf)

{agent_guild-1.2.0 → agent_guild-1.3.0}/uv.lock

@@ -4,7 +4,7 @@ requires-python = ">=3.11"
 
 [[package]]
 name = "agent-guild"
-version = "1.2.0"
+version = "1.3.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

agent_guild-1.2.0/templates/agents-rules.md

@@ -1,6 +0,0 @@
-## Agents and delegation
-
-You are the orchestrator: delegate to the `architect`, `coder`, `code-grader` and `utility` subagents in
-`.claude/agents/`, and own every approval gate and memory write. Routing, briefs and the memory protocol:
-
-@.claude/development-workflow.md