editmamei 0.20.0 → 0.22.0

package/dist/tools/group-tools.js

@@ -77,7 +77,7 @@ export function createGroupTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_create_group',
+                name: 'ps_create_group',
                 description: 'Create a new layer group (LayerSet) above the active layer with the given name. 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: {
@@ -99,7 +99,7 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_move_layer_to_group',
+                name: 'ps_move_layer_to_group',
                 description: '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: {
@@ -120,7 +120,7 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_set_group_blend_mode',
+                name: 'ps_set_group_blend_mode',
                 description: "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: {
@@ -141,7 +141,7 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_ungroup',
+                name: 'ps_ungroup',
                 description: '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: {
@@ -164,8 +164,8 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_create_clipping_mask',
-                description: 'Clip the active layer to the layer directly below it (uses that layer as the alpha source). Non-destructive — the upper layer is unchanged; PS just paints it only where the layer below has pixels. Common for masking adjustment-layer effect to a single underlying layer, or constraining a texture/photo to a shape. Equivalent to the PS menu Layer > Create Clipping Mask (Ctrl+Alt+G). Reverse it with the PS menu Layer > Release Clipping Mask, or photoshop_undo. This is the standalone primitive — the add_adjustment_layer tool already accepts clip_to_below for the adjustment-layer-specific case.',
+                name: 'ps_create_clipping_mask',
+                description: 'Clip the active layer to the layer directly below it (uses that layer as the alpha source). Non-destructive — the upper layer is unchanged; PS just paints it only where the layer below has pixels. Common for masking adjustment-layer effect to a single underlying layer, or constraining a texture/photo to a shape. Equivalent to the PS menu Layer > Create Clipping Mask (Ctrl+Alt+G). Reverse it with the PS menu Layer > Release Clipping Mask, or ps_undo. This is the standalone primitive — the add_adjustment_layer tool already accepts clip_to_below for the adjustment-layer-specific case.',
                 inputSchema: { type: 'object', properties: {}, required: [] },
                 outputSchema: {
                     type: 'object',
@@ -184,8 +184,8 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_release_clipping_mask',
-                description: "Release the active layer's clipping mask (the inverse of photoshop_create_clipping_mask). The layer returns to compositing against the whole canvas instead of just the layer below. Equivalent to PS menu Layer > Release Clipping Mask. Idempotent on a non-clipped layer (PS silently no-ops).",
+                name: 'ps_release_clipping_mask',
+                description: "Release the active layer's clipping mask (the inverse of ps_create_clipping_mask). The layer returns to compositing against the whole canvas instead of just the layer below. Equivalent to PS menu Layer > Release Clipping Mask. Idempotent on a non-clipped layer (PS silently no-ops).",
                 inputSchema: { type: 'object', properties: {}, required: [] },
                 outputSchema: {
                     type: 'object',
@@ -204,8 +204,8 @@ export function createGroupTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_delete_group',
-                description: '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 photoshop_ungroup instead.',
+                name: 'ps_delete_group',
+                description: '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',

package/dist/tools/guide-tools.js

@@ -10,7 +10,7 @@ const addGuideSchema = {
         },
         position: {
             type: 'number',
-            description: 'Guide position in document pixels (the x for vertical, the y for horizontal).',
+            description: 'Guide position in document pixels (the x for a vertical guide, the y for a horizontal guide).',
             minimum: 0,
         },
     },
@@ -51,8 +51,8 @@ export function createGuideTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_guides',
-                description: 'Manage document guides — choose with `op`. `add` places one guide (orientation horizontal|vertical + position in px). `layout` creates an evenly-spaced grid (columns and/or rows — great for rule-of-thirds at 3×3). `clear` removes all guides. Guides are non-printing layout aids.',
+                name: 'ps_guides',
+                description: 'Manage document guides — non-printing layout aids for a HUMAN working in Photoshop. Guides are editor-only chrome: they do NOT render into ps_get_preview (the exported/flattened image), so they are a user authoring aid, not a model-perception tool — place them when a person will open the PSD and wants alignment/composition marks. Choose with `op`. `add` places one guide (orientation horizontal|vertical) at a `position` in px. `layout` creates an evenly-spaced grid (columns and/or rows — great for rule-of-thirds at 3×3). `clear` removes all guides.',
                 inputSchema: GUIDE_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -103,7 +103,7 @@ async function addGuide(connection, snippetClient, rawArgs) {
         const orientation = args.orientation;
         const position = args.position;
         const script = await snippetClient.build('addGuide', { orientation, position });
-        const result = await runScript(connection, script);
+        const result = (await runScript(connection, script));
         return {
             content: [
                 {

package/dist/tools/history-tools.js

@@ -38,8 +38,8 @@ export function createHistoryTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_undo',
-                description: 'Step backward in the document history (equivalent to Ctrl/Cmd+Z). WHEN TO REACH FOR THIS: after an experimental destructive bake (photoshop_merge_visible_layers, photoshop_flatten_image, photoshop_apply_*_blur, photoshop_apply_sharpen, photoshop_apply_noise) produced a wrong result; after a play_action whose scope you mispredicted; or to revert an entire branch of exploration. Non-destructive workflows (adjustment layers + masks) rarely need this — just tweak/delete the offending layer instead. Reversible via photoshop_redo as long as no new edit has been made since. Returns current history state, remaining steps, and document context.',
+                name: 'ps_undo',
+                description: 'Step backward in the document history (equivalent to Ctrl/Cmd+Z). WHEN TO REACH FOR THIS: after an experimental destructive bake (photoshop_merge_visible_layers, photoshop_flatten_image, photoshop_apply_*_blur, photoshop_apply_sharpen, photoshop_apply_noise) produced a wrong result; after a play_action whose scope you mispredicted; or to revert an entire branch of exploration. Non-destructive workflows (adjustment layers + masks) rarely need this — just tweak/delete the offending layer instead. Reversible via ps_redo as long as no new edit has been made since. Returns current history state, remaining steps, and document context.',
                 inputSchema: undoSchema,
                 outputSchema: HISTORY_STEP_RESULT_SCHEMA,
                 annotations: {
@@ -51,8 +51,8 @@ export function createHistoryTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_redo',
-                description: 'Step forward in the document history (equivalent to Ctrl/Cmd+Shift+Z). Only works if photoshop_undo was the last operation; making a fresh edit destroys the redo stack. Returns updated context.',
+                name: 'ps_redo',
+                description: 'Step forward in the document history (equivalent to Ctrl/Cmd+Shift+Z). Only works if ps_undo was the last operation; making a fresh edit destroys the redo stack. Returns updated context.',
                 inputSchema: redoSchema,
                 outputSchema: HISTORY_STEP_RESULT_SCHEMA,
                 annotations: {

package/dist/tools/image-placement-tools.js

@@ -41,7 +41,7 @@ export function createImagePlacementTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_place_image',
+                name: 'ps_place_image',
                 description: 'Place an image file (JPEG, PNG, PSD, etc.) as a new Smart Object layer in the active document, optionally offset from center. Rasterize separately if you need to apply pixel-only operations. Open-world: reads from the filesystem. Returns the new layer name, bounds, and updated document context.',
                 inputSchema: placeImageSchema,
                 outputSchema: {

package/dist/tools/image-tools.js

@@ -1,5 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
+import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
+import { resolveExpectedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
 const PS_MAX_DIM_PX = 300_000;
 const resizeImageSchema = {
     type: 'object',
@@ -22,32 +24,37 @@ const resizeImageSchema = {
 const cropDocumentSchema = {
     type: 'object',
     properties: {
+        placement: {
+            ...PLACEMENT_SCHEMA,
+            description: 'ANCHOR-RELATIONAL crop (preferred over guessing pixels): a REGION relation (inside/gap) → the crop is the ' +
+                'resolved region bounding box, verified by the gate. Crops ONLY if the gate PASSES. When set, ' +
+                'left/top/right/bottom are ignored. See ps_resolve_placement for the anchors + relation vocabulary.',
+        },
         left: {
             type: 'integer',
-            description: 'Left edge position in pixels.',
+            description: 'Left edge position in pixels (raw mode; ignored when placement is set).',
             minimum: 0,
             maximum: PS_MAX_DIM_PX,
         },
         top: {
             type: 'integer',
-            description: 'Top edge position in pixels.',
+            description: 'Top edge position in pixels (raw mode; ignored when placement is set).',
             minimum: 0,
             maximum: PS_MAX_DIM_PX,
         },
         right: {
             type: 'integer',
-            description: 'Right edge position in pixels.',
+            description: 'Right edge position in pixels (raw mode; ignored when placement is set).',
             minimum: 1,
             maximum: PS_MAX_DIM_PX,
         },
         bottom: {
             type: 'integer',
-            description: 'Bottom edge position in pixels.',
+            description: 'Bottom edge position in pixels (raw mode; ignored when placement is set).',
             minimum: 1,
             maximum: PS_MAX_DIM_PX,
         },
     },
-    required: ['left', 'top', 'right', 'bottom'],
 };
 const convertImageModeSchema = {
     type: 'object',
@@ -80,11 +87,11 @@ const convertImageModeSchema = {
     },
     required: ['mode'],
 };
-export function createImageTools(connection, snippetClient) {
+export function createImageTools(connection, snippetClient, client = new OnnxLandmarkDetectionClient()) {
     return [
         {
             tool: {
-                name: 'photoshop_resize_image',
+                name: 'ps_resize_image',
                 description: 'Resize the entire document canvas (all layers) to the specified absolute dimensions. Destructive: downscaling permanently loses pixel data. Idempotent: same width/height always yield the same result. For aspect-preserving downscale during export, see photoshop_export_jpeg / photoshop_export_png which resize a duplicate. Returns updated document context.',
                 inputSchema: resizeImageSchema,
                 outputSchema: {
@@ -107,8 +114,8 @@ export function createImageTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_crop_document',
-                description: 'Crop the document to the specified absolute pixel bounds. Destructive: pixels outside the bounds are permanently lost. Idempotent: same bounds always yield the same result. Coordinates are in document space. Returns updated document context.',
+                name: 'ps_crop_document',
+                description: 'Crop the document to a region — EITHER anchor-relational `placement` (preferred: a region relation like inside/gap → the crop is the resolved, gate-verified region bbox, no pixel-guessing) OR absolute pixel bounds (left/top/right/bottom in document space). Destructive: pixels outside the bounds are permanently lost. Idempotent for the same bounds. Returns updated document context.',
                 inputSchema: cropDocumentSchema,
                 outputSchema: {
                     type: 'object',
@@ -116,6 +123,16 @@ export function createImageTools(connection, snippetClient) {
                         cropped: { type: 'boolean' },
                         newWidth: { type: 'number' },
                         newHeight: { type: 'number' },
+                        placement: {
+                            type: 'object',
+                            description: 'Present when anchor-relational placement was used: the resolved region + gate verdict.',
+                            properties: {
+                                target: { type: 'string' },
+                                gate: { type: 'object' },
+                                anchors: { type: 'object' },
+                                geometry: { type: 'object' },
+                            },
+                        },
                         context: { type: 'object' },
                     },
                 },
@@ -125,11 +142,11 @@ export function createImageTools(connection, snippetClient) {
                     idempotentHint: true,
                 },
             },
-            handler: async (args) => cropDocument(connection, snippetClient, args),
+            handler: async (args) => cropDocument(connection, snippetClient, client, args),
         },
         {
             tool: {
-                name: 'photoshop_convert_image_mode',
+                name: 'ps_convert_image_mode',
                 description: 'Convert the document color mode (grayscale / rgb / cmyk / lab). Destructive and document-wide: the image is FLATTENED and, for grayscale, color is discarded (the confirmation prompt is auto-accepted). Use grayscale as the base for halftone / line-art workflows, or rgb to bring a CMYK/Lab doc back for normal editing. Returns updated document context.',
                 inputSchema: convertImageModeSchema,
                 outputSchema: {
@@ -218,23 +235,49 @@ async function convertImageMode(connection, snippetClient, rawArgs) {
         };
     }
 }
-async function cropDocument(connection, snippetClient, rawArgs) {
+async function cropDocument(connection, snippetClient, client, rawArgs) {
     try {
         const args = validateArgs(cropDocumentSchema, rawArgs);
-        const left = args.left;
-        const top = args.top;
-        const right = args.right;
-        const bottom = args.bottom;
+        let left, top, right, bottom;
+        let placementInfo;
+        if (args.placement) {
+            const rp = await resolveExpectedPlacement(connection, client, args.placement, 'region', 'crop');
+            ({ left, top, right, bottom } = rp.bbox);
+            placementInfo = { target: rp.target, anchors: rp.anchors, geometry: rp.bbox };
+        }
+        else {
+            for (const k of ['left', 'top', 'right', 'bottom']) {
+                if (typeof args[k] !== 'number') {
+                    throw new Error(`crop needs numeric left/top/right/bottom (missing ${k}), or a placement (anchors + a region relation).`);
+                }
+            }
+            left = args.left;
+            top = args.top;
+            right = args.right;
+            bottom = args.bottom;
+        }
         const script = await snippetClient.build('cropDocument', { left, top, right, bottom });
-        const result = await runScript(connection, script);
+        const result = (await runScript(connection, script));
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Document cropped\nResult: ${JSON.stringify(result)}`,
+                    text: placementInfo
+                        ? `Document cropped to [${left},${top},${right},${bottom}] (placement gate PASS)\nResult: ${JSON.stringify(result)}`
+                        : `Document cropped\nResult: ${JSON.stringify(result)}`,
                 },
             ],
-            structuredContent: result,
+            structuredContent: placementInfo
+                ? {
+                    ...result,
+                    placement: {
+                        target: placementInfo.target,
+                        gate: { pass: true },
+                        anchors: placementInfo.anchors,
+                        geometry: placementInfo.geometry,
+                    },
+                }
+                : result,
         };
     }
     catch (error) {

package/dist/tools/inspect-tools.js

@@ -23,8 +23,8 @@ export function createInspectTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_inspect',
-                description: 'Read-only document inspection — choose with `what` (metadata / layer_tree / history / selection_info). This is the assess/orientation surface: call it at the start of a workflow and whenever you need fresh state. For metadata, pass `sections` to subset (e.g. ["context"] for a cheap probe). For an IMAGE-based check use photoshop_get_preview; for NUMERIC verification use photoshop_get_histogram / photoshop_compare_regions / photoshop_get_layer_bounds_diff (these stay separate, named tools on purpose). Read-only and idempotent.',
+                name: 'ps_inspect',
+                description: 'Read-only document inspection — choose with `what` (metadata / layer_tree / history / selection_info). This is the assess/orientation surface: call it at the start of a workflow and whenever you need fresh state. For metadata, pass `sections` to subset (e.g. ["context"] for a cheap probe). For an IMAGE-based check use ps_get_preview; for NUMERIC verification use ps_get_histogram / ps_compare_regions / ps_get_layer_bounds_diff (these stay separate, named tools on purpose). Read-only and idempotent.',
                 inputSchema: INSPECT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',

package/dist/tools/layer-ordering-tools.js

@@ -35,7 +35,7 @@ export function createLayerOrderingTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_move_layer_to_position',
+                name: 'ps_move_layer_to_position',
                 description: 'Move a layer to a position in the stack — the single ordering primitive (the per-direction helpers `_to_top` / `_to_bottom` / `_up` / `_down` were removed 2026-05-31; this tool covers all four cases). Position keywords: ABOVE/BELOW (requires target_layer_name — places the moved layer immediately above/below the target), TOP/BOTTOM (absolute — target_layer_name not needed). By default the ACTIVE layer is moved; pass layer_to_move=<name> to move a specific layer by name (recurses into groups). COMMON CASES: an adjustment layer just created landed below another adjustment that masks its effect → move it to TOP; a vignette darkens the wrong layers → move ABOVE the layer it should affect; a sky-replacement composite is showing through the foreground → move the foreground to TOP. Idempotent for a given (layer_to_move, target, position).',
                 inputSchema: moveLayerToPositionSchema,
                 outputSchema: LAYER_MOVE_RESULT_SCHEMA,

package/dist/tools/layer-properties-tools.js

@@ -5,6 +5,18 @@ const emptySchema = {
     type: 'object',
     properties: {},
 };
+const convertToSmartObjectSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['convert', 'new_via_copy'],
+            description: 'convert (default): wrap the active layer into a Smart Object in place. ' +
+                "new_via_copy: the active layer must ALREADY be a Smart Object — make a NEW Smart Object that is an INDEPENDENT copy (its own embedded source), unlinked from the original's shared source, so editing the copy's contents does not propagate back. (Differs from ps_duplicate_layer of a Smart Object, which keeps the shared source.)",
+            default: 'convert',
+        },
+    },
+};
 const setLayerOpacitySchema = {
     type: 'object',
     properties: {
@@ -77,8 +89,8 @@ const addLayerStyleSchema = {
     properties: {
         style: {
             type: 'string',
-            enum: ['drop_shadow', 'stroke', 'outer_glow'],
-            description: 'Which layer style to apply.',
+            enum: ['drop_shadow', 'stroke', 'outer_glow', 'inner_shadow', 'inner_glow', 'color_overlay'],
+            description: 'Which layer style to apply. drop_shadow/inner_shadow share angle/distance/spread/size; outer_glow/inner_glow share glow_size/glow_spread; color_overlay uses only color + opacity. inner_shadow = recessed shadow inside the layer edges (Multiply); inner_glow = glow inset from the edges (Screen); color_overlay = flat solid-color fill (Normal).',
         },
         color: {
             type: 'object',
@@ -99,24 +111,24 @@ const addLayerStyleSchema = {
         },
         angle: {
             type: 'number',
-            description: 'drop_shadow only: light angle in degrees. 90 = top-down (standard product shadow).',
+            description: 'drop_shadow/inner_shadow: light angle in degrees. 90 = top-down (standard product shadow).',
             default: 90,
         },
         distance: {
             type: 'number',
-            description: 'drop_shadow only: shadow offset in pixels.',
+            description: 'drop_shadow/inner_shadow: shadow offset in pixels.',
             default: 8,
         },
         spread: {
             type: 'number',
             minimum: 0,
             maximum: 100,
-            description: 'drop_shadow only: shadow spread (0-100%).',
+            description: 'drop_shadow/inner_shadow: shadow choke/spread (0-100%).',
             default: 0,
         },
         size: {
             type: 'number',
-            description: 'drop_shadow only: shadow blur size in pixels.',
+            description: 'drop_shadow/inner_shadow: shadow blur size in pixels.',
             default: 12,
         },
         stroke_size: {
@@ -132,14 +144,14 @@ const addLayerStyleSchema = {
         },
         glow_size: {
             type: 'number',
-            description: 'outer_glow only: glow blur size in pixels.',
+            description: 'outer_glow/inner_glow: glow blur size in pixels.',
             default: 12,
         },
         glow_spread: {
             type: 'number',
             minimum: 0,
             maximum: 100,
-            description: 'outer_glow only: glow spread (0-100%).',
+            description: 'outer_glow/inner_glow: glow choke/spread (0-100%).',
             default: 0,
         },
     },
@@ -182,9 +194,9 @@ export function createLayerPropertiesTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_convert_to_smart_object',
-                description: 'Convert the active layer to a Smart Object. This wraps the layer content so every subsequent filter becomes a Smart Filter — fully editable and non-destructive. PREREQUISITE for Camera Raw Filter, non-destructive frequency separation, and any workflow where filter parameters need to stay adjustable after the fact. Works on pixel, text, shape, and adjustment layers. Auto-promotes the background layer if needed. Wrapping an already-Smart-Object layer creates a nested Smart Object (valid in Photoshop — the inner SO is preserved as-is). Use photoshop_rasterize_layer to go the other direction.',
-                inputSchema: emptySchema,
+                name: 'ps_convert_to_smart_object',
+                description: 'Convert the active layer to a Smart Object, or (mode=new_via_copy) copy an existing Smart Object to an independent new one. `convert` (default) wraps the layer content so every subsequent filter becomes a Smart Filter — fully editable and non-destructive. PREREQUISITE for Camera Raw Filter, non-destructive frequency separation, and any workflow where filter parameters need to stay adjustable after the fact. Works on pixel, text, shape, and adjustment layers. Auto-promotes the background layer if needed. Wrapping an already-Smart-Object layer creates a nested Smart Object (valid in Photoshop — the inner SO is preserved as-is). `new_via_copy` requires the active layer to already be a Smart Object and yields a copy with its OWN source (unlinked). Use ps_rasterize_layer to go the other direction.',
+                inputSchema: convertToSmartObjectSchema,
                 outputSchema: {
                     type: 'object',
                     properties: {
@@ -193,6 +205,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
                         original_kind: { type: 'string' },
                         was_already_smart_object: { type: 'boolean' },
                         background_promoted: { type: 'boolean' },
+                        source_unlinked: { type: 'boolean' },
                         context: { type: 'object' },
                     },
                 },
@@ -201,11 +214,11 @@ export function createLayerPropertiesTools(connection, snippetClient) {
                     idempotentHint: false,
                 },
             },
-            handler: async () => convertToSmartObject(connection, snippetClient),
+            handler: async (args) => convertToSmartObject(connection, snippetClient, args),
         },
         {
             tool: {
-                name: 'photoshop_rasterize_layer',
+                name: 'ps_rasterize_layer',
                 description: 'Rasterize the active layer (convert text or smart object to plain pixels). Destructive — the text/smart-object source is lost. No-op if already a normal raster layer. Returns context so the caller sees the layer kind transition.',
                 inputSchema: emptySchema,
                 outputSchema: {
@@ -228,7 +241,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_set_layer',
+                name: 'ps_set_layer',
                 description: 'Set a property of the active layer — chosen via `property`. Idempotent absolute setters; do not change which layer is active. `opacity`: pass opacity (whole layer incl. styles) and/or fill_percent (pixels only — Photoshop\'s separate "Fill" slider, for Hard Mix / stroke-only effects). `blend_mode`: how the layer composites below (NORMAL to reset). `visibility`: show/hide via `visible`. `locked`: allLocked via `locked`. `name`: rename via `name`. Returns context so the LLM keeps state awareness.',
                 inputSchema: SET_LAYER_INPUT_SCHEMA,
                 outputSchema: {
@@ -257,7 +270,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_duplicate_layer',
+                name: 'ps_duplicate_layer',
                 description: 'Duplicate the active layer. The new layer becomes active. Returns context so the caller sees the new active layer. Not idempotent (each call creates another copy).',
                 inputSchema: duplicateLayerSchema,
                 outputSchema: {
@@ -277,7 +290,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_layer_via_copy',
+                name: 'ps_copy_to_new_layer',
                 description: 'Copy the current selection into a NEW layer above the active one — Photoshop\'s "Layer via Copy" (Ctrl+J). The source layer is left untouched and the new copied layer becomes active. With an active selection only the selected pixels are lifted; with no selection it copies the whole active layer (a plain duplicate). Reach for this to isolate a region for independent transforms or filters (stretch, light rays, a local grade) without altering the source. Returns context so the caller sees the new active layer.',
                 inputSchema: emptySchema,
                 outputSchema: {
@@ -300,7 +313,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_merge',
+                name: 'ps_merge',
                 description: 'Merge layers — choose with `mode`. `visible`: collapse all visible layers into one (DESTRUCTIVE; identities lost). `stamp`: merge visible into a NEW layer on top, leaving originals intact (Ctrl+Alt+Shift+E — the non-destructive "final tweak" composite for output sharpening/grain/contrast; prefer this when building on top rather than collapsing). `flatten`: flatten ALL layers into the background (DESTRUCTIVE; transparency filled with bg color — use sparingly, usually prefer `visible` or exporting a flattened copy). Returns context.',
                 inputSchema: MERGE_INPUT_SCHEMA,
                 outputSchema: {
@@ -325,7 +338,7 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_bake_layer',
+                name: 'ps_bake_layer',
                 description: 'Flatten the active layer\'s CURRENT APPEARANCE — the layer plus any adjustment layers clipped to it plus its layer styles — into a NEW pixel layer named "<name> (baked)". Non-destructive: the originals are left intact. This is how you get real baked pixels out of a non-destructive stack: clip a Hue/Saturation (saturation -100) or an Invert adjustment to a layer, then bake to get a desaturated / inverted PIXEL layer for techniques that need actual pixels (line art, blurred-layer blends). Also works on a lone layer with nothing clipped to it — it rasterizes that layer\'s own appearance (layer styles, smart-object or text content) into a flat pixel copy. The active layer must be top-level (not inside a group).',
                 inputSchema: emptySchema,
                 outputSchema: {
@@ -347,8 +360,8 @@ export function createLayerPropertiesTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_add_layer_style',
-                description: 'Apply a layer style (drop shadow, stroke, or outer glow) to the active layer. Non-destructive and editable. For PHOTO workflows: `stroke` = print-style border around the image (apply to the flattened photo on a transparent canvas, or to a duplicated background); `outer_glow` = atmospheric lift on highlights (halo around the sun, glow around a window or lamp); `drop_shadow` = depth on text overlays and layered composites. Drop shadow uses Multiply blend; outer glow uses Screen; stroke uses Normal. Cannot be applied to a background layer (duplicate or convert it first). Returns context — applying a style changes what exists on the layer (the Lefx descriptor).',
+                name: 'ps_add_layer_style',
+                description: 'Apply a layer style (drop shadow, stroke, outer glow, inner shadow, inner glow, or color overlay) to the active layer. Non-destructive and editable. For PHOTO workflows: `stroke` = print-style border around the image (apply to the flattened photo on a transparent canvas, or to a duplicated background); `outer_glow` = atmospheric lift on highlights (halo around the sun, glow around a window or lamp); `drop_shadow` = depth on text overlays and layered composites. Drop shadow uses Multiply blend; outer glow uses Screen; stroke uses Normal. Cannot be applied to a background layer (duplicate or convert it first). Returns context — applying a style changes what exists on the layer (the Lefx descriptor).',
                 inputSchema: addLayerStyleSchema,
                 outputSchema: {
                     type: 'object',
@@ -414,15 +427,21 @@ async function mergeLayers(connection, snippetClient, rawArgs) {
             };
     }
 }
-async function convertToSmartObject(connection, snippetClient) {
+async function convertToSmartObject(connection, snippetClient, rawArgs) {
     try {
-        const script = await snippetClient.build('convertToSmartObject');
+        const args = validateArgs(convertToSmartObjectSchema, rawArgs);
+        const mode = args.mode ?? 'convert';
+        const snippet = mode === 'new_via_copy' ? 'newSmartObjectViaCopy' : 'convertToSmartObject';
+        const script = await snippetClient.build(snippet);
         const result = await runScript(connection, script);
+        const verb = mode === 'new_via_copy'
+            ? 'New independent Smart Object created via copy'
+            : 'Layer converted to Smart Object';
         return {
             content: [
                 {
                     type: 'text',
-                    text: `Layer converted to Smart Object.\nResult: ${JSON.stringify(result)}`,
+                    text: `${verb}.\nResult: ${JSON.stringify(result)}`,
                 },
             ],
             structuredContent: result,

package/dist/tools/layer-tools.js

@@ -103,8 +103,8 @@ export function createLayerTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_create_layer',
-                description: 'Create a new empty raster layer above the currently active layer. Non-destructive. Use photoshop_create_text_layer for text, photoshop_add_adjustment_layer for adjustments.',
+                name: 'ps_create_layer',
+                description: 'Create a new empty raster layer above the currently active layer. Non-destructive. Use ps_create_text_layer for text, ps_add_adjustment_layer for adjustments.',
                 inputSchema: createLayerSchema,
                 outputSchema: {
                     type: 'object',
@@ -123,8 +123,8 @@ export function createLayerTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_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 photoshop_delete_group.',
+                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.',
                 inputSchema: deleteLayerSchema,
                 outputSchema: {
                     type: 'object',
@@ -144,7 +144,7 @@ export function createLayerTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_create_text_layer',
+                name: 'ps_create_text_layer',
                 description: 'Create a new text layer with the given content, position, and font size. The text is editable (vector). Use photoshop_set_text_font / photoshop_set_text_color afterwards to style.',
                 inputSchema: createTextLayerSchema,
                 outputSchema: {
@@ -167,7 +167,7 @@ export function createLayerTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_fill_layer',
+                name: 'ps_fill_layer',
                 description: 'Fill the active layer (or the current selection within it) with a solid RGB color. Idempotent for the same color. Throws on fully-locked or text layers — rasterize text first if needed.',
                 inputSchema: fillLayerSchema,
                 outputSchema: {
@@ -187,8 +187,8 @@ export function createLayerTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_add_fill_layer',
-                description: 'Add a non-destructive SOLID COLOR fill layer (an editable, re-colorable content layer — distinct from photoshop_fill_layer, which bakes color into the active pixel layer). The new fill layer becomes active. Use for color washes, base backgrounds, and clipped color overlays. (Gradient and pattern fill types are planned.)',
+                name: 'ps_add_fill_layer',
+                description: 'Add a non-destructive SOLID COLOR fill layer (an editable, re-colorable content layer — distinct from ps_fill_layer, which bakes color into the active pixel layer). The new fill layer becomes active. Use for color washes, base backgrounds, and clipped color overlays. (Gradient and pattern fill types are planned.)',
                 inputSchema: addFillLayerSchema,
                 outputSchema: {
                     type: 'object',
@@ -209,8 +209,8 @@ export function createLayerTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_select_layer',
-                description: '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). Throws if no layer by that name exists. 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.',
+                name: 'ps_select_layer',
+                description: '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). Throws if no layer by that name exists. Foundational for multi-layer workflows — use after ps_duplicate_layer or ps_add_adjustment_layer when you need to focus a specific layer before applying further operations.',
                 inputSchema: selectLayerSchema,
                 outputSchema: {
                     type: 'object',