lshed 0.10.0 → 0.13.0

package/CHANGELOG.md

@@ -1,6 +1,38 @@
 # Changelog
 
-## 0.10.0 — 2026-09-04
+## 0.13.0 — 2026-09-05
+
+`--agent agy` places into Google Antigravity (the `agy` CLI and the IDE).
+
+- Skills go to `~/.gemini/config/skills/`, the one global location both the Antigravity IDE and CLI read. Instructions are concatenated into `~/.gemini/AGENTS.md`, one level above that root: agy reads both `AGENTS.md` and `GEMINI.md` there, and Gemini CLI also owns `GEMINI.md`, so lshed leaves that one alone. MCP servers go to `~/.gemini/config/mcp_config.json` in agy's shape (no `type`, `serverUrl` for http); `${VAR}` is filled by `restore`.
+- A part above the root (`../AGENTS.md`) is backed up under `lshed/backups/<stamp>/__/` so backups never escape the backup directory.
+- Verified on this machine with agy 1.1.26 through the VM probe (`scripts/vm/probe.sh agy`): skill, rules file, MCP list, and a linked skill all read. agy does not read `~/.agents/skills`, so it is not part of the `agents` target.
+
+## 0.12.1 — 2026-09-05
+
+- Fix: with `CLAUDE_CONFIG_DIR` set on a machine where Claude Code has not run yet, `restore` wrote MCP servers to `<dir>.json` next to the config dir instead of `<dir>/.claude.json` inside it, where Claude Code actually reads them. Found by the VM probe below. Without `CLAUDE_CONFIG_DIR` nothing changes.
+
+VM probe for the other agents (`scripts/vm/`): `install-tools.sh` bakes an image with Codex, Gemini CLI, Copilot CLI, Cursor CLI and lshed; `cloud-init.yaml` injects API keys at boot and runs `probe.sh`, which restores a throwaway shed into each tool's real root and asks the tool, non-interactively, for a passphrase kept in a skill, a codeword kept in the instructions file, and the same skill again after `--link`. Where a tool can parse its own config without a model (`codex mcp list`, `gemini mcp list`, `codex debug prompt-input`) that is checked too. Run on this machine against Codex 0.153.2: Codex reads `$CODEX_HOME/skills` (deprecated in its source; the docs now name only `~/.agents/skills`), `$CODEX_HOME/AGENTS.md`, the `[mcp_servers.*]` table lshed writes, and a linked skill.
+
+## 0.12.0 — 2026-09-04
+
+MCP servers follow the shed into the other agents.
+
+- `restore --agent codex|gemini|copilot|cursor` now writes the profile's MCP servers too: Codex into `config.toml` (`[mcp_servers.*]`), Gemini into `settings.json`, Copilot into `mcp-config.json`, Cursor into `mcp.json`. The shed keeps Claude Code's shape; each target gets its own (`httpUrl`, `type: local` + `tools`, `${env:VAR}`, `env_vars` / `bearer_token_env_var`).
+- Secrets stay out of Codex and Cursor config files, which take variable names or `${env:VAR}`. Gemini and Copilot take values, filled from your shell at `restore` like settings keys.
+- Codex's `config.toml` is edited one table at a time. Comments, ordering and unrelated tables are left untouched.
+- `lshed init --agent gemini` (or any of the others) reads that tool's MCP servers into the shed, masked the same way as Claude Code's. `diff` and `save` work across the translation.
+
+ — 2026-09-04
+
+One shed, several agents.
+
+- `--agent codex|gemini|copilot|cursor|agents` restores the same shed into another tool's config root. They all read `skills/<name>/SKILL.md` the way Claude Code does, and `~/.agents/skills/` is the shared location every one of them also reads. Codex gets `AGENTS.md`, Gemini `GEMINI.md`, Copilot `copilot-instructions.md`, each with the profile's instruction fragments concatenated; Cursor and `~/.agents` have no user-level instructions file and skip that category.
+- Parts the target does not understand are announced and skipped instead of failing: MCP servers, settings keys and Claude Code agents/commands stay Claude-only, and Claude plugin packages are not installed elsewhere. Each agent root keeps its own state, profile and `--link` choice.
+- `lshed init --agent codex` builds a shed from a Codex machine; a shed made by one agent restores into any other. The shed's `agent:` field is now only the default for `--agent`; `$LSHED_AGENT` also works.
+- `lshed status` names the agent next to the root.
+
+ — 2026-09-04
 
 Link instead of copy, on the machines where you edit.
 

package/README.md

@@ -245,6 +245,31 @@ Switching removes only what the previous profile placed (`-`), keeps what both u
 
 Instructions fragments are ordered. `restore` writes a `CLAUDE.md` that `@`-imports each fragment, so editing a fragment in the shed shows up on the next `restore` and there is nothing to merge.
 
+### Other agents, same shed
+
+Codex, Gemini CLI, Copilot CLI, Cursor and Google Antigravity (`agy`) all read skills from `<their config dir>/skills/<name>/SKILL.md`, the same layout Claude Code uses, and all but Antigravity also read the shared `~/.agents/skills/`. So one shed can serve them all. Pick the target with `--agent`:
+
+```
+lshed restore --agent agents            # ~/.agents/skills: every tool that follows the convention reads it
+lshed restore --agent codex             # ~/.codex/skills + ~/.codex/AGENTS.md
+lshed restore --agent gemini --link     # ~/.gemini/skills + ~/.gemini/GEMINI.md, as links
+lshed restore --agent agy               # ~/.gemini/config/skills + ~/.gemini/AGENTS.md (Antigravity IDE and CLI)
+```
+
+| `--agent` | root | skills | instructions file | MCP servers |
+|---|---|---|---|---|
+| `claude-code` (default) | `~/.claude` or `$CLAUDE_CONFIG_DIR` | yes, plus agents, commands, settings | `CLAUDE.md`, `@`-imports fragments | `~/.claude.json` |
+| `codex` | `~/.codex` or `$CODEX_HOME` | yes | `AGENTS.md`, fragments concatenated | `config.toml` `[mcp_servers.*]` |
+| `gemini` | `~/.gemini` | yes | `GEMINI.md`, concatenated | `settings.json` |
+| `copilot` | `~/.copilot` or `$COPILOT_HOME` | yes | `copilot-instructions.md`, concatenated | `mcp-config.json` |
+| `cursor` | `~/.cursor` | yes | none (Cursor's user rules live in its settings UI) | `mcp.json` |
+| `agy` | `~/.gemini/config` | yes | `../AGENTS.md`, concatenated (agy reads `GEMINI.md` too, but Gemini CLI owns that one) | `mcp_config.json` |
+| `agents` | `~/.agents` | yes | none | none |
+
+MCP entries are stored in the shed in Claude Code's shape and translated on the way out: Gemini gets `httpUrl` and no `type`, Antigravity gets `serverUrl`, Copilot gets `type: local` and `tools: ["*"]`, Cursor gets `${env:VAR}` placeholders and Codex gets `env_vars` / `bearer_token_env_var` / `env_http_headers` with the variable *names*, so for those two the secret values never touch the config file. Gemini, Antigravity and Copilot do not expand placeholders, so lshed fills them from your shell at `restore`. Codex's `config.toml` is edited table by table; your comments and other settings stay as they are. `lshed init --agent gemini` reads the same files back into the shed shape, secrets masked.
+
+Each agent root keeps its own `lshed/state.json`, so restoring into `~/.codex` never touches what lshed placed in `~/.claude`, and each can use a different profile or `--link` choice. Parts the target does not understand are announced and skipped: a profile with settings keys restores into Codex without them, with a line saying `codex 은 settings 를 다루지 않아 건너뜁니다`. Claude plugin packages are skipped the same way; `github:`/`git:` packages are cloned into every agent root that restores the profile, so give the other agents a profile without them if that is not what you want. `lshed init --agent codex` works too, and a shed made from Codex restores into Claude Code with `CLAUDE.md` generated from the same fragments. The shed's `agent:` is only a default for `--agent` (`$LSHED_AGENT` also works).
+
 ### Links instead of copies
 
 On the machine where you do most of your editing, `restore --link` places skills, agents, commands and instruction fragments as links into the shed instead of copies. Edits in `~/.claude` land in the shed directly, `diff` has nothing to report, and `save` has nothing to do; `lshed sync` is the whole loop.
@@ -444,7 +469,7 @@ $ lshed add
 ```
 lshed init [--shed <dir>] [--profile <name>] [--exclude <id...>]
 lshed add [keys...] [--all]                     put things that appeared since init into the shed
-lshed restore [profile] [--pick] [--link | --no-link] [--dry-run] [--no-backup] [--yes]
+lshed restore [profile] [--pick] [--link | --no-link] [--dry-run] [--no-backup] [--yes]   (--agent <name> to target another tool)
 lshed status                                    applied profile, drift, packages, missing env, new things
 lshed diff                                      files (or JSON keys) that differ between local and shed
 lshed save [ids...]                             copy local edits back into the shed
@@ -457,7 +482,7 @@ lshed prune [--yes]                             drop everything no profile uses
 
 Keys are `category/id`, or just `id` when unambiguous: `skills/paper-review`, `mcp/exa`, `packages/gstack`.
 
-Global options: `--shed <dir>` (or `LSHED_HOME`; after the first restore lshed remembers it), `--root <dir>` (agent config root, default `~/.claude` or `CLAUDE_CONFIG_DIR`).
+Global options: `--shed <dir>` (or `LSHED_HOME`; after the first restore lshed remembers it), `--agent <name>` (or `LSHED_AGENT`; default is the shed's `agent:`, then `claude-code`), `--root <dir>` (agent config root, default is the agent's own, e.g. `~/.claude` or `~/.codex`).
 
 ### What `restore` does