editmamei 1.1.0 → 1.2.0

package/README.md

@@ -75,7 +75,7 @@ These are the choices that shape the surface, and the reason an AI assistant can
 
 ## Tool surface
 
-**82 tools across 16 capability groups** (59 Community, 23 Pro). Every tool is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license. `tools/list` reports eight more than the table below: the names superseded by `filter`, `group`, and `text` (`apply_filter`, `create_group`, `move_layer_to_group`, `set_group_blend_mode`, `ungroup`, `delete_group`, `create_text_layer`, `set_text`) stay registered as deprecated aliases for one release, so existing calls keep working.
+**79 tools across 16 capability groups** (59 Community, 20 Pro). Every tool is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license.
 
 | Group | Edition | Tools |
 | --- | --- | --- |
@@ -94,11 +94,11 @@ These are the choices that shape the surface, and the reason an AI assistant can
 | **AI selection** | Community | `select_subject` · `select_sky` |
 | **AI selection** | Pro | `select_subject_instance` · `select_object` |
 | **Filters** | Pro | `apply_camera_raw` |
-| **Layers (warp)** | Pro | `warp_layer` · `warp_layer_mesh` · `warp_layer_along` · `warp_layer_region` · `warp_layer_to` |
+| **Layers (warp)** | Pro | `warp_layer` |
 | **Perception** | Pro | `edit_object` · `add_text_to_object` · `resolve_placement` |
 | **Face mesh** | Pro | `detect_landmarks` · `select_face_feature` |
 | **Templates** | Pro | `template_create_evidence` · `template_save` · `template_list` · `template_apply` · `template_verify` · `template_recall` · `template_delete` |
-| **Automation** | Pro | `list_actions` · `play_action` · `execute_script` |
+| **Automation** | Pro | `list_actions` · `play_action` · `execute_script` · `batch` |
 
 ## Editions
 

package/dist/api/extendscript/_helpers.js

@@ -27,12 +27,13 @@ function __notFoundMessage(label, requested, groupsOnly) {
     var out = '';
     for (var c = 0; c < s.length; c++) {
       var code = s.charCodeAt(c);
-      if (code >= 32 && code <= 126 && code !== 92) {
-        out += s.charAt(c);
-      } else {
+      // Control characters and backslash only — see the doc comment above.
+      if (code < 32 || code === 127 || code === 92) {
         var hex = code.toString(16);
         while (hex.length < 4) hex = '0' + hex;
         out += '\\\\u' + hex;
+      } else {
+        out += s.charAt(c);
       }
     }
     return out;
@@ -47,6 +48,11 @@ function __notFoundMessage(label, requested, groupsOnly) {
       nm = nm.substring(0, 40);
       var cut = nm.lastIndexOf('\\\\u');
       if (cut > 34) nm = nm.substring(0, cut);
+      // Non-ASCII is no longer escaped, so the cut counts raw UTF-16 units and
+      // can land between the halves of a surrogate pair. Drop a trailing high
+      // surrogate rather than emit a lone one.
+      var lastCode = nm.length > 0 ? nm.charCodeAt(nm.length - 1) : 0;
+      if (lastCode >= 0xD800 && lastCode <= 0xDBFF) nm = nm.substring(0, nm.length - 1);
       nm = nm + '...';
     }
     kept.push(nm);

package/dist/api/photoshop-api.js

@@ -55,6 +55,21 @@ class ExtendScriptPhotoshopAPI {
   // numbers, booleans, null/undefined, arrays, and plain objects. Cycles
   // and very deep nesting are capped via __depth to avoid stack overflow
   // on pathological inputs.
+  //
+  // Everything outside printable ASCII is escaped as a JSON u-escape, not
+  // just the control range. The Windows cscript stdout transport is
+  // codepage-bound and flattens raw non-ASCII to '?' (measured live,
+  // PS 27.2.0), so a layer Photoshop named itself in a non-English UI —
+  // 'Farbfuellung 1' spelled with the u-umlaut — used to reach the caller as
+  // 'Farbf?llung 1'. Naming that layer back at us then missed, because '?'
+  // is not what the layer is called. The escape is valid JSON, survives the
+  // transport, and JSON.parse restores the exact character, so the round trip
+  // is lossless rather than merely legible. Every outcome the script itself
+  // produces routes through here, errors included, so this covers messages as
+  // well as values. It does NOT cover the Windows shim's own COM failures
+  // (windows-runner.ts echoes Err.Description straight to stdout), nor raw
+  // non-ASCII sitting in a snippet's own source text — that arrives by a
+  // different path and is not addressed here.
   function __mcpJsonEncode(v, __depth) {
     if (__depth === undefined) __depth = 0;
     if (__depth > 32) return '"<<truncated:max-depth>>"';
@@ -72,7 +87,7 @@ class ExtendScriptPhotoshopAPI {
         else if (c === '\\t') s += '\\\\t';
         else if (c === '\\b') s += '\\\\b';
         else if (c === '\\f') s += '\\\\f';
-        else if (cc < 32) {
+        else if (cc < 32 || cc > 126) {
           var hex = cc.toString(16);
           while (hex.length < 4) hex = '0' + hex;
           s += '\\\\u' + hex;

package/dist/core/server.js

@@ -13,6 +13,7 @@ import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride,
 import { TelemetryClient } from '../telemetry/client.js';
 import { resolveInstallChannel } from '../install-channel.js';
 import { checkForUpdate, shouldCheckForUpdate } from '../update/check.js';
+import { previousSessionFailureCounts, relevantFixes } from '../update/session-fixes.js';
 import { join } from 'node:path';
 import { GoSnippetClient, coreBinaryName } from '../api/snippet-client.js';
 import { isProEntitled } from '../license/entitlement.js';
@@ -63,6 +64,8 @@ export class EditmameiServer {
     lastPingReachedPs = null;
     liveVersionResolutionAttempted = false;
     updateInfo = null;
+    updateCheck = null;
+    updateNoticeShown = false;
     snippetClient = new GoSnippetClient();
     refreshLicenseOnPing = createPingLicenseRefresher();
     constructor() {
@@ -82,7 +85,7 @@ export class EditmameiServer {
         if (created)
             this.logger.info(FIRST_RUN_DISCLOSURE);
         if (shouldCheckForUpdate(effectiveSettings.update_check)) {
-            void checkForUpdate().then((info) => {
+            this.updateCheck = checkForUpdate().then((info) => {
                 this.updateInfo = info;
             });
         }
@@ -102,18 +105,23 @@ export class EditmameiServer {
                     ...(entry.error ? { error: entry.error } : {}),
                 }, entry.result);
                 const telemetrySuccess = entry.tool === 'ps_ping' && this.lastPingReachedPs === false ? false : entry.success;
-                const errorClass = classifyError(entry.error);
+                const isPingDowngrade = entry.tool === 'ps_ping' && !telemetrySuccess && entry.error === undefined;
+                const errorClass = classifyError(entry.error) ??
+                    (telemetrySuccess ? null : isPingDowngrade ? 'ps_not_running' : 'other');
                 this.telemetry.recordCall({
                     tool: entry.tool,
                     success: telemetrySuccess,
                     duration_ms: entry.duration_ms,
                     error_class: errorClass,
                 });
-                if (!entry.success && entry.error) {
+                if (!telemetrySuccess) {
                     this.telemetry.recordDiagnostic({
                         tool: entry.tool,
                         error_class: errorClass ?? 'other',
-                        error_message: entry.error,
+                        error_message: entry.error ||
+                            (isPingDowngrade
+                                ? 'ps_ping did not reach Photoshop'
+                                : 'tool reported failure with no message'),
                     });
                 }
             },
@@ -155,14 +163,19 @@ export class EditmameiServer {
                         },
                         update_available: {
                             type: ['object', 'null'],
-                            description: 'Set when a newer Editmamei version is published, else null. When present, TELL THE USER: relay current → latest and how_to_update verbatim. { current, latest, channel (npm/mcpb/dev), how_to_update }. Anonymous npm-registry check at boot; opt out with `editmamei config set update_check false`.',
+                            description: 'Set when a newer Editmamei version is published, else null: { current, latest, channel (npm/mcpb/dev), how_to_update, fixed_tools (tools whose recorded failures the newer version fixes) }. The relay instruction rides the ping TEXT on the first ping — see notify_user. Anonymous npm-registry check at boot; opt out with `editmamei config set update_check false`.',
                             properties: {
                                 current: { type: 'string' },
                                 latest: { type: 'string' },
                                 channel: { type: 'string' },
                                 how_to_update: { type: 'string' },
+                                fixed_tools: { type: 'array', items: { type: 'string' } },
                             },
                         },
+                        notify_user: {
+                            type: 'boolean',
+                            description: 'True on the one ping whose text carries the update notice — relay that notice to the user before continuing. False on later pings and when no update is available.',
+                        },
                     },
                 },
                 annotations: {
@@ -346,6 +359,9 @@ export class EditmameiServer {
     async pingPhotoshop() {
         this.lastPingReachedPs = null;
         this.refreshLicenseOnPing();
+        if (this.updateCheck)
+            await this.updateCheck;
+        const update = await this.buildUpdateNotice();
         const connection = this.session.getConnection();
         let version = 'Unknown';
         let actionSetsCount = 0;
@@ -359,6 +375,23 @@ export class EditmameiServer {
         }
         catch {
         }
+        if (connection.getPhotoshopInfo() !== null && !(await connection.isCurrentlyRunning())) {
+            this.lastPingReachedPs = false;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Photoshop does not appear to be running. Start Photoshop, then call ps_ping again.' +
+                            update.note,
+                    },
+                ],
+                structuredContent: {
+                    connected: false,
+                    update_available: this.updateInfo,
+                    notify_user: update.notify,
+                },
+            };
+        }
         let pingStateSnippet = null;
         try {
             pingStateSnippet = await this.snippetClient.build('pingState');
@@ -373,10 +406,14 @@ export class EditmameiServer {
                     content: [
                         {
                             type: 'text',
-                            text: (reason ?? 'Photoshop did not respond') + this.updateNote(),
+                            text: (reason ?? 'Photoshop did not respond') + update.note,
                         },
                     ],
-                    structuredContent: { connected: false, update_available: this.updateInfo },
+                    structuredContent: {
+                        connected: false,
+                        update_available: this.updateInfo,
+                        notify_user: update.notify,
+                    },
                 };
             }
             degraded.push('pingState');
@@ -390,10 +427,12 @@ export class EditmameiServer {
                 this.logger.warn(`pingState snippet failed: ${err instanceof Error ? err.message : String(err)}`);
                 this.lastPingReachedPs = false;
                 return {
-                    content: [
-                        { type: 'text', text: 'Photoshop did not respond' + this.updateNote() },
-                    ],
-                    structuredContent: { connected: false, update_available: this.updateInfo },
+                    content: [{ type: 'text', text: 'Photoshop did not respond' + update.note }],
+                    structuredContent: {
+                        connected: false,
+                        update_available: this.updateInfo,
+                        notify_user: update.notify,
+                    },
                 };
             }
             if (state.version) {
@@ -431,7 +470,7 @@ export class EditmameiServer {
                         `${actionSetsCount} custom action set(s), ${userTemplates} saved template(s), ` +
                         `${openDocuments.length} open document(s)${openDocuments.length ? ': ' + openDocuments.join(', ') : ''}` +
                         `${degradedNote}.` +
-                        this.updateNote(),
+                        update.note,
                 },
             ],
             structuredContent: {
@@ -442,14 +481,43 @@ export class EditmameiServer {
                 open_documents: openDocuments,
                 degraded,
                 update_available: this.updateInfo,
+                notify_user: update.notify,
             },
         };
     }
-    updateNote() {
+    async buildUpdateNotice() {
         const u = this.updateInfo;
         if (!u)
-            return '';
-        return ` Update available: v${u.current} → v${u.latest}. ${u.how_to_update}`;
+            return { note: '', notify: false };
+        if (this.updateNoticeShown) {
+            return {
+                note: ` Update available: v${u.current} → v${u.latest}. ${u.how_to_update}`,
+                notify: false,
+            };
+        }
+        this.updateNoticeShown = true;
+        let fixNote = '';
+        if (u.fixed_tools.length > 0) {
+            try {
+                const counts = await previousSessionFailureCounts(this.session.getSessionId(), {
+                    dir: this.sessionLog.directory,
+                });
+                const hits = relevantFixes(counts, u.fixed_tools);
+                if (hits.length > 0) {
+                    const named = hits
+                        .map((h) => `${h.tool} (failed ${h.failures} time${h.failures === 1 ? '' : 's'} last session)`)
+                        .join(', ');
+                    fixNote = ` v${u.latest} fixes known failures in ${named}.`;
+                }
+            }
+            catch {
+            }
+        }
+        return {
+            note: ` IMPORTANT — tell the user before continuing: Editmamei v${u.latest} is available` +
+                ` (this install runs v${u.current}).${fixNote} To update: ${u.how_to_update}`,
+            notify: true,
+        };
     }
     async start() {
         await this.loadModules();

package/dist/core/tool-groups.js

@@ -77,7 +77,7 @@ export const GROUPS = {
     automation: {
         id: 'automation',
         label: 'Automation (Pro)',
-        purpose: 'Play recorded Actions and the ExtendScript escape hatch (Pro).',
+        purpose: 'Batch files, play recorded Actions, and the ExtendScript escape hatch (Pro).',
     },
 };
 export const TOOL_GROUPS = {
@@ -111,10 +111,11 @@ export const TOOL_GROUPS = {
     ps_select_sky: 'select_ai',
     ps_select_subject_instance: 'select_ai',
     ps_select_object: 'select_ai',
+    ps_select_focus_area: 'select_ai',
+    ps_replace_sky: 'select_ai',
     ps_add_adjustment_layer: 'adjust',
     ps_apply_adjustment: 'adjust',
     ps_filter: 'filter',
-    ps_apply_filter: 'filter',
     ps_apply_camera_raw: 'filter',
     ps_retouch: 'retouch',
     ps_apply_brush_stroke: 'retouch',
@@ -139,11 +140,6 @@ export const TOOL_GROUPS = {
     ps_warp_layer_region: 'layers',
     ps_warp_layer_to: 'layers',
     ps_group: 'layers',
-    ps_create_group: 'layers',
-    ps_move_layer_to_group: 'layers',
-    ps_set_group_blend_mode: 'layers',
-    ps_ungroup: 'layers',
-    ps_delete_group: 'layers',
     ps_shape: 'layers',
     ps_layer_mask: 'masks',
     ps_clipping_mask: 'masks',
@@ -152,8 +148,6 @@ export const TOOL_GROUPS = {
     ps_apply_image: 'masks',
     ps_calculations: 'masks',
     ps_text: 'type',
-    ps_create_text_layer: 'type',
-    ps_set_text: 'type',
     ps_detect: 'perception',
     ps_read_scene: 'perception',
     ps_select_by_reference: 'perception',
@@ -174,6 +168,7 @@ export const TOOL_GROUPS = {
     ps_list_actions: 'automation',
     ps_play_action: 'automation',
     ps_execute_script: 'automation',
+    ps_batch: 'automation',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -5,6 +5,7 @@ export const TOOL_TIERS = {
     ps_list_actions: 'pro',
     ps_play_action: 'pro',
     ps_execute_script: 'pro',
+    ps_batch: 'pro',
     ps_add_adjustment_layer: 'community',
     ps_apply_adjustment: 'community',
     ps_create_document: 'community',
@@ -13,13 +14,7 @@ export const TOOL_TIERS = {
     ps_save_psd: 'community',
     ps_export: 'community',
     ps_filter: 'community',
-    ps_apply_filter: 'community',
     ps_group: 'community',
-    ps_create_group: 'community',
-    ps_move_layer_to_group: 'community',
-    ps_set_group_blend_mode: 'community',
-    ps_ungroup: 'community',
-    ps_delete_group: 'community',
     ps_clipping_mask: 'community',
     ps_undo: 'community',
     ps_redo: 'community',
@@ -38,7 +33,6 @@ export const TOOL_TIERS = {
     ps_add_layer_style: 'community',
     ps_create_layer: 'community',
     ps_delete_layer: 'community',
-    ps_create_text_layer: 'community',
     ps_fill_layer: 'community',
     ps_add_fill_layer: 'community',
     ps_select_layer: 'community',
@@ -73,6 +67,8 @@ export const TOOL_TIERS = {
     ps_select_sky: 'community',
     ps_select_subject_instance: 'pro',
     ps_select_object: 'pro',
+    ps_select_focus_area: 'dev',
+    ps_replace_sky: 'dev',
     ps_modify_selection: 'community',
     ps_get_selection_preview: 'community',
     ps_selection_channel: 'community',
@@ -91,7 +87,6 @@ export const TOOL_TIERS = {
     ps_template_recall: 'pro',
     ps_template_delete: 'pro',
     ps_text: 'community',
-    ps_set_text: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/modules/ce/index.js

@@ -29,6 +29,7 @@ import { createPathTools } from '../../tools/path-tools.js';
 import { createVectorMaskTools } from '../../tools/vector-mask-tools.js';
 import { createChannelComposeTools } from '../../tools/channel-compose-tools.js';
 import { createShapeTools } from '../../tools/shape-tools.js';
+import { createSkyTools } from '../../tools/sky-tools.js';
 const ceFactories = [
     createDocumentTools,
     createLayerTools,
@@ -57,6 +58,7 @@ const ceFactories = [
     createVectorMaskTools,
     createChannelComposeTools,
     createShapeTools,
+    createSkyTools,
 ];
 export const ceModule = {
     manifest: { id: 'ce', name: 'Editmamei Community Tools', abi: KERNEL_ABI },

package/dist/tools/filter-tools.js

@@ -1010,20 +1010,6 @@ export function createFilterTools(connection, snippetClient, client = new OnnxLa
             },
             handler: async (args) => runFilterTool(connection, snippetClient, client, args),
         },
-        {
-            tool: {
-                name: 'ps_apply_filter',
-                description: `DEPRECATED — use ps_filter instead (kept for one release for backward compatibility, identical behaviour). ${FILTER_DESCRIPTION}`,
-                inputSchema: FILTER_INPUT_SCHEMA,
-                outputSchema: FILTER_OUTPUT_SCHEMA,
-                annotations: {
-                    title: 'Apply Filter',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => runFilterTool(connection, snippetClient, client, args),
-        },
     ];
 }
 async function runFilterTool(connection, snippetClient, detClient, rawArgs) {

package/dist/tools/group-tools.js

@@ -41,7 +41,7 @@ const moveLayerToGroupSchema = {
     properties: {
         layer_name: {
             type: 'string',
-            description: 'Name of the layer to move (recursive search).',
+            description: 'Name of the layer to move (recursive search). A layer is preferred over a group of the same name; a group is moved only when no layer matches, which is how one group is nested inside another.',
         },
         group_name: {
             type: 'string',
@@ -187,102 +187,6 @@ export function createGroupTools(connection, snippetClient) {
             },
             handler: async (args) => groupDispatch(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'ps_create_group',
-                description: `DEPRECATED — use ps_group(op=create) instead (kept for one release for backward compatibility, identical behaviour). Create a new layer group (LayerSet) above the active layer with the given name — hoisted out of the active layer's group by default even though Photoshop's own Mk-layerSection placement rule would otherwise nest it INSIDE that group (pass into_active_group:true to keep that native nesting; this is why groups created one after another land as siblings rather than nested, so bottom-to-top group creation is safe). Optionally moves existing layers into it in one step. Non-destructive. Foundational for structured non-destructive editing — e.g. group all adjustment layers into an "edits" group so you can A/B toggle the whole stack via group visibility.`,
-                inputSchema: createGroupSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        created: { type: 'boolean' },
-                        groupName: { type: 'string' },
-                        moved_count: { type: 'number' },
-                        not_found: { type: 'array', items: { type: 'string' } },
-                        hoisted: {
-                            type: 'boolean',
-                            description: 'True when the new group had to be moved back out of the previously-active group to honor into_active_group:false (the default). False when it landed correctly on its own, or when the move-back itself failed — check the layer tree if this matters and hoisted is false.',
-                        },
-                        parent_path: {
-                            type: ['array', 'null'],
-                            items: { type: 'string' },
-                            description: 'The containing-group name chain (outermost first), empty array at the document root.',
-                        },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Create Layer Group',
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => createGroup(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'ps_move_layer_to_group',
-                description: 'DEPRECATED — use ps_group(op=add_layer) instead (kept for one release for backward compatibility, identical behaviour). Move a named layer into a named group. The layer is placed at the top of the group stack. Both layer_name and group_name are looked up recursively. Throws if either is not found, or if the layer IS the group itself.',
-                inputSchema: moveLayerToGroupSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        moved: { type: 'boolean' },
-                        layerName: { type: 'string' },
-                        groupName: { type: 'string' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Move Layer Into Group',
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => moveLayerToGroup(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'ps_set_group_blend_mode',
-                description: "DEPRECATED — use ps_group(op=set_blend_mode) instead (kept for one release for backward compatibility, identical behaviour). Set a group's blend mode. The 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.",
-                inputSchema: setGroupBlendModeSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        set: { type: 'boolean' },
-                        groupName: { type: 'string' },
-                        blendMode: { type: 'string' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Set Group Blend Mode',
-                    idempotentHint: true,
-                },
-            },
-            handler: async (args) => setGroupBlendMode(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'ps_ungroup',
-                description: 'DEPRECATED — use ps_group(op=ungroup) instead (kept for one release for backward compatibility, identical behaviour). DESTRUCTIVE structural change: 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.',
-                inputSchema: ungroupSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        ungrouped: { type: 'boolean' },
-                        groupName: { type: 'string' },
-                        children_promoted: { type: 'number' },
-                        child_names: { type: 'array', items: { type: 'string' } },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Ungroup Layer Set (destructive structural change)',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => ungroup(connection, snippetClient, args),
-        },
         {
             tool: {
                 name: 'ps_clipping_mask',
@@ -305,28 +209,6 @@ export function createGroupTools(connection, snippetClient) {
             },
             handler: async (args) => clippingMask(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'ps_delete_group',
-                description: 'DEPRECATED — use ps_group(op=delete) instead (kept for one release for backward compatibility, identical behaviour). 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. Recoverable only via Edit > Undo. To dissolve a group while keeping its contents, use ps_ungroup instead.',
-                inputSchema: deleteGroupSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        deleted: { type: 'boolean' },
-                        groupName: { type: 'string' },
-                        descendants_deleted: { type: 'number' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Delete Group (destructive, recursive)',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => deleteGroup(connection, snippetClient, args),
-        },
     ];
 }
 async function clippingMask(connection, snippetClient, rawArgs) {

package/dist/tools/layer-tools.js

@@ -220,7 +220,7 @@ export function createLayerTools(connection, snippetClient) {
         {
             tool: {
                 name: 'ps_delete_layer',
-                description: 'DESTRUCTIVE: Delete a layer. With no arg, deletes the currently active layer (backward-compatible). With `name`, recurses into groups and deletes the first layer matching that name — useful for cleanup workflows where the dead layer is not currently active. Recoverable only via Edit > Undo. To delete a group and all its contents, use ps_delete_group.',
+                description: 'DESTRUCTIVE: Delete a layer. With no arg, deletes the currently active layer (backward-compatible). With `name`, recurses into groups and deletes the first LAYER matching that name — useful for cleanup workflows where the dead layer is not currently active. A name that matches a group is refused rather than deleted; use ps_group(op=delete) to delete a group and all its contents. Recoverable only via Edit > Undo.',
                 inputSchema: deleteLayerSchema,
                 outputSchema: {
                     type: 'object',
@@ -238,29 +238,6 @@ export function createLayerTools(connection, snippetClient) {
             },
             handler: async (args) => deleteLayer(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'ps_create_text_layer',
-                description: 'DEPRECATED — use ps_text(op=create) instead (kept for one release for backward compatibility, identical behaviour). Create a new text layer with the given content, position, and font size. The text is editable (vector). Use ps_text (op=set_font / set_color / set_alignment) afterwards to style.',
-                inputSchema: createTextLayerSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        created: { type: 'boolean' },
-                        layerName: { type: 'string' },
-                        text: { type: 'string' },
-                        position: { type: 'object' },
-                        fontSize: { type: 'number' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Create Text Layer',
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => createTextLayer(connection, snippetClient, args),
-        },
         {
             tool: {
                 name: 'ps_fill_layer',

package/dist/tools/selection-tools.js

@@ -5,7 +5,7 @@ import { validateArgs } from '../utils/validate.js';
 import { toolErrorResult, runSnippetTool, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
 import { resolveExpectedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
-import { SELECT_SUBJECT_TIMEOUT_MS, SELECT_SKY_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+import { SELECT_SUBJECT_TIMEOUT_MS, SELECT_SKY_TIMEOUT_MS, SELECT_FOCUS_AREA_TIMEOUT_MS, } from '../utils/operation-timeouts.js';
 export const SELECTION_TYPE_ENUM = ['replace', 'add', 'subtract', 'intersect'];
 export const selectionTypeFragment = {
     type: 'string',
@@ -817,6 +817,42 @@ export function createSelectionTools(connection, snippetClient, client = new Onn
             },
             handler: async (args) => selectSky(connection, snippetClient, args),
         },
+        {
+            tool: {
+                name: 'ps_select_focus_area',
+                description: "Run Photoshop's \"Focus Area\" — select what the lens rendered SHARP, by depth of field rather than by subject or colour. Use it when the thing you want is defined by focus and not by what it is: lifting a subject off a bokeh background, masking the in-focus plane of a macro shot, or grabbing a shallow-depth foreground that Select Subject splits badly. Takes NO coordinates. in_focus_radius widens (higher) or narrows (lower) what counts as sharp; soft_mask=true gives feathered edges instead of a hard boundary. Analyses the ACTIVE layer, so target the photographic pixels you mean. If the active layer is not a raster layer at all (adjustment, smart object, text, shape), detection is retargeted to the bottom layer and active_layer_temporarily_changed comes back true — check it, because the analysed layer was then NOT the one you selected. An EMPTY raster layer cannot be told apart by kind, so it is not retargeted; it surfaces instead as an error or as whole_canvas_selected. whole_canvas_selected and warning diagnose Focus Area's RAW detection, measured BEFORE any selection_type combine — a uniformly sharp image (or too high an in_focus_radius) trips them even when combining then folds the result down to something small. Check whole_canvas_selected first; selection_info separately reports the FINAL, post-combine selection and can disagree with it by design (e.g. selection_type='subtract' against an existing selection), so read selection_info for what actually got selected, not as a substitute for whole_canvas_selected.",
+                inputSchema: selectFocusAreaSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        selected: { type: 'boolean' },
+                        method: { type: 'string' },
+                        strategy_used: { type: 'string' },
+                        in_focus_radius: { type: 'number' },
+                        soft_mask: { type: 'boolean' },
+                        active_layer_temporarily_changed: {
+                            type: 'boolean',
+                            description: 'True if the active layer was not an ordinary pixel layer and detection was temporarily retargeted to the bottom layer. The original active layer is restored before return.',
+                        },
+                        whole_canvas_selected: {
+                            type: 'boolean',
+                            description: "True when Focus Area's RAW detection covered essentially the entire canvas — usually a non-result (radius too high, or nothing photographic to analyse). Measured BEFORE combining with any prior selection, so it describes the detection step, not the final selection: selection_info reports the FINAL, post-combine result and the two can legitimately disagree, e.g. selection_type='subtract' against an existing selection can leave this true while selection_info.area_percent is well under 100.",
+                        },
+                        warning: {
+                            type: ['string', 'null'],
+                            description: 'Set when whole_canvas_selected is true. Also describes the RAW detection, not the final post-combine selection.',
+                        },
+                        selection_type: { type: 'string' },
+                        selection_info: selectionInfoFragment,
+                    },
+                },
+                annotations: {
+                    title: 'Select Focus Area',
+                    idempotentHint: true,
+                },
+            },
+            handler: async (args) => selectFocusArea(connection, snippetClient, args),
+        },
     ];
 }
 const selectSubjectSchema = {
@@ -841,6 +877,41 @@ const selectSkySchema = {
         selection_type: selectionTypeFragment,
     },
 };
+const selectFocusAreaSchema = {
+    type: 'object',
+    properties: {
+        in_focus_radius: {
+            type: 'number',
+            description: 'How much blur still counts as "in focus", in pixels. Higher pulls more of the soft transition zone into the selection; lower keeps only the crisply resolved plane. 4.07 is the Photoshop dialog default and a sane starting point. The useful band is narrow, and a radius well above the default selects the entire frame — so move in small steps and CHECK the returned area_percent and whole_canvas_selected: a selection covering essentially everything means the radius is too high and the result is worthless, even though the call reports success.',
+            default: 4.07,
+            minimum: 0.1,
+            maximum: 15,
+        },
+        soft_mask: {
+            type: 'boolean',
+            description: 'False (default) yields a hard-edged selection — every pixel fully in or fully out, which is what you want before ps_modify_selection feathering. True lets Photoshop feather the focus falloff itself, useful when the subject edge is genuinely gradual (hair, fur, motion).',
+            default: false,
+        },
+        selection_type: selectionTypeFragment,
+    },
+};
+async function selectFocusArea(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: selectFocusAreaSchema,
+        snippet: 'selectFocusArea',
+        errorPrefix: 'Error running Focus Area selection',
+        timeoutMs: SELECT_FOCUS_AREA_TIMEOUT_MS,
+        params: (args) => ({
+            inFocusRadius: args.in_focus_radius ?? 4.07,
+            softMask: args.soft_mask ?? false,
+            selectionType: normalizeSelectionType(args.selection_type),
+        }),
+        successText: (_result, args) => `Focus Area selection (${normalizeSelectionType(args.selection_type)}) complete`,
+    });
+}
 async function selectSubject(connection, snippetClient, rawArgs) {
     return runSnippetTool({
         connection,

package/dist/tools/sky-tools.js

@@ -0,0 +1,126 @@
+import { runSnippetTool } from '../utils/tool-helpers.js';
+import { SKY_REPLACEMENT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+const PLACEHOLDER_SKY_ID = '00000000-0000-0000-0000-000000000000';
+const replaceSkyInputSchema = {
+    type: 'object',
+    properties: {
+        sky_file: {
+            type: 'string',
+            description: 'ABSOLUTE path to the image to use as the sky. Any image Photoshop can open works — it does not need to be a registered Photoshop sky preset. The built-in skies live as .jpg files under the Sky_Presets folder inside your Photoshop settings directory, and their paths can be passed here directly.',
+        },
+        sky_name: {
+            type: 'string',
+            description: 'Label recorded on the operation. Cosmetic — it does not select the sky, sky_file does.',
+            default: 'Custom Sky',
+        },
+        shift_edge: {
+            type: 'number',
+            description: 'Moves the sky/foreground boundary inward (negative) or outward (positive). Use it when the horizon leaves a halo or eats into the foreground.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        border_smoothness: {
+            type: 'number',
+            description: 'Softens the boundary between sky and foreground. 0 is a hard cut.',
+            default: 50,
+            minimum: 0,
+            maximum: 100,
+        },
+        brightness: {
+            type: 'number',
+            description: 'Brightness of the replaced sky itself.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        temperature: {
+            type: 'number',
+            description: 'Warms (positive) or cools (negative) the replaced sky.',
+            default: 0,
+            minimum: -100,
+            maximum: 100,
+        },
+        harmonization_opacity: {
+            type: 'number',
+            description: 'How strongly the foreground is colour-graded to match the new sky. This is what sells the composite — 0 leaves the foreground untouched and usually reads as pasted-on.',
+            default: 35,
+            minimum: 0,
+            maximum: 100,
+        },
+        foreground_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the relighting applied to the foreground so it appears lit by the new sky.',
+            default: 78,
+            minimum: 0,
+            maximum: 100,
+        },
+        edge_lighting_opacity: {
+            type: 'number',
+            description: 'Strength of the light wrap along the foreground edge where it meets the sky.',
+            default: 70,
+            minimum: 0,
+            maximum: 100,
+        },
+    },
+    required: ['sky_file'],
+};
+async function replaceSky(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: replaceSkyInputSchema,
+        snippet: 'replaceSky',
+        errorPrefix: 'Error running Sky Replacement',
+        timeoutMs: SKY_REPLACEMENT_TIMEOUT_MS,
+        params: (args) => ({
+            skyPath: args.sky_file,
+            skyName: args.sky_name ?? 'Custom Sky',
+            skyId: PLACEHOLDER_SKY_ID,
+            shiftEdge: args.shift_edge ?? 0,
+            borderSmoothness: args.border_smoothness ?? 50,
+            brightness: args.brightness ?? 0,
+            temperature: args.temperature ?? 0,
+            harmonizationOpacity: args.harmonization_opacity ?? 35,
+            foregroundLightingOpacity: args.foreground_lighting_opacity ?? 78,
+            edgeLightingOpacity: args.edge_lighting_opacity ?? 70,
+        }),
+        successText: (_result, args) => `Sky replaced using ${String(args.sky_file)}`,
+    });
+}
+export function createSkyTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'ps_replace_sky',
+                description: 'Run Photoshop\'s Sky Replacement (Adobe Sensei): detect the sky, composite a replacement, and relight/colour-grade the foreground to match. Non-destructive — everything lands in a "Sky Replacement Group" of editable layers above the original, so the result can be tuned or deleted afterwards. sky_file takes an ABSOLUTE path to ANY image on disk, not only Photoshop\'s built-in presets. Reach for harmonization_opacity and foreground_lighting_opacity when the composite reads as pasted-on; those two carry most of the believability. Fails cleanly when the image has no detectable sky (indoor or closed compositions).',
+                inputSchema: replaceSkyInputSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        replaced: { type: 'boolean' },
+                        strategy_used: { type: 'string' },
+                        group_name: {
+                            type: 'string',
+                            description: 'Name of the layer group Photoshop created.',
+                        },
+                        group_layers: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Layers inside the group, top to bottom — typically the sky layer, an edge-lighting group, a foreground-lighting layer and a foreground-colour curves layer.',
+                        },
+                        sky_file: { type: 'string' },
+                        sky_name: { type: 'string' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Replace Sky (Sensei)',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => replaceSky(connection, snippetClient, args),
+        },
+    ];
+}

package/dist/tools/text-tools.js

@@ -70,24 +70,6 @@ const updateTextContentSchema = {
     },
     required: ['text'],
 };
-const SET_TEXT_PROPERTIES = ['font', 'color', 'alignment', 'content'];
-const SET_TEXT_INPUT_SCHEMA = {
-    type: 'object',
-    properties: {
-        property: {
-            type: 'string',
-            enum: [...SET_TEXT_PROPERTIES],
-            description: 'Which text attribute to set on the active text layer: ' +
-                'font(font_name, optional font_size); color(red, green, blue); ' +
-                'alignment(alignment); content(text).',
-        },
-        ...setTextFontSchema.properties,
-        ...setTextColorSchema.properties,
-        ...setTextAlignmentSchema.properties,
-        ...updateTextContentSchema.properties,
-    },
-    required: ['property'],
-};
 const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
 export const TEXT_OP_SCHEMAS = {
     create: createTextLayerSchema,
@@ -161,33 +143,6 @@ export function createTextTools(connection, snippetClient) {
             },
             handler: async (args) => textDispatch(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'ps_set_text',
-                description: 'DEPRECATED — use ps_text(op=set_font / set_color / set_alignment / set_content) instead (kept for one release for backward compatibility, identical behaviour). Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
-                inputSchema: SET_TEXT_INPUT_SCHEMA,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        requested: { type: 'string' },
-                        font: { type: 'string' },
-                        size: { type: 'number' },
-                        matched_by: {
-                            type: 'string',
-                            enum: ['postScriptName', 'family+regular', 'family', 'name'],
-                        },
-                        color: { type: 'string' },
-                        alignment: { type: 'string' },
-                        text: { type: 'string' },
-                    },
-                },
-                annotations: {
-                    title: 'Set Text',
-                    idempotentHint: true,
-                },
-            },
-            handler: async (args) => setText(connection, snippetClient, args),
-        },
     ];
 }
 async function textDispatch(connection, snippetClient, rawArgs) {
@@ -208,30 +163,6 @@ async function textDispatch(connection, snippetClient, rawArgs) {
             return unknownDiscriminator('text op', op, TEXT_OPS);
     }
 }
-async function setText(connection, snippetClient, rawArgs) {
-    const property = rawArgs.property;
-    const { property: _omit, ...rest } = rawArgs;
-    switch (property) {
-        case 'font':
-            return setTextFont(connection, snippetClient, rest);
-        case 'color':
-            return setTextColor(connection, snippetClient, rest);
-        case 'alignment':
-            return setTextAlignment(connection, snippetClient, rest);
-        case 'content':
-            return updateTextContent(connection, snippetClient, rest);
-        default:
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Error: unknown text property "${String(property)}". Allowed: ${SET_TEXT_PROPERTIES.join(', ')}.`,
-                    },
-                ],
-                isError: true,
-            };
-    }
-}
 async function setTextFont(connection, snippetClient, rawArgs) {
     return runSnippetTool({
         connection,

package/dist/update/check.js

@@ -1,10 +1,33 @@
 import { VERSION } from '../version.js';
 import { resolveInstallChannel } from '../install-channel.js';
-const DEFAULT_DIST_TAGS_URL = 'https://registry.npmjs.org/-/package/editmamei/dist-tags';
+const DEFAULT_LATEST_MANIFEST_URL = 'https://registry.npmjs.org/editmamei/latest';
 const RELEASES_URL = 'https://editmamei.com/download';
 export function resolveUpdateCheckUrl(env = process.env) {
     const override = env.EDITMAMEI_UPDATE_CHECK_URL;
-    return override && override.length > 0 ? override : DEFAULT_DIST_TAGS_URL;
+    return override && override.length > 0 ? override : DEFAULT_LATEST_MANIFEST_URL;
+}
+const MAX_FIX_VERSIONS = 16;
+const MAX_TOOLS_PER_VERSION = 16;
+const MAX_TOOL_NAME_LENGTH = 64;
+export function parseFixesByVersion(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    let versions = 0;
+    for (const [version, tools] of Object.entries(raw)) {
+        if (versions >= MAX_FIX_VERSIONS)
+            break;
+        if (!parseSemver(version) || !Array.isArray(tools))
+            continue;
+        const names = tools
+            .filter((t) => typeof t === 'string' && t.length > 0 && t.length <= MAX_TOOL_NAME_LENGTH)
+            .slice(0, MAX_TOOLS_PER_VERSION);
+        if (names.length > 0) {
+            out[version] = names;
+            versions++;
+        }
+    }
+    return out;
 }
 export function httpFetchLatest() {
     return async (url, timeoutMs) => {
@@ -18,7 +41,12 @@ export function httpFetchLatest() {
             if (!res.ok)
                 return null;
             const data = (await res.json());
-            return typeof data.latest === 'string' ? data.latest : null;
+            if (typeof data.version !== 'string')
+                return null;
+            return {
+                version: data.version,
+                fixesByVersion: parseFixesByVersion(data.editmamei?.fixesByVersion),
+            };
         }
         catch {
             return null;
@@ -43,6 +71,30 @@ export function isNewer(latest, current) {
     }
     return false;
 }
+export function fixedToolsSince(fixesByVersion, current, latest) {
+    const versions = Object.keys(fixesByVersion)
+        .filter((v) => isNewer(v, current) && !isNewer(v, latest))
+        .sort((a, b) => {
+        const pa = parseSemver(a);
+        const pb = parseSemver(b);
+        for (let i = 0; i < 3; i++) {
+            if (pa[i] !== pb[i])
+                return pa[i] - pb[i];
+        }
+        return 0;
+    });
+    const seen = new Set();
+    const out = [];
+    for (const v of versions) {
+        for (const tool of fixesByVersion[v]) {
+            if (!seen.has(tool)) {
+                seen.add(tool);
+                out.push(tool);
+            }
+        }
+    }
+    return out;
+}
 export function updateMessage(channel, latest) {
     switch (channel) {
         case 'mcpb':
@@ -64,12 +116,19 @@ export async function checkForUpdate(opts = {}) {
         const current = opts.current ?? VERSION;
         const channel = resolveInstallChannel(env);
         const fetchLatest = opts.fetchLatest ?? httpFetchLatest();
-        const latest = await fetchLatest(resolveUpdateCheckUrl(env), opts.timeoutMs ?? 4000);
-        if (!latest || !parseSemver(latest))
+        const manifest = await fetchLatest(resolveUpdateCheckUrl(env), opts.timeoutMs ?? 4000);
+        if (!manifest || !parseSemver(manifest.version))
             return null;
+        const latest = manifest.version;
         if (!isNewer(latest, current))
             return null;
-        return { current, latest, channel, how_to_update: updateMessage(channel, latest) };
+        return {
+            current,
+            latest,
+            channel,
+            how_to_update: updateMessage(channel, latest),
+            fixed_tools: fixedToolsSince(manifest.fixesByVersion, current, latest),
+        };
     }
     catch {
         return null;

package/dist/update/session-fixes.js

@@ -0,0 +1,33 @@
+import { listRecentSessionIds, readSessionLog, } from '../utils/session-log-reader.js';
+const RECENT_SESSION_SCAN_LIMIT = 5;
+export async function previousSessionFailureCounts(currentSessionId, opts = {}) {
+    const ids = await listRecentSessionIds(RECENT_SESSION_SCAN_LIMIT, opts);
+    for (const id of ids) {
+        if (id === currentSessionId)
+            continue;
+        const entries = await readSessionLog(id, opts);
+        const counts = new Map();
+        let sawCall = false;
+        for (const entry of entries) {
+            if ('type' in entry && entry.type === 'meta')
+                continue;
+            const call = entry;
+            if (typeof call.tool !== 'string')
+                continue;
+            sawCall = true;
+            if (call.success === false) {
+                counts.set(call.tool, (counts.get(call.tool) ?? 0) + 1);
+            }
+        }
+        if (sawCall)
+            return counts;
+    }
+    return new Map();
+}
+export function relevantFixes(failureCounts, fixedTools, cap = 3) {
+    return fixedTools
+        .filter((tool) => (failureCounts.get(tool) ?? 0) > 0)
+        .map((tool) => ({ tool, failures: failureCounts.get(tool) }))
+        .sort((a, b) => b.failures - a.failures)
+        .slice(0, cap);
+}

package/dist/utils/jsx.js

@@ -1,5 +1,6 @@
+const NON_ASCII = /[^ -~]/g;
 export function jsLit(value) {
-    return JSON.stringify(String(value));
+    return JSON.stringify(String(value)).replace(NON_ASCII, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, '0')}`);
 }
 export function jsNum(value, fallback) {
     const n = typeof value === 'number' ? value : Number(value);

package/dist/utils/operation-timeouts.js

@@ -3,5 +3,7 @@ export const OPEN_DOCUMENT_REPROBE_TIMEOUT_MS = 10_000;
 export const CAMERA_RAW_FILTER_TIMEOUT_MS = 120_000;
 export const SELECT_SUBJECT_TIMEOUT_MS = 120_000;
 export const SELECT_SKY_TIMEOUT_MS = 120_000;
+export const SELECT_FOCUS_AREA_TIMEOUT_MS = 120_000;
+export const SKY_REPLACEMENT_TIMEOUT_MS = 120_000;
 export const ANNOTATED_PREVIEW_TIMEOUT_MS = 90_000;
 export const SCENE_CHANNEL_TIMEOUT_MS = 120_000;

package/dist/utils/session-log.js

@@ -24,6 +24,7 @@ export function generateSessionId(now = new Date()) {
 }
 export const ERROR_CLASS_TABLE = [
     { errorClass: 'ps_empty_error', pattern: /returned an empty error|failed with no message/i },
+    { errorClass: 'wrong_layer_kind', pattern: /is a group, not an art layer/i },
     {
         errorClass: 'layer_not_found',
         pattern: /\blayer not found|no layer named|(?:layer_to_move|target_layer_name) not found|layer "[^"]*" not found/i,
@@ -210,6 +211,9 @@ export class SessionLog {
     get path() {
         return join(this.dir, `${this.sessionId}.ndjson`);
     }
+    get directory() {
+        return this.dir;
+    }
     setMcpClientGetter(fn) {
         this.getMcpClientFn = fn;
     }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.1.0';
+export const VERSION = '1.2.0';

package/package.json

@@ -1,8 +1,19 @@
 {
   "name": "editmamei",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Photoshop MCP server: natural-language AI photo editing with your own Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
+  "editmamei": {
+    "fixesByVersion": {
+      "1.1.0": [
+        "ps_create_clipping_mask"
+      ],
+      "1.2.0": [
+        "ps_delete_layer",
+        "ps_select_layer"
+      ]
+    }
+  },
   "main": "dist/index.js",
   "type": "module",
   "bin": {