npm - editmamei - Versions diffs - 0.17.3 → 0.17.5 - Mend

editmamei 0.17.3 → 0.17.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +26 -1363
package/dist/bin/editmamei-core-darwin-arm64 +0 -0
package/dist/bin/editmamei-core-darwin-x64 +0 -0
package/dist/bin/editmamei-core-win-x64.exe +0 -0
package/dist/delivery/signing.js +3 -3
package/dist/license/env-activation.js +46 -7
package/dist/skills/editmamei-skill.zip +0 -0
package/dist/version.js +1 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -1,1391 +1,54 @@
 # Editmamei
-**Unlock Photoshop with natural-language photo editing.**
+**Unlock Photoshop with natural-language photo editing.** AI orchestration, not generation.
-_AI orchestration, not generation._
+(Pronounced like _edamame_. Yes, the snack.)
-_(Pronounced like_ edamame*. Yes, the snack.)*
+> Independent project, not affiliated with or endorsed by Adobe Inc.
-> **Note:** This is an independent project and is not affiliated with or endorsed by Adobe Inc.
-[![License: Proprietary](https://img.shields.io/badge/License-Proprietary-red.svg)](./LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)](https://www.typescriptlang.org/)
+[![npm version](https://img.shields.io/npm/v/editmamei.svg)](https://www.npmjs.com/package/editmamei)
+[![License](https://img.shields.io/badge/License-Proprietary-blue.svg)](https://editmamei.com/license)
 [![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20macOS-lightgrey.svg)]()
-You describe the edit in plain words. The AI plans the steps. Your own copy of Photoshop carries them out, using its standard adjustment layers, masks, selections, and filters. The AI directs; Photoshop edits. No generative model touches your pixels.
-Editmamei is a Model Context Protocol (MCP) server. It plugs into Claude Desktop, Cursor, or any MCP-compatible client; your AI assistant is the interface and Editmamei drives Photoshop underneath.
-## How It Works
-**You talk. Photoshop works.**
-1. **You describe the edit** in plain language ("warm up the golden hour, lift the shadows, clean up the horizon").
-2. **The AI plans the steps:** which adjustments, which selections, in what order.
-3. **Your Photoshop does the editing** on your machine, using its own standard tools.
-4. **You get a finished photo** that's fully layered, maskable, and editable. Nothing baked in.
-The AI looks at the result and refines it; Photoshop performs every actual change.
-### Edited, not generated
-Most "AI photo" tools are _generative_. They invent new pixels: skies, objects, even faces that were never in your shot. **Editmamei doesn't do that.** It works only with the pixels you captured, using the same non-generative Photoshop tools professionals have used for years: adjustment layers, masks, selections, filters. The AI is the director, not the artist. Your photo is yours, just finished faster.
+Editmamei is a Model Context Protocol (MCP) server that drives the Adobe Photoshop you already have. You describe the edit in plain words; your AI assistant plans the steps; your own copy of Photoshop carries them out with its standard adjustment layers, masks, selections, and filters. The AI directs; Photoshop edits. No generative model touches your pixels.
-### Your files, your machine
+**[editmamei.com](https://editmamei.com)** · [Docs](https://github.com/editmamei/editmamei-wiki) · [Report a bug](https://github.com/editmamei/editmamei-wiki/issues)
-Editmamei runs on your own computer, and the editing happens inside your own Photoshop. There's no Editmamei cloud your photo library gets uploaded to — no image content, no document data, and no file paths are sent to Editmamei's servers.
-Editmamei does report anonymous, content-free usage telemetry (which tools you run, whether they succeed, how long they take, and your version/OS/Photoshop version) so a small team can see what's breaking and what's used. It carries no images, no paths, and no personal data. It's on by default and easy to turn off: `editmamei config set telemetry.usage false` (or edit `~/.editmamei/settings.json`). Optional diagnostic detail for bug-hunting is off until you opt in with `editmamei config set telemetry.diagnostics true`.
-When your AI assistant needs to see the result — to verify an edit, say — Editmamei sends it a downscaled preview: to _that AI provider_, the cloud assistant you chose, the same as dropping a photo into a chat with it. That's how the AI judges its own work; it's a property of using a cloud AI, not a hop Editmamei adds.
-## Features
-- ✅ **Works on both Windows and macOS**
-- ✅ **Tested on Photoshop 2026 (v27.x)** — earlier versions may work but are unverified. Editmamei's ActionManager descriptor specs are pinned to PS 27.x ScriptListener captures, and Adobe is known to rotate event IDs between major versions; descriptor-shape workarounds for the PS 27.x bugs identified during testing are documented in [docs/20260530-ps27-cross-platform-bug-analysis.md](docs/20260530-ps27-cross-platform-bug-analysis.md).
-- ✅ **ExtendScript API**: Universal compatibility via AppleScript/COM automation
-- ✅ **Auto-Detection**: Finds Photoshop installation on your system
-- ✅ **Comprehensive tool surface**: 80+ Photoshop operations exposed as MCP tools, each with structured input/output, schema validation, and context awareness
-- ✅ **Smart selections**: Sensei-backed Select Subject / Select Sky, plus Color Range, Magic Wand, and a rich `selection_info` feedback bundle on every selection op
-- ✅ **Pipeline export**: PSD copy, JPEG/PNG export with sRGB conversion and resize
-- ✅ **Non-destructive adjustments**: Adjustment layers (curves/levels/HSL/B&C) and layer styles (shadow/stroke/glow)
-- ✅ **Live preview**: Downscaled flattened image returned inline so the AI can see what just happened
-- ✅ **Templates**: Freeze a finished edit as a reproducible recipe; apply it to a new photo by name
-- ✅ **Session telemetry**: NDJSON log of every tool call for debugging + template evidence
-- ✅ **Document management**: Create, open, save, close, crop documents
-- ✅ **Layer operations**: Create, delete, duplicate, merge, transform layers
-- ✅ **Layer properties**: Opacity, blend modes, visibility, locking
-- ✅ **Text formatting**: Font, size, color, alignment controls
-- ✅ **Image placement**: Place images, open files, fit to document
-- ✅ **Filters**: Gaussian Blur, Sharpen, Noise, Motion Blur
-- ✅ **Color adjustments**: Brightness/Contrast, Hue/Saturation, Auto Levels/Contrast
-- ✅ **Selections & masks**: Rectangular selections, layer masks
-- ✅ **History control**: Undo/Redo operations, view history states
-- ✅ **Actions**: Play recorded actions, execute custom scripts
-- ✅ **Auto-rasterize**: Converts layers when needed for filters
-- ✅ **Context tracking**: Returns document/layer state after each operation so the AI keeps a working mental model
-## Installation
-End users install from npm — see the public install guide at [editmamei-ce/docs/installation.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/installation.md):
+## Install
 ```bash
 npm install -g editmamei
-editmamei install            # registers with Claude Desktop
-editmamei status             # confirms install state + Photoshop detection
-```
-> **Note for early adopters:** `editmamei` on npm currently publishes the `0.0.0-placeholder` stub. The full release lands at v1.0.0. Until then, follow the source-build instructions below to use the current `main`.
-### Source build (contributors and pre-v1.0 users)
-```bash
-git clone https://github.com/editmamei/editmamei.git
-cd editmamei
-npm install
-npm run build              # produces dist/
-npm install -g .           # makes the `editmamei` CLI available system-wide
-```
-After this, `editmamei install` and `editmamei status` work identically to the npm-installed flow.
-## Configuration
-When you're running from a source build, `editmamei install` still wires Claude Desktop correctly. If you'd rather hand-edit the MCP client config, point it at the built `dist/index.js`. Replace the path below with the absolute path on your machine.
-### Claude Desktop
-Edit `%APPDATA%\Claude\claude_desktop_config.json` (Windows) or `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS):
-```json
-{
-  "mcpServers": {
-    "editmamei": {
-      "command": "node",
-      "args": ["C:\\absolute\\path\\to\\Editmamei\\dist\\index.js"],
-      "env": {
-        "LOG_LEVEL": "1"
-      }
-    }
-  }
-}
-```
-### Cursor
-Add to your Cursor settings (`.cursor/config.json` or workspace settings):
-```json
-{
-  "mcpServers": {
-    "editmamei": {
-      "command": "node",
-      "args": ["C:\\absolute\\path\\to\\Editmamei\\dist\\index.js"],
-      "env": {
-        "LOG_LEVEL": "1"
-      }
-    }
-  }
-}
-```
-### Environment Variables
-- `PHOTOSHOP_PATH`: (Optional) Specify custom Photoshop installation path
-- `LOG_LEVEL`: Logging level (0=DEBUG, 1=INFO, 2=WARN, 3=ERROR)
-## Example Prompts
-Drive Editmamei through Claude using natural language:
-<details>
-<summary>🎨 Basic Design Creation</summary>
-```
-Create a 1920x1080 Photoshop document with RGB color mode.
-Add a light blue background layer and fill it with RGB(240, 248, 255).
-Add centered text "Welcome" in 64pt font.
-Save as welcome.psd to my Desktop.
-```
-</details>
-<details>
-<summary>🖼️ Stock Image Design (with Pexels MCP)</summary>
-```
-Search Pexels for "mountain sunset" images.
-Create a 1920x1080 Photoshop document.
-Place the downloaded image and fit it to fill the entire canvas.
-Apply a subtle Gaussian blur of 3px.
-Increase brightness by 15 and contrast by 10.
-Add white text "Adventure Awaits" centered at the top in 72pt.
-Set the text opacity to 90% and blend mode to OVERLAY.
-Save as adventure.jpg with quality 10.
-```
-</details>
-<details>
-<summary>✨ Photo Enhancement</summary>
-```
-Open photo.jpg from my Desktop in Photoshop.
-Apply auto levels and auto contrast.
-Apply unsharp mask with amount 120%, radius 1.5, threshold 0.
-Increase saturation by 15.
-Crop to remove 100px from each edge.
-Save as enhanced-photo.jpg with quality 12.
-```
-</details>
-<details>
-<summary>🎭 Layer Effects & Blending</summary>
-```
-Create a 1200x800 document.
-Add a new layer named "Background" and fill with RGB(50, 50, 50).
-Place logo.png at position (100, 100).
-Fit the logo layer to 50% of its current size.
-Set blend mode to SCREEN and opacity to 85%.
-Add another layer, fill with RGB(255, 100, 50).
-Set this layer's blend mode to MULTIPLY and opacity to 60%.
-Merge all visible layers.
-Save as composite.psd.
-```
-</details>
-<details>
-<summary>📝 Text Poster Design</summary>
-```
-Create a 1080x1350 portrait document (Instagram story size).
-Add a layer and fill with gradient-like color RGB(120, 40, 200).
-Add text "SUMMER" at (540, 300) in 96pt.
-Change text color to white RGB(255, 255, 255).
-Set text alignment to CENTER.
-Add another text "2026" at (540, 450) in 128pt, white color.
-Apply Gaussian blur 2px to the background layer.
-Save as summer-poster.png.
-```
-</details>
-<details>
-<summary>🎬 Batch Processing</summary>
-```
-Open image1.jpg.
-Resize to 1920x1080.
-Apply auto contrast.
-Apply subtle sharpen (amount 80%, radius 1.0).
-Save as processed-1.jpg with quality 10.
-Close without saving changes to original.
-Repeat for image2.jpg and image3.jpg.
-```
-</details>
-<details>
-<summary>🖌️ Creative Manipulation</summary>
-```
-Create a 2000x2000 square document.
-Place abstract-pattern.jpg and fit to fill document.
-Duplicate the layer.
-On the duplicate, apply motion blur at 45 degrees, radius 50px.
-Set blend mode to OVERLAY and opacity to 70%.
-Add centered text "MOTION" in 120pt white.
-Apply a rectangular selection from (200, 200) to (1800, 1800).
-Invert the selection and delete (to create a border effect).
-Flatten the image.
-Save as motion-art.jpg.
-```
-</details>
-<details>
-<summary>🎯 Advanced Workflow</summary>
-```
-Create a 3000x2000 document at 300 DPI for print.
-Place hero-image.jpg and fit to fill the canvas.
-Duplicate the image layer.
-On the duplicate, desaturate it completely.
-Set blend mode to LUMINOSITY and opacity to 50%.
-Create a new layer named "Overlay".
-Fill with RGB(255, 150, 0) and set blend mode to SOFTLIGHT at 30% opacity.
-Add text "PORTFOLIO" at top center (1500, 200) in 96pt.
-Set text color to white.
-Add subtext "2026 Collection" at (1500, 320) in 36pt.
-Create a rectangular selection around the text area.
-Create a layer mask on the overlay layer.
-Merge visible layers.
-Save as portfolio-cover.psd.
-Export as portfolio-cover.jpg at quality 12.
-```
-</details>
-<details>
-<summary>🔄 Using Actions</summary>
-```
-Open my-photo.jpg.
-Play the "Vintage Look" action from "My Actions" set.
-Adjust brightness by -10 to darken slightly.
-Save as vintage-photo.jpg.
-```
-</details>
-<details>
-<summary>⚡ Custom Script Execution</summary>
-```
-Execute this custom ExtendScript code:
-app.beep();
-alert('Processing started!');
-```
-</details>
-<details>
-<summary>⏮️ Undo/Redo Operations</summary>
-```
-Apply Gaussian blur 15px to the active layer.
-[Wait for result]
-Actually, that's too much blur. Undo that.
-Apply Gaussian blur 5px instead.
-```
-Or:
-```
-Get the history states to see what operations were performed.
-Undo the last 3 operations.
-Redo 1 step to bring back one operation.
-```
-</details>
-## Available Tools
-### Tool surface conventions
-Every tool follows the same shape so MCP clients (and the LLMs they host) can plan and validate without guesswork:
-- **Input fields are snake_case** (`file_path`, `blend_mode`, `font_size`, `target_layer_name`, etc.). Older camelCase aliases are NOT accepted as of 2026-05-27.
-- **Annotations** (`title`, `readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint`) are set on every tool so clients can decide what's safe to call unprompted.
-- **Output schemas + `structuredContent`** are returned on every call. The LLM can program against parsed JSON without string-parsing.
-- **Context tracking**: tools that change _what is active_ or _what exists_ include `context: getContextInfo()` in their structured response (active document, active layer, selection state). Pure setters/filters/selectors are exempt — the LLM's mental model of "what's active" is preserved.
-- **Escape hatch**: `photoshop_execute_script` is tagged `destructiveHint + openWorldHint` and its description leads with "ESCAPE HATCH — prefer a dedicated tool when one exists." As of 2026-05-31 it ships in **Pro only** — see [docs/20260531-tool-removals.md](docs/20260531-tool-removals.md) for the tier-flip rationale.
-- **Editions**: every tool is classified `community` or `pro` in [src/core/tool-tiers.ts](src/core/tool-tiers.ts) (Pro: `photoshop_get_histogram`, `photoshop_select_subject`, `photoshop_select_sky`, `photoshop_template_create_evidence`, `photoshop_template_save`, `photoshop_template_delete`, `photoshop_execute_script`; all others community). The CE bundle excludes Pro tools at build time; runtime registration enforces the same gate as defense-in-depth. The user-facing Pro/CE split is at [editmamei-ce/docs/pro-features.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/pro-features.md).
-### Connection & Discovery
-#### `photoshop_ping`
-Test connection to Photoshop and report session-start discovery signals. Returns `connected`, plus on success: `version` (folds the former `photoshop_get_version`), `custom_action_sets` (count of user-loaded Action Sets — non-zero means `photoshop_list_actions` / `photoshop_play_action` are worth exploring), `user_templates` (count of saved Editmamei templates), and `open_documents` (names of docs already open in Photoshop). On open-ended editing tasks, follow up with `photoshop_overview` to get the workflow brief.
-```javascript
-photoshop_ping();
-```
-#### `photoshop_overview`
-Orientation brief for the entire MCP — workflow contract, capabilities map by category, verification primitives, escape-hatch policy, known gaps. Returns ~6 KB of markdown in `content[0].text`. **READ THIS FIRST when the user gives you an open-ended editing task** — the per-tool descriptions tell you what one tool does, but the overview tells you HOW to combine them (e.g. the place → preview → bounds_diff → adjust verification loop). Read-only, idempotent, no Photoshop call. Skip it for trivial single-tool requests where you already know which tool fits. Bundle R (2026-06-02).
-```javascript
-photoshop_overview();
-```
-### Document Management
-#### `photoshop_create_document`
-Create a new Photoshop document.
-**Parameters:**
-- `width` (number, required): Document width in pixels
-- `height` (number, required): Document height in pixels
-- `resolution` (number, optional): DPI resolution (default: 72)
-- `color_mode` (string, optional): Color mode - RGB, CMYK, or Grayscale (default: RGB)
-```javascript
-photoshop_create_document({
-  width: 1920,
-  height: 1080,
-  resolution: 72,
-  color_mode: 'RGB',
-});
-```
-#### `photoshop_get_metadata`
-Read metadata for the active document. Returns six sections by default: `document` (size, resolution, bit depth, color profile, layer count, saved state), `iptc` (title, author, copyright, dateCreated, keywords, location), `camera` (make/model/lens/EXIF: datetime_original, exposure_time, f_number, iso, focal_length, white_balance, flash, orientation), `gps` (lat/lon/altitude if geotagged), `acr` (Camera Raw develop settings: temperature, tint, exposure, contrast, highlights, shadows, vibrance, saturation, clarity, dehaze, sharpness), and `context` (active doc + active layer + selection state). `camera`/`gps`/`acr` read the source file directly via `exifr` and require it to still be on disk at its original path — if the document was never saved or the source has moved, those sections report unavailable with a reason.
-Pass `sections=["context"]` for a cheap orientation call that skips the IPTC traversal and the source-file read. This is the recommended call when you just need to know "what's active right now." Read-only.
-```javascript
-photoshop_get_metadata(); // everything
-photoshop_get_metadata({ sections: ['context'] }); // cheap orientation
-photoshop_get_metadata({ sections: ['camera', 'acr'] });
-```
-#### `photoshop_close_document`
-Close the active document.
-**Parameters:**
-- `save` (boolean, optional): Save before closing (default: false)
-#### `photoshop_open_document`
-Open a file from disk with all PS dialogs suppressed. Raw/HEIC formats fall back to last-used Camera Raw settings. Pipeline-oriented: returns dimensions, color mode, bit depth, and whether the source was a raw format.
-**Parameters:**
-- `file_path` (string, required): Absolute path to the file to open
-- `suppress_dialogs` (boolean, optional): Suppress all PS dialogs during open (default: true)
-```javascript
-photoshop_open_document({
-  file_path: 'E:\\Photos\\Inbox\\shell_01.heic',
-});
-```
-#### `photoshop_save_psd`
-Save the active document as a layered PSD copy. The working document's filename and dirty state are unchanged (useful in the pipeline so subsequent export calls still target the same in-memory doc).
-**Parameters:**
-- `output_path` (string, required): Absolute output path including filename
-- `maximize_compatibility` (boolean, optional): Include flattened composite for compatibility (default: true)
-```javascript
-photoshop_save_psd({
-  output_path: 'E:\\Photos\\Edit\\shell_01.psd',
-});
-```
-#### `photoshop_export_jpeg`
-Export the active document as a flattened JPEG. Optionally converts to sRGB and downscales so the long edge equals a target pixel count. Operates on a duplicate — working document is unchanged.
-**Parameters:**
-- `output_path` (string, required): Absolute output path including filename
-- `quality` (integer, optional): JPEG quality 0-12 (default: 11)
-- `long_edge_px` (integer, optional): Resize so longest edge equals this value (downscale only)
-- `embed_color_profile` (boolean, optional): Embed color profile (default: true)
-- `convert_to_srgb` (boolean, optional): Convert to sRGB before export (default: true)
-```javascript
-photoshop_export_jpeg({
-  output_path: 'E:\\Photos\\Processed\\shell_01.jpg',
-  quality: 11,
-  long_edge_px: 2400,
-});
-```
-#### `photoshop_export_png`
-Export the active document as a PNG. Choose transparent background (alpha preserved) or flattened onto white. Optionally resizes. Operates on a duplicate — working document is unchanged.
-**Parameters:**
-- `output_path` (string, required): Absolute output path including filename
-- `transparent_background` (boolean, optional): Preserve alpha (default: false → flatten onto white)
-- `long_edge_px` (integer, optional): Resize so longest edge equals this value (downscale only)
-- `compression` (integer, optional): PNG compression 0-9, lower = larger/faster (default: 6)
-```javascript
-photoshop_export_png({
-  output_path: 'E:\\Photos\\Processed\\shell_01_t.png',
-  transparent_background: true,
-});
-```
-### Layer Operations
-#### `photoshop_create_layer`
-Create a new layer.
-**Parameters:**
-- `name` (string, optional): Layer name
-#### `photoshop_delete_layer`
-**DESTRUCTIVE:** Delete a layer. With no arg, deletes the currently active layer (backward-compatible). With `name`, recurses into groups and deletes the first match — useful for cleanup workflows where the dead layer is not currently active. To delete a group and all its contents, use `photoshop_delete_group`.
-**Parameters:**
-- `name` (string, optional): Layer name to delete by recursive search (defaults to active layer when omitted)
-#### `photoshop_create_text_layer`
-Create a text layer.
-**Parameters:**
-- `text` (string, required): Text content
-- `x` (number, optional): X position in pixels (default: 100)
-- `y` (number, optional): Y position in pixels (default: 100)
-- `font_size` (number, optional): Font size in points (default: 24)
-#### `photoshop_fill_layer`
-Fill the active layer with a solid color.
-**Parameters:**
-- `red` (number, required): Red component (0-255)
-- `green` (number, required): Green component (0-255)
-- `blue` (number, required): Blue component (0-255)
-#### `photoshop_get_layer_tree`
-Get the full layer tree as nested JSON. Recursively walks groups and reports name, kind, visibility, opacity, blend mode, clipping membership, and (for art layers) bounds. The right call when you need to know what's inside a group.
-#### `photoshop_select_layer`
-Make a layer active by name. Recurses into groups; if a name appears more than once, picks the first match in stack order (top-to-bottom). Foundational for multi-layer workflows — use after `photoshop_duplicate_layer` or `photoshop_add_adjustment_layer` when you need to focus a specific layer before applying further operations.
-**Parameters:**
-- `name` (string, required): Layer name to make active
-#### `photoshop_set_layer_opacity`
-Set the opacity of the active layer.
-**Parameters:**
-- `opacity` (number, required): Opacity value (0-100)
-#### `photoshop_set_layer_blend_mode`
-Set the blend mode of the active layer.
-**Parameters:**
-- `blend_mode` (string, required): NORMAL, MULTIPLY, SCREEN, OVERLAY, etc.
-Available blend modes: NORMAL, DISSOLVE, DARKEN, MULTIPLY, COLORBURN, LINEARBURN, DARKERCOLOR, LIGHTEN, SCREEN, COLORDODGE, LINEARDODGE, LIGHTERCOLOR, OVERLAY, SOFTLIGHT, HARDLIGHT, VIVIDLIGHT, LINEARLIGHT, PINLIGHT, HARDMIX, DIFFERENCE, EXCLUSION, SUBTRACT, DIVIDE, HUE, SATURATION, COLOR, LUMINOSITY
-#### `photoshop_set_layer_visibility`
-Show or hide the active layer.
-#### `photoshop_set_layer_locked`
-Lock or unlock the active layer.
-#### `photoshop_rename_layer`
-Rename the active layer.
-#### `photoshop_duplicate_layer`
-Duplicate the active layer.
-#### `photoshop_merge_visible_layers`
-Merge all visible layers into one.
-#### `photoshop_flatten_image`
-Flatten all layers into a single background layer.
-#### `photoshop_convert_to_smart_object`
-Convert the active layer to a Smart Object so every subsequent filter becomes an editable, non-destructive Smart Filter. Prerequisite for re-editable filter workflows; works on pixel, text, shape, and adjustment layers and auto-promotes the background layer. Inverse of `photoshop_rasterize_layer`.
-#### `photoshop_rasterize_layer`
-Rasterize the active layer (convert text/smart object to normal layer). Destructive — the text/smart-object source is lost.
-#### `photoshop_add_layer_style`
-Apply a non-destructive layer style (drop shadow, stroke, or outer glow) to the active layer. Editable and removable. Drop shadow uses Multiply blend; outer glow uses Screen; stroke uses Normal.
-**Parameters:**
-- `style` (string, required): One of `drop_shadow`, `stroke`, `outer_glow`
-- `color` (object, optional): RGB color `{r, g, b}` (0-255). Defaults: black for shadow/stroke, white for glow
-- `opacity` (number, optional): Effect opacity 0-100 (default: 50)
-- `angle` (number, optional): Drop shadow only — light angle in degrees, 90 = top-down (default: 90)
-- `distance` (number, optional): Drop shadow only — shadow offset in pixels (default: 8)
-- `size` (number, optional): Drop shadow only — blur size in pixels (default: 12)
-- `spread` (number, optional): Drop shadow only — spread 0-100% (default: 0)
-- `stroke_size` (number, optional): Stroke only — width in pixels (default: 3)
-- `stroke_position` (string, optional): Stroke only — `outside` / `inside` / `center` (default: outside)
-- `glow_size` (number, optional): Outer glow only — blur size in pixels (default: 12)
-- `glow_spread` (number, optional): Outer glow only — spread 0-100% (default: 0)
-```javascript
-photoshop_add_layer_style({
-  style: 'drop_shadow',
-  color: { r: 0, g: 0, b: 0 },
-  opacity: 50,
-  distance: 12,
-});
+editmamei install   # registers with Claude Desktop, Cursor, Claude Code
+editmamei status    # confirms install state + Photoshop detection
 ```
-### Layer Ordering
-#### `photoshop_move_layer_to_position`
-Move the active layer relative to another layer.
-**Parameters:**
-- `target_layer_name` (string, required): Name of the reference layer
-- `position` (string, required): ABOVE, BELOW, TOP, or BOTTOM
-> **Removed 2026-05-31:** `photoshop_move_layer_to_top` / `_to_bottom` / `_up` / `_down` were strict subsets of `photoshop_move_layer_to_position` (TOP / BOTTOM / ABOVE+target / BELOW+target) and saw zero LLM usage in six months of session logs. See [docs/20260531-tool-removals.md](docs/20260531-tool-removals.md).
-### Group Operations
-Layer groups (LayerSets) are foundational for structured non-destructive editing — drop a stack of adjustments into a single group and you can A/B toggle the whole look via the group's visibility, or apply one mask to the composite by switching the group's blend mode to NORMAL.
-#### `photoshop_create_group`
-Create a new layer group (LayerSet) above the active layer with the given name. Optionally moves existing layers into it in one step.
-**Parameters:**
-- `name` (string, required): Name for the new group
-- `layers` (string[], optional): Existing layer names to move into the new group. The first listed name ends up on top of the group stack. Layers not found are returned in `not_found`.
-#### `photoshop_move_layer_to_group`
-Move a named layer into a named group. The layer is placed at the top of the group stack. Both names are looked up recursively.
-**Parameters:**
-- `layer_name` (string, required): Name of the layer to move
-- `group_name` (string, required): Name of the destination group
-#### `photoshop_set_group_blend_mode`
-Set a group's blend mode. Default for new groups is `PASSTHROUGH` (adjustments inside affect layers below the group). Change to `NORMAL` when treating the group as a single composite — required for masking a stack of adjustments with one mask.
-**Parameters:**
-- `name` (string, required): Group name (recursive search)
-- `blend_mode` (string, required): One of `PASSTHROUGH`, `NORMAL`, `MULTIPLY`, `SCREEN`, `OVERLAY`, `SOFTLIGHT`, `HARDLIGHT`, `COLORDODGE`, `COLORBURN`, `DARKEN`, `LIGHTEN`, `DIFFERENCE`, `EXCLUSION`, `HUE`, `SATURATION`, `COLORBLEND`, `LUMINOSITY`
-#### `photoshop_ungroup` ⚠️ DESTRUCTIVE
-Dissolve a group, leaving its contents at the parent level in their existing stack order. The group itself is removed. Requires `confirm: true`. Recoverable only via Edit > Undo.
-**Parameters:**
-- `name` (string, required): Group name to dissolve
-- `confirm` (boolean, required): Must be true
-#### `photoshop_delete_group` ⚠️ DESTRUCTIVE
-Delete a group AND ALL its contents (including nested groups and their layers). Requires `confirm: true` because the destructive scope is much larger than a single-layer delete. To dissolve a group while keeping its contents, use `photoshop_ungroup` instead.
-**Parameters:**
-- `name` (string, required): Group name to delete
-- `confirm` (boolean, required): Must be true
-#### `photoshop_create_clipping_mask`
-Clip the active layer to the layer directly below it, using that layer's pixels as the alpha source (the upper layer shows only where the lower one has content). Non-destructive. Equivalent to Layer > Create Clipping Mask. The standalone primitive — `photoshop_add_adjustment_layer` already accepts `clip_to_below` for the adjustment-layer case.
-### Layer Transformations
-#### `photoshop_fit_layer_to_document`
-Scale the active layer to fit or fill the document canvas while maintaining aspect ratio, and center it. Idempotent.
-**Parameters:**
-- `mode` (string, optional): `fit` (default) letterboxes the layer inside the canvas; `fill` covers the canvas, cropping the long edge. Both preserve aspect ratio.
-> **Bundle R (2026-06-02) — background auto-promote.** The three transform tools below (`scale_layer`, `move_layer`, `rotate_layer`) now auto-promote the background layer instead of throwing. They return `background_promoted: true` in the result so the caller sees the side-effect. No more "duplicate first" dance.
-#### `photoshop_scale_layer`
-Scale the active layer by a percentage. Auto-promotes the background layer if needed.
-**Parameters:**
-- `scale_percent` (number, required): Scale percentage (e.g., 50 for 50%, 200 for 200%)
-- `center_anchor` (boolean, optional): Scale from center (true) or top-left (false). Default: true
-#### `photoshop_move_layer`
-Translate the active layer. Three positioning modes — pass exactly one pair:
-- **Relative**: `delta_x` + `delta_y` (original behavior — offset from current position).
-- **Absolute**: `absolute_x` + `absolute_y` to land the bounds top-left at a specific document-pixel point.
-- **Center**: `center_on_x` + `center_on_y` to land the bounds CENTER at a specific point — use for "place inside the frame opening" workflows.
-Mixing modes returns a validation error. Auto-promotes the background layer if needed.
-**Parameters (delta mode):**
-- `delta_x` (number): Horizontal offset in pixels
-- `delta_y` (number): Vertical offset in pixels
-**Parameters (absolute mode):**
-- `absolute_x` (number): Target X for the layer's bounds top-left, in document pixels
-- `absolute_y` (number): Target Y for the layer's bounds top-left, in document pixels
+Then restart your AI client and ask it: _"Is Photoshop connected?"_
-**Parameters (center mode):**
+Prefer not to use a terminal? Claude Desktop users can install the one-click `.mcpb` extension from [the latest release](https://github.com/editmamei/editmamei-wiki/releases/latest). Full walkthrough in the [install guide](https://github.com/editmamei/editmamei-wiki/blob/main/docs/installation.md).
-- `center_on_x` (number): Target X for the layer's bounds CENTER, in document pixels
-- `center_on_y` (number): Target Y for the layer's bounds CENTER, in document pixels
+**Requirements:** Adobe Photoshop 2026 (v27.x), Windows 10/11 or macOS 12+, Node.js 20+ (for the npm path), and an MCP-compatible AI client.
-#### `photoshop_rotate_layer`
+## What it does
-Rotate the active layer around its center. Auto-promotes the background layer if needed.
+Editmamei gives your AI assistant a working photographer's toolkit inside Photoshop: open and save documents, build layer stacks, make selections, add non-destructive adjustments, run filters, mask, retouch, and check the result with inline previews and histograms. Your AI calls these as building blocks, so you can say _"make the sky more dramatic but keep the foreground natural"_ instead of clicking through menus.
-**Parameters:**
+The full capability surface is at [editmamei.com](https://editmamei.com). The Community and Pro split is in [pro-features.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/pro-features.md): Community is free and covers the everyday editing surface; Pro adds the reproducible-template system, Sensei-backed Select Subject and Select Sky, and Photoshop Actions plus scripting.
-- `degrees` (number, required): Rotation angle in degrees (positive = clockwise)
+## Privacy
-### Filters
+Editmamei runs on your computer and edits in your own Photoshop. No image content, document data, or file paths are sent to Editmamei's servers. It reports anonymous, content-free usage telemetry (on by default; turn it off with `editmamei config set telemetry.usage false`). When your AI assistant needs to see a result, Editmamei sends it a downscaled preview, the same as dropping a photo into a chat with that assistant. Every field is documented in [privacy.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/privacy.md).
-> **Bundle O (2026-06-01) — auto-duplicate-first.** Every filter below runs on a DUPLICATE of the active layer by default (named `<FilterName> (<Original Name>)`); the original is preserved and you can revert by deleting the copy. Pass `apply_to_active_layer: true` to bake into the original (the historical destructive behavior). See [CLAUDE.md "Auto-duplicate-first pattern"](CLAUDE.md) for the rule.
+## Docs and support
-#### `photoshop_apply_gaussian_blur`
-Apply Gaussian Blur filter to a duplicate of the active layer (default) or to the active layer in place.
-**Parameters:**
-- `radius` (number, required): Blur radius in pixels (0.1-250)
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-#### `photoshop_apply_sharpen`
-Apply Unsharp Mask (sharpen) filter to a duplicate of the active layer (default).
-**Parameters:**
-- `amount` (number, required): Sharpening amount in percent (1-500)
-- `radius` (number, required): Radius in pixels (0.1-250)
-- `threshold` (number, optional): Threshold levels (0-255, default: 0)
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-#### `photoshop_apply_noise`
-Apply Add Noise filter to a duplicate of the active layer (default).
-**Parameters:**
-- `amount` (number, required): Noise amount in percent (0.1-400)
-- `distribution` (string, optional): UNIFORM or GAUSSIAN (default: UNIFORM)
-- `monochromatic` (boolean, optional): Monochromatic noise (default: false)
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-#### `photoshop_apply_motion_blur`
-Apply Motion Blur filter to a duplicate of the active layer (default).
-**Parameters:**
-- `angle` (number, required): Blur angle in degrees (-360 to 360)
-- `radius` (number, required): Blur distance in pixels (1-999)
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-#### `photoshop_apply_lens_blur`
-Apply Lens Blur (photographically authentic depth-of-field) to a duplicate of the active layer (default). Use instead of Gaussian Blur when the goal is real DOF — portrait backgrounds, tilt-shift/miniature looks — with control over the iris shape, specular-highlight bokeh, and noise restoration. Auto-rasterizes text/smart-object layers.
-**Parameters:**
-- `radius` (number, optional): Blur radius in pixels 0-100 (default: 15) — the defining parameter
-- `iris_shape` (string, optional): `triangle` / `square` / `pentagon` / `hexagon` (default) / `heptagon` / `octagon`
-- `iris_blade_curvature` (number, optional): 0 = polygonal bokeh, 100 = circular (default: 0)
-- `iris_rotation` (number, optional): Iris rotation in degrees 0-360 (default: 0)
-- `specular_brightness` (number, optional): Highlight boost for bokeh balls 0-255 (default: 0)
-- `specular_threshold` (number, optional): Threshold above which pixels count as speculars 0-255 (default: 255)
-- `noise_amount` (number, optional): Noise restoration into the blurred region 0-100 (default: 0)
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-### Color Adjustments
-#### `photoshop_add_adjustment_layer`
-Create a non-destructive adjustment layer above the active layer. Supports the full Photoshop tonal/color surface: Curves, Levels, Hue/Saturation, Brightness/Contrast, **Black & White** (with optional tint), **Color Balance**, **Photo Filter** (preset or custom color), **Vibrance**, **Channel Mixer**, **Selective Color**, **Gradient Map** (preset), **Exposure** (stops + offset + gamma), **Color Lookup** (3DLUT presets or custom file path), and **Invert**. Optionally clips the adjustment to only affect the layer directly below it. If a selection is active at call time, the new layer is automatically masked by it (toggleable via `mask_from_selection` / `mask_inverted`). This is the canonical entry point for ALL tonal/color adjustments; the destructive bake tools (`photoshop_auto_levels` / `photoshop_auto_contrast` / `photoshop_desaturate` / `photoshop_invert`) were removed on 2026-05-31 — if you genuinely need a pixel bake, follow this call with `photoshop_merge_visible_layers`.
-**Parameters:**
-- `type` (string, required): One of `curves`, `levels`, `hue_saturation`, `brightness_contrast`, `black_and_white`, `color_balance`, `photo_filter`, `vibrance`, `channel_mixer`, `selective_color`, `gradient_map`, `exposure`, `color_lookup`, `invert`, `posterize`, `threshold`
-- `clip_to_below` (boolean, optional): Restrict effect to the layer directly below (default: false)
-- `name` (string, optional): Layer name
-- **Curves:** `curves_preset` — `linear` / `sCurveLight` / `sCurveMedium` / `sCurveStrong`
-- **Levels:** `black_point` / `white_point` / `gamma`
-- **Hue/Saturation:** `hue` / `saturation` / `lightness`
-- **Brightness/Contrast:** `brightness` / `contrast`
-- **Black & White:** `bw_reds` / `bw_yellows` / `bw_greens` / `bw_cyans` / `bw_blues` / `bw_magentas` (each −200 to +300); optional `bw_tint` boolean + `bw_tint_hue` + `bw_tint_saturation` for split-toned B&W
-- **Color Balance:** `cb_shadows_cyan_red` / `cb_shadows_magenta_green` / `cb_shadows_yellow_blue` + matching `cb_midtones_*` and `cb_highlights_*`; `cb_preserve_luminosity`
-- **Photo Filter:** either `pf_preset` (e.g. `warming_85`, `cooling_80`, `sepia`, 17 more) or `pf_color_hex`; `pf_density` (1-100, default 25); `pf_preserve_luminosity`
-- **Vibrance:** `vib_vibrance` / `vib_saturation`
-- **Channel Mixer:** `cm_monochrome` flag; in mono mode `cm_gray_from_r/g/b` + `cm_gray_constant`; in RGB mode `cm_r_from_{r,g,b}` + `cm_r_constant` for each output channel
-- **Selective Color:** `sc_method` (`relative` / `absolute`); `sc_colors` is a nested object — `{reds: {cyan, magenta, yellow, black}, blues: {...}, ...}` for any of the 9 color families
-- **Gradient Map:** `gm_preset` (`black_to_white` / `sepia` / `tint`); when preset=tint, `gm_tint_color_hex`; `gm_reverse`; `gm_dither`. Custom gradient stops are not supported in v1 — record a Photoshop Action for arbitrary gradients
-- **Exposure:** `exp_exposure` (stops, −20 to +20), `exp_offset` (−0.5 to +0.5), `exp_gamma` (0.01 to 9.99)
-- **Color Lookup:** `cl_lut_name` (validated against `Presets/3DLUTs/` or absolute path); `cl_lut_type` (`3dlut` only). **Note:** the LUT is NOT loaded — PS scripting has no entry point for the .cube/.3DL/.look parser. The layer is created empty; the artist hand-picks the LUT in PS's Properties panel, or records a Photoshop Action that applies the desired LUT preset and invokes that via the actions surface. See [docs/20260603-color-lookup-limitation.md](docs/20260603-color-lookup-limitation.md) for the full investigation.
-- **Invert:** no params — creating the layer IS the operation
-- **Posterize:** `pos_levels` (2-255, default 4)
-- **Threshold:** `thr_level` (1-255, default 128)
-- `mask_from_selection` (boolean, optional, default `true`): If true and there is an active selection, the new layer gets a mask from it. If false, any existing selection is dropped first and the layer is unmasked (full canvas).
-- `mask_inverted` (boolean, optional, default `false`): Only meaningful with `mask_from_selection: true` and an active selection. Inverts the resulting mask — useful for "I selected the sky but want to adjust everything else."
-```javascript
-photoshop_add_adjustment_layer({
-  type: 'curves',
-  curves_preset: 'sCurveMedium',
-  clip_to_below: true,
-  name: 'Contrast',
-});
-```
-> **Removed 2026-05-31:** `photoshop_auto_levels` / `photoshop_auto_contrast` / `photoshop_desaturate` / `photoshop_invert` were redundancies with `photoshop_add_adjustment_layer` (non-destructive + editable + maskable) and saw zero LLM usage in six months of session logs. To bake, use `photoshop_add_adjustment_layer` followed by `photoshop_merge_visible_layers`. See [docs/20260531-tool-removals.md](docs/20260531-tool-removals.md).
-#### `photoshop_apply_color_lookup`
-Apply a 3DLUT preset as a destructive color grade, baked onto a duplicate of the active layer (the original is preserved). This is the **only** working LUT path — the non-destructive `add_adjustment_layer type=color_lookup` form can't load a LUT via scripting (see [docs/20260603-color-lookup-limitation.md](docs/20260603-color-lookup-limitation.md)). For an editable grade, compose `selective_color` + `color_balance` + `curves`.
-**Parameters:**
-- `cl_lut_name` (string, required): Leaf name of a LUT in PS's `Presets/3DLUTs/` folder (e.g. `FallColors.look`, `Kodak 5205 Fuji 3510 (by Adobe).cube`, `TealOrangePlusContrast.3DL`) or an absolute path to a `.cube` / `.3dl` / `.look` file. Extension-agnostic leaf matching.
-- `apply_to_active_layer` (boolean, optional): Bake into the active layer instead of a copy. Default `false`.
-### Text Formatting
-#### `photoshop_set_text_font`
-Set font family and size for active text layer.
-**Parameters:**
-- `font_name` (string, required): Font family name
-- `font_size` (number, optional): Font size in points
-#### `photoshop_set_text_color`
-Set color for active text layer.
-**Parameters:**
-- `red`, `green`, `blue` (number, required): RGB components (0-255)
-#### `photoshop_set_text_alignment`
-Set text alignment.
-**Parameters:**
-- `alignment` (string, required): LEFT, CENTER, RIGHT, LEFTJUSTIFIED, CENTERJUSTIFIED, RIGHTJUSTIFIED, FULLYJUSTIFIED
-#### `photoshop_update_text_content`
-Update text content of active text layer.
-**Parameters:**
-- `text` (string, required): New text content
-### Selections & Masks
-**Common `selection_type` arg** on every selection-creating tool: `replace` (default) overwrites the current selection; `add` unions with it; `subtract` removes this region from it; `intersect` keeps the overlap.
-**Common `selection_info` return** on every selection tool: a rich post-op stats bundle the agent uses to verify what got selected — bounds, coverage-weighted `pixel_count`, `area_percent`, `bounds_fill_ratio` (low = patchy selection), `edge_complexity` (high = soft/feathered edge), plus `fully_selected_pixels` / `partial_pixels` breakouts. Computed in ~150-300ms by routing the selection through a temp alpha channel histogram. Use these numbers before committing a mask; if they look off, call `photoshop_get_selection_preview` for a visual.
-#### `photoshop_select_rectangle`
-Create a rectangular selection. Optional `feather_px` softens the edge — essential for regional adjustments in smooth areas (open sky bands visibly without it).
-**Parameters:**
-- `left`, `top`, `right`, `bottom` (number, required): Selection bounds in pixels
-- `feather_px` (number, optional): Soften the selection edge by this many pixels (default: 0). Typical values 40-180.
-- `selection_type` (string, optional): `replace` (default), `add`, `subtract`, `intersect`.
-#### `photoshop_select_subject`
-**Smart selection** via Adobe Sensei's on-device subject-detection model. One-call selection of the main subject — person, animal, product, etc. ~2-5s typical. Killer for portrait masking. Combines via `selection_type`.
-**Parameters:**
-- `selection_type` (string, optional): default `replace`.
-#### `photoshop_select_sky`
-**Smart selection** via Adobe Sensei's sky detection. One-call sky masking for landscape work. On tricky horizons (foreground objects against sky), `selection_info.edge_complexity` will be high — verify with `photoshop_get_selection_preview` before committing.
-**Parameters:**
-- `selection_type` (string, optional): default `replace`.
-#### `photoshop_magic_wand`
-Click-point selection by color similarity. Equivalent to the Magic Wand tool — clicks at (x, y) and selects all pixels within `tolerance` of that color. Often needs 2-3 iterations adjusting tolerance; use the returned `selection_info` (and `photoshop_get_selection_preview` if needed) to gauge whether to widen or narrow.
-**Parameters:**
-- `x`, `y` (integer, required): Click coords in document pixel space.
-- `tolerance` (integer 0-255, optional, default 32): Color similarity threshold.
-- `contiguous` (boolean, optional, default true): Restrict to connected matching pixels.
-- `anti_alias` (boolean, optional, default true): Soften the edge.
-- `sample_all_layers` (boolean, optional, default false): Sample color across all visible layers.
-- `selection_type` (string, optional): default `replace`.
-#### `photoshop_select_color_range`
-Select all pixels matching a target RGB color within a fuzziness threshold. Equivalent to Select > Color Range. Use for "select all the red," "select skin tones," etc. Combine multiple calls with `selection_type: 'add'` to capture related color ranges.
-**Parameters:**
-- `red`, `green`, `blue` (integer 0-255, required): Target color.
-- `fuzziness` (integer 0-200, optional, default 40): Tolerance — higher selects a wider color range.
-- `selection_type` (string, optional): default `replace`.
-#### `photoshop_get_selection_info`
-Read the current selection state without modifying anything. Returns the same `selection_info` bundle (bounds, coverage-weighted `pixel_count`, `area_percent`, `bounds_fill_ratio`, `edge_complexity`, etc.) that selection-creating tools embed in their return. Use this as a **pre-flight check** when you start a workflow and aren't sure whether a selection is already active — a previous tool may have failed mid-way and left a stale selection that would corrupt a downstream mask. Cheap (~200ms). For a visual instead of stats, use `photoshop_get_selection_preview`.
-#### `photoshop_get_selection_preview`
-Render TWO inline JPEGs so the agent can visually verify what's currently selected: (1) an **overlay** of the document with a 50% red wash over the selected area (Quick Mask-style — most intuitive), and (2) a **B/W mask** where black = selected. Heavier than reading `selection_info` (~2-4s) — reach for it when the stats look off or before committing a layer mask. Does NOT modify the source document.
-**Parameters:**
-- `max_dimension` (integer 128-4096, optional, default 800): Long-edge pixel cap for both returned images.
-#### `photoshop_feather_selection`
-Feather (soften) the current selection by a pixel radius. Use this when a selection was created without a feather (e.g. `select_all`, `invert_selection`, `select_subject`) or when an existing selection needs further softening before applying an adjustment. Throws if no active selection. After feathering, `selection_info.edge_complexity` rises noticeably.
-**Parameters:**
-- `radius_px` (number, required): Feather radius in pixels (> 0)
-#### `photoshop_select_all`
-Select the entire document canvas. Returns `selection_info` with `area_percent: 100`.
-#### `photoshop_deselect`
-Clear the active selection. Returns `selection_info` with `has_selection: false`.
-#### `photoshop_invert_selection`
-Invert the current selection. NOT idempotent.
-#### `photoshop_delete_layer_mask`
-Delete the layer mask from the active layer. The underlying layer pixels are NOT lost.
-#### `photoshop_apply_layer_mask`
-**DESTRUCTIVE (bakes into pixels):** Permanently apply the layer mask to the layer pixels (Apply Mask). Pixels outside the mask are lost and the mask is removed.
-#### `photoshop_save_selection_to_channel`
-Save the current active selection to a named alpha channel. If a channel with that name already exists it is overwritten in place (returns `overwritten: true`); otherwise a new channel is created. Use to checkpoint complex or expensive selections so they can be recalled later — particularly useful before a multi-step refinement loop where you want to restore the base selection if the refinement overshoots.
-**Parameters:**
-- `channel_name` (string, required): Name for the alpha channel to save into (creates it if it doesn't exist, overwrites if it does)
-**Returns:** `saved`, `channel_name`, `overwritten`, `channel_count` (total channels in document after save), `selection_info`
-#### `photoshop_load_selection_from_channel`
-Load a previously saved alpha channel back as an active selection. Supports all four boolean combination modes (`replace`, `add`, `subtract`, `intersect`) so you can compose multi-channel masks without losing the current selection. Use after `photoshop_save_selection_to_channel` to restore a checkpoint, or combine two saved channels by loading each in turn with `add`/`subtract`.
-**Parameters:**
-- `channel_name` (string, required): Name of the alpha channel to load
-- `operation` (string, optional): `replace` (default), `add`, `subtract`, or `intersect` — how the loaded selection combines with any existing active selection
-**Returns:** `loaded`, `channel_name`, `operation`, `selection_info`
-### History & Undo/Redo
-#### `photoshop_undo`
-Undo the last operation(s) - equivalent to Ctrl/Cmd+Z.
-**Parameters:**
-- `steps` (number, optional): Number of steps to undo (default: 1)
-#### `photoshop_redo`
-Redo previously undone operation(s) - equivalent to Ctrl/Cmd+Shift+Z.
-**Parameters:**
-- `steps` (number, optional): Number of steps to redo (default: 1)
-#### `photoshop_get_history`
-Get the history states of the active document.
-### Actions & Automation
-#### `photoshop_list_actions`
-Enumerate the Photoshop Actions palette. Returns every Action Set and the actions inside it. Read-only and cheap. Call this BEFORE `photoshop_play_action` so you know which `action_name` + `action_set_name` combinations actually exist — `play_action` throws on unknown names and has no other way to enumerate them.
-```javascript
-photoshop_list_actions();
-// → { count: 2, sets: [{ name: "Default Actions", actions: ["Vignette", "Sepia"] }, ...] }
-```
-#### `photoshop_play_action`
-Play a recorded action from the Actions palette. Call `photoshop_list_actions` first to discover valid names.
-**Parameters:**
-- `action_name` (string, required): Action name
-- `action_set_name` (string, required): Action set name
-#### `photoshop_execute_script` _(Pro)_
-Execute custom ExtendScript code (advanced). **Pro tier as of 2026-05-31** — see [docs/20260531-tool-removals.md](docs/20260531-tool-removals.md) for the rationale. CE callers fall back to `photoshop_play_action` for any user-recorded workflow that covers the same operation.
-**Parameters:**
-- `code` (string, required): ExtendScript code
-### Image Manipulation
-#### `photoshop_resize_image`
-Resize the active image.
-**Parameters:**
-- `width` (number, required): New width in pixels
-- `height` (number, required): New height in pixels
-#### `photoshop_crop_document`
-Crop the document to specified bounds.
-**Parameters:**
-- `left`, `top`, `right`, `bottom` (number, required): Crop bounds in pixels
-#### `photoshop_place_image`
-Place an image file as a layer in the active document.
-**Parameters:**
-- `file_path` (string, required): Full path to the image file
-- `x` (number, optional): X position offset in pixels (default: 0)
-- `y` (number, optional): Y position offset in pixels (default: 0)
-### Preview & Verification
-#### `photoshop_get_preview`
-Render the active Photoshop document as a flattened, downscaled image and return it inline so the AI can see the current visual state. Read-only with respect to the working document (renders a duplicate that's closed immediately). The optional `annotations` array draws document-space overlays in two families: **spatial verification** (rectangles, guides, points, current-selection markers — Bundle Q, 2026-06-02) and **coordinate / compositional overlays** (regular grids, rule-of-thirds, golden-ratio guides, golden spiral, diagonals, triangles — 2026-06-09). Use spatial overlays to verify placement ("did the layer land inside the frame?"); use grids when you need to translate a visual judgment ("subject is in the lower-left third") into pixel coordinates for a downstream tool call; use composition overlays to evaluate balance, leading lines, and focal-point placement against canonical photographic frameworks.
-**Parameters:**
-- `max_dimension` (integer, optional): Cap on the long edge in pixels, 64-8192 (default: 1024)
-- `format` (string, optional): `jpeg` (smaller) or `png` (preserves transparency, lossless). Default: `jpeg`
-- `quality` (integer, optional): JPEG quality 1-12. Ignored for PNG. Default: 6
-- `annotations` (array, optional): List of annotations to draw onto the preview. Each is one of:
-  - `{ type: "rectangle", left, top, right, bottom, color, label, stroke_width }` — wireframe rectangle at explicit bounds
-  - `{ type: "rectangle", layer: "<name>", color, label }` — wireframe around a layer's bounds (tool reads them via the layer tree)
-  - `{ type: "guide", orientation: "horizontal"|"vertical", pixel, canvas_pct, color, label }` — reference line
-  - `{ type: "point", x, y, marker: "cross"|"dot"|"crosshair", color, label }` — point marker
-  - `{ type: "selection", color, label }` — outline the current active selection
-  - `{ type: "grid", style: "every"|"thirds"|"quarters"|"phi", spacing_px, color, label }` — regular grid for coordinate readout. `every` uses `spacing_px` (default 50); `thirds` draws 2 horizontal + 2 vertical lines at the 1/3 / 2/3 marks; `quarters` is a center crosshair; `phi` is the golden-ratio analog of thirds at 0.382 / 0.618.
-  - `{ type: "composition", style: "diagonals"|"triangles"|"fibonacci_grid"|"golden_spiral", orientation_corner: "tl"|"tr"|"bl"|"br", color, label }` — compositional guides. `diagonals` draws a corner-to-corner X; `triangles` is the diagonal plus perpendiculars from the opposite corners (the "golden triangles" composition); `fibonacci_grid` draws nested golden-ratio rectangles from the named corner; `golden_spiral` is `fibonacci_grid` plus the iconic spiral curve through it. Default corner `tl`.
-  - `color` accepts named (`red`, `blue`, `green`, `yellow`, `magenta`, `cyan`, `orange`, `white`, `black`) or hex (`#RRGGBB`). Default `red`. Default stroke width 4 px.
-```javascript
-photoshop_get_preview({
-  max_dimension: 1500,
-  annotations: [
-    {
-      type: 'rectangle',
-      left: 1060,
-      top: 820,
-      right: 3890,
-      bottom: 2690,
-      color: 'red',
-      label: 'target',
-    },
-    { type: 'rectangle', layer: 'Sunset', color: 'blue', label: 'actual' },
-  ],
-});
-```
-#### `photoshop_get_layer_bounds_diff`
-Numeric verification: compute the per-edge pixel deltas between a layer's actual bounds and a target rectangle. Returns deltas (actual − target), scale ratio, centroid offset, and a one-word verdict (`aligned`, `shifted right`, `layer too small`, etc.). Use after `place_image` / `scale_layer` / `move_layer` to confirm intended placement — far more reliable than eyeballing a preview for fine alignment.
-**Parameters:**
-- `layer` (string, required): Layer name (searched recursively through groups)
-- `target_left`, `target_top`, `target_right`, `target_bottom` (number, required): Target rectangle in document pixels
-- `tolerance_px` (number, optional, default 10): Tolerance for the "aligned" verdict
-#### `photoshop_compare_regions`
-Quantitative region comparison: capture the histogram of two rectangular regions on the same document and report per-channel mean / stdev / median for each, plus differences between them. Use to verify color or tonal claims about specific areas ("is the sky region noticeably bluer than the foreground?"). Single-pixel sampling supported (1×1 rect).
-**Parameters:**
-- `region_a_left`, `region_a_top`, `region_a_right`, `region_a_bottom` (number, required): Region A bounds
-- `region_b_left`, `region_b_top`, `region_b_right`, `region_b_bottom` (number, required): Region B bounds
-- `label_a`, `label_b` (string, optional): Labels for the regions in the response
-#### `photoshop_get_histogram`
-Read the histogram of the active document for a given channel. Returns 256 bin counts plus `mean`, `stdev`, and `median`. Cheap (~50ms) and read-only. **Use as a verification primitive**: capture a histogram before and after a destructive op to confirm pixels actually changed. If two histograms are identical, the op was a no-op — don't trust a tool's success message alone. Composite reads the visible flattened image (works in any color mode); per-channel reads work only on documents that have that channel.
-**Parameters:**
-- `channel` (string, optional): `composite` (default), `red`, `green`, `blue`, `luminosity`, or `gray`
-### Templates _(Pro)_
-> **The entire template surface is Pro** (as of 2026-06-16). Authoring (`create_evidence` / `save` / `delete`) and use (`list` / `apply` / `verify` / `recall`) are all Pro-tier — templates are the reproducible-recipe / learning-loop layer and ship as one paid feature.
-The template system lets the photographer freeze a finished edit as a reproducible recipe. After Claude finishes editing a photo to satisfaction, ask it to create a template; the next time you want the same look on a different photo, ask Claude to apply that template by name. Templates live as plain markdown files at `~/.editmamei/templates/<slug>/template.md` alongside before/after thumbnails — you can hand-edit them in any text editor.
-The synthesis is a two-step flow. Step 1 (`photoshop_template_create_evidence`) gathers everything Claude needs: every tool call made in the current session, every Photoshop history state, full image metadata, and rendered before/after thumbnails. Step 2 (`photoshop_template_save`) accepts the markdown Claude authored and writes the bundle to disk.
-#### `photoshop_template_create_evidence`
-Step 1 of 2: gather the three evidence layers needed to author a template — session tool calls (from the Phase 2 telemetry log), Photoshop history states, and full metadata snapshot. Renders before.jpg (history[0]) and after.jpg (current state) inline. Read-only.
-**Parameters:**
-- `name` (string, required): Human-readable template name (sanitized to a filesystem-safe slug for storage)
-```javascript
-photoshop_template_create_evidence({ name: 'Warm Portrait' });
-// Then draft the template.md content based on the returned evidence,
-// then call photoshop_template_save.
-```
-#### `photoshop_template_save`
-Step 2 of 2: write Claude's authored markdown + freshly re-rendered before/after JPEGs + evidence.json bundle to `~/.editmamei/templates/<slug>/`. Re-renders previews at save time so the saved bundle always matches the current document state.
-**Parameters:**
-- `name` (string, required): Template name (will be slug-sanitized)
-- `md_content` (string, required): Full template.md body with YAML frontmatter
-- `overwrite` (boolean, optional): Replace an existing template (default: false; errors on collision)
-#### `photoshop_template_list`
-List all saved templates with parsed frontmatter descriptors (slug, display name, intent, created date, source camera, tags). Read-only. Sorted newest first.
-```javascript
-photoshop_template_list();
-```
-#### `photoshop_template_apply`
-Load a template by name and return its markdown + before/after thumbnails as inline content. Does NOT directly edit the active document — Claude reads the template as guidance and drives the existing `photoshop_*` pipeline tools to match the look, using `photoshop_get_preview` to self-judge against the template's exit criteria.
-The response orders **text first** so the markdown instructions reach the agent even if MCP truncates the trailing payload. Thumbnails are inlined when their combined base64 size fits under the MCP 1 MB response cap; oversized bundles degrade gracefully to text-only and flag `images_included:false` in `structuredContent`.
-**Parameters:**
-- `name` (string, required): Template slug (use `photoshop_template_list` to discover)
-```javascript
-photoshop_template_apply({ name: 'warm-portrait' });
-```
-#### `photoshop_template_verify`
-Evaluate the active document against a template's **signature** — machine-checkable style assertions (`signature.json`) authored at save time via `photoshop_template_save`'s `signature_content` arg. Returns per-predicate `pass | fail | skipped` with measured-vs-target detail and a one-line corrective steer per failure, turning "matches the look" into a measurement. Predicates are relative/scale-invariant (channel orderings, clipping ceilings, tonal points, subject-vs-background relations) so they transfer across photos.
-Regions resolve relationally (Select Subject / Select Sky + inversion); when those are unavailable the affected predicates report `skipped`, never `failed`. Measurement transiently changes the document's selection state and ends deselected — pixels are never modified. Templates without a signature return an explanatory error.
-**Parameters:**
-- `name` (string, required): Template slug (use `photoshop_template_list` to discover)
-```javascript
-photoshop_template_verify({ name: 'warm-portrait' });
-```
-#### `photoshop_template_recall`
-Re-surface one section of a template as **text only** — no images, no full recipe. Built for long edit sessions where the template body is tens of thousands of tokens back in context: recall the binding tier cheaply instead of re-running `photoshop_template_apply`. Read-only, filesystem-only.
-**Parameters:**
-- `name` (string, required): Template slug
-- `section` (string, optional, default `exit_criteria`): One of `exit_criteria`, `tune`, `fixed`, `intent`, `signature`
-```javascript
-photoshop_template_recall({ name: 'warm-portrait' }); // exit criteria
-photoshop_template_recall({ name: 'warm-portrait', section: 'tune' });
-```
-#### `photoshop_template_delete`
-Delete a template by name. Destructive and irreversible. Pass `confirm: true` to acknowledge.
-**Parameters:**
-- `name` (string, required): Template slug
-- `confirm` (boolean, required): Must be true
-## Context Tracking
-Each tool returns comprehensive context information about the current state of Photoshop, including:
-- **Document Info**: Name, dimensions, resolution, color mode, layer count
-- **Active Layer Info**: Name, type, opacity, blend mode, visibility, lock state
-- **Selection State**: Whether a selection is active
-- **Operation Result**: Specific details about what was changed
-This allows AI assistants to maintain awareness of:
-- Which document is active
-- Which layer is being worked on
-- Current layer properties (opacity, blend mode, etc.)
-- Document dimensions and settings
-**Example Response:**
-```javascript
-{
-  "applied": true,
-  "filter": "Gaussian Blur",
-  "radius": 10,
-  "wasRasterized": true,
-  "context": {
-    "hasDocument": true,
-    "document": {
-      "name": "design.psd",
-      "width": 1920,
-      "height": 1080,
-      "resolution": 72,
-      "colorMode": "RGBColorMode",
-      "layerCount": 3,
-      "hasSelection": false
-    },
-    "activeLayer": {
-      "name": "Background",
-      "kind": "NORMAL",
-      "opacity": 100,
-      "blendMode": "NORMAL",
-      "visible": true,
-      "locked": false,
-      "isBackground": false
-    }
-  }
-}
-```
-## Platform-Specific Notes
-### Windows
-- Uses COM automation to communicate with Photoshop
-- Registry-based auto-detection for installation paths
-- Supports both 32-bit and 64-bit versions
-### macOS
-- Uses AppleScript/OSA for Photoshop communication
-- Spotlight-based auto-detection
-- Supports multiple Photoshop versions installed simultaneously
-## Supported Photoshop Versions
-- **Tested on Photoshop 2026 (internal version 27.x).** This is the only version Editmamei has been verified against; ScriptListener captures pinning ActionManager descriptor specs come from PS 27.x sessions on both Windows and macOS.
-- **Earlier versions are unverified.** Editmamei may run on Photoshop 2025 / 2024 / 2023 / 2022 — the DOM-level APIs and many AM events are stable across recent majors — but Adobe rotates event IDs between major versions, and silent-no-op descriptor failures on untested PS versions cannot be ruled out. The auto-detector still probes older install paths so power users can try; failing tools on those versions are a known unsupported-version risk, not a bug.
-- **PS 27.x bug roster.** Several PS 27.x descriptor regressions are worked around in current builds — see [docs/20260530-ps27-cross-platform-bug-analysis.md](docs/20260530-ps27-cross-platform-bug-analysis.md) for the roster and which are fixed vs deferred.
-- ExtendScript API via AppleScript (macOS) or COM (Windows). ExtendScript is the only path that works for external automation — UXP cannot be invoked from outside Photoshop (see CLAUDE.md "Why ExtendScript only").
-## Troubleshooting
-### "Photoshop not found"
-1. Make sure Photoshop is installed in the default location
-2. Or set `PHOTOSHOP_PATH` environment variable to custom installation path
-```json
-{
-  "env": {
-    "PHOTOSHOP_PATH": "C:\\Custom\\Path\\Adobe Photoshop 2026\\Photoshop.exe"
-  }
-}
-```
-### "Failed to connect to Photoshop"
-1. Ensure Photoshop is running (the server will try to launch it if not)
-2. Check that scripting is enabled in Photoshop preferences
-3. On Windows, verify COM automation is not blocked by security settings
-### "Script execution timeout"
-- Some operations may take longer on large documents
-- The default timeout is 30 seconds
-- For complex operations, consider breaking them into smaller steps
-### Debug Logging
-Enable detailed logging by setting `LOG_LEVEL=0`:
-```json
-{
-  "env": {
-    "LOG_LEVEL": "0"
-  }
-}
-```
-## Development
-### Build
-```bash
-npm run build
-```
-### Watch Mode
-```bash
-npm run dev
-```
-### Lint & Format
-```bash
-npm run lint
-npm run format
-```
-## Architecture
-```
-Editmamei/
-├── src/
-│   ├── core/              # MCP server core
-│   │   ├── server.ts      # Main MCP server (EditmameiServer)
-│   │   ├── session.ts     # Session management
-│   │   └── tool-registry.ts  # Tool registration system
-│   ├── platform/          # Platform-specific detection & execution
-│   │   ├── detector.ts    # Main detector
-│   │   ├── connection.ts  # Connection manager
-│   │   ├── script-executor.ts   # Cross-platform script execution
-│   │   ├── windows-detector.ts  # Windows registry detection
-│   │   ├── windows-executor.ts  # Windows COM automation
-│   │   ├── macos-detector.ts    # macOS Spotlight detection
-│   │   └── macos-executor.ts    # macOS AppleScript execution
-│   ├── api/              # Photoshop API abstractions
-│   │   ├── photoshop-api.ts    # API factory
-│   │   ├── batch-play.ts       # UXP batchPlay helpers (legacy)
-│   │   └── extendscript.ts     # ExtendScript snippets library
-│   ├── tools/            # MCP tool implementations (50+ tools)
-│   │   ├── document-tools.ts
-│   │   ├── layer-tools.ts
-│   │   ├── layer-properties-tools.ts
-│   │   ├── layer-transform-tools.ts
-│   │   ├── layer-ordering-tools.ts
-│   │   ├── image-tools.ts
-│   │   ├── image-placement-tools.ts
-│   │   ├── filter-tools.ts
-│   │   ├── adjustment-tools.ts
-│   │   ├── text-tools.ts
-│   │   ├── selection-tools.ts
-│   │   ├── history-tools.ts
-│   │   ├── action-tools.ts
-│   │   └── preview-tools.ts
-│   ├── utils/            # Utilities
-│   │   └── logger.ts     # Logging system (stderr-based)
-│   └── index.ts          # Entry point
-├── examples/             # Configuration examples
-│   ├── cursor-config.json
-│   └── claude-desktop-config.json
-├── LICENSE               # Proprietary license
-├── NOTICES.md            # Third-party attributions (MIT upstream + deps)
-└── server.json           # MCP registry metadata
-```
+- **Features and pricing:** [editmamei.com](https://editmamei.com)
+- **Install, getting started, FAQ, Pro features:** [the wiki](https://github.com/editmamei/editmamei-wiki)
+- **Bugs and feature requests:** [the issue tracker](https://github.com/editmamei/editmamei-wiki/issues)
+- **Security:** see [editmamei.com/security](https://editmamei.com/security) (don't file security issues publicly)
 ## License
-This software is proprietary. See [LICENSE](./LICENSE) for full terms.
-Editmamei incorporates code originally licensed under the MIT License. Required attributions are provided in [NOTICES.md](./NOTICES.md).
-## Acknowledgments
-Editmamei is a derivative work originally based on [photoshop-mcp](https://github.com/alisaitteke/photoshop-mcp) by Ali Sait Teke, released under the MIT License. Significant portions have been rewritten, extended, or replaced.
+Proprietary, free to install and use. See [the license](https://editmamei.com/license). Third-party dependencies keep their own licenses, listed in the bundled `NOTICES.md`.
-Built with the [Model Context Protocol SDK](https://github.com/modelcontextprotocol/sdk).
+---
-"Adobe" and "Photoshop" are trademarks of Adobe Inc. This project is not affiliated with, endorsed by, or sponsored by Adobe Inc.
+_Pairs well with: a layered PSD, a willing AI, and a small bowl of edamame._