editmamei 0.17.5 → 0.19.0

package/NOTICES.md

@@ -46,6 +46,49 @@ artifact rather than by inlining the text here.
 
 ---
 
+## Bundled Machine-Learning Models
+
+Unlike the npm dependencies above, the local-vision ONNX model weights are
+**bundled** in Editmamei's tarball (under `dist/models/`) and redistributed with
+it, so their notices are reproduced here. The models run entirely on-device; no
+image data is transmitted. The ONNX runtime that executes them
+(`onnxruntime-web`, MIT) is a resolved npm dependency covered by the section
+above.
+
+### Ultraface (`ultraface-rfb-320.onnx`) — face detection
+
+- **Upstream:** Ultra-Light-Fast-Generic-Face-Detector-1MB (version-RFB-320), by
+  Linzaer (Fei Yu); distributed via the ONNX Model Zoo.
+- **License:** MIT.
+- Used to locate forward-facing faces. Returns bounding boxes only.
+
+### D-FINE-S (`dfine-s-coco-quant.onnx`) — object detection
+
+- **Upstream:** D-FINE ("Redefine Regression Task of DETRs as Fine-grained
+  Distribution Refinement", Peng et al.), COCO-trained S variant; ONNX export +
+  int8 quantization via the Hugging Face `onnx-community/dfine_s_coco-ONNX`
+  repository.
+- **License:** Apache-2.0. The upstream D-FINE repository's `NOTICE`/attribution
+  terms (Apache-2.0 §4(d)) are preserved by reference to that source.
+- Used to detect the 80 COCO object classes.
+
+### MediaPipe FaceMesh (`models/pro/face_mesh_468.onnx`) — facial landmarks (Pro)
+
+- **Upstream:** Google MediaPipe Face Landmark / FaceMesh model (the
+  `face_landmarks_detector` weight from `face_landmarker.task`), trained by Google
+  on its own data. Converted to ONNX (468-point variant) and redistributed via the
+  Hugging Face `Heliosoph/mediapipe-face-onnx` repository.
+- **License:** Apache-2.0 (the model is permissively licensed by Google;
+  commercial-safe — see `docs/product/pro-vision-models.md` for the weights-license
+  diligence). Any upstream `NOTICE`/attribution terms (Apache-2.0 §4(d)) are
+  preserved by reference to those sources.
+- Runs on-device via the same `onnxruntime-web` backend; the image never leaves the
+  machine. Used by the Pro `photoshop_detect_landmarks` tool to locate the 468-point
+  face mesh (eyes, brows, lips, nose, jaw). Ships in the **Pro module**
+  (`models/pro/`), not the CE tarball.
+
+---
+
 ## Trademarks
 
 "Adobe" and "Photoshop" are registered trademarks of Adobe Inc. This product

package/README.md

@@ -10,9 +10,31 @@
 [![License](https://img.shields.io/badge/License-Proprietary-blue.svg)](https://editmamei.com/license)
 [![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20macOS-lightgrey.svg)]()
 
-Editmamei is a Model Context Protocol (MCP) server that drives the Adobe Photoshop you already have. You describe the edit in plain words; your AI assistant plans the steps; your own copy of Photoshop carries them out with its standard adjustment layers, masks, selections, and filters. The AI directs; Photoshop edits. No generative model touches your pixels.
+Editmamei is a Model Context Protocol (MCP) server that drives the Adobe Photoshop you already have. You describe the edit in plain words, your AI assistant plans the steps, and your own copy of Photoshop carries them out with its standard adjustment layers, masks, selections, and filters. The AI directs and Photoshop edits. No generative model touches your pixels, and no image is uploaded to perform an edit.
 
-**[editmamei.com](https://editmamei.com)** · [Docs](https://github.com/editmamei/editmamei-wiki) · [Report a bug](https://github.com/editmamei/editmamei-wiki/issues)
+It serves photographers and retouchers who want to edit by conversation just as much as developers wiring Photoshop into an AI pipeline. To learn more or get started, visit **[editmamei.com](https://editmamei.com)**.
+
+**[editmamei.com](https://editmamei.com)** · [Docs & wiki](https://github.com/editmamei/editmamei-wiki) · [Report a bug](https://github.com/editmamei/editmamei-wiki/issues)
+
+## How it works
+
+Editmamei is a pure MCP **stdio** server written in Node. Your AI client launches it as a subprocess and calls its tools over stdio. Each tool builds a small Photoshop script and runs it in your local Photoshop over the platform's native automation channel:
+
+```
+AI client  ──stdio──▶  Editmamei (Node MCP server)
+                              │  builds a Photoshop script per tool call
+                              ▼
+                    COM (Windows) / AppleScript (macOS)
+                              │
+                              ▼
+                     Your local Adobe Photoshop
+```
+
+- **Windows** drives Photoshop through COM (the `Photoshop.Application` object).
+- **macOS** drives it through AppleScript / OSA.
+- Perception (face, object, and scene detection) runs **on-device** with local ONNX computer vision, so the model gets real document coordinates without your image leaving the machine.
+
+Photoshop does the pixel work with its own engine. Editmamei is the conductor, not a renderer.
 
 ## Install
 
@@ -24,19 +46,80 @@ editmamei status    # confirms install state + Photoshop detection
 
 Then restart your AI client and ask it: _"Is Photoshop connected?"_
 
-Prefer not to use a terminal? Claude Desktop users can install the one-click `.mcpb` extension from [the latest release](https://github.com/editmamei/editmamei-wiki/releases/latest). Full walkthrough in the [install guide](https://github.com/editmamei/editmamei-wiki/blob/main/docs/installation.md).
+Prefer not to use a terminal? Claude Desktop users can install the one-click `.mcpb` extension from [the latest release](https://github.com/editmamei/editmamei-wiki/releases/latest) (no system Node required, Claude Desktop ships its own runtime). Full walkthrough in the [install guide](https://github.com/editmamei/editmamei-wiki/blob/main/docs/installation.md).
+
+**Requirements:** Adobe Photoshop 2026 (v27.x), Windows 10/11 or macOS 12+, Node.js 20+ (for the npm path), and an MCP-compatible AI client (Claude Desktop, Cursor, Claude Code).
+
+## A session, end to end
+
+The discovery chain is `photoshop_ping` (liveness), then `photoshop_overview` (the working method and capability map), then `tools/list` (the full schema-typed inventory). After that you just talk to your assistant:
+
+> _"Open my vacation photo."_
+> _"Make the sky more dramatic but keep the foreground natural."_
+> _"Sharpen the eyes, soften the skin, leave everything else alone."_
+> _"Isolate the subject onto its own layer with a clean mask."_
+> _"Export a 2048px web JPEG."_
 
-**Requirements:** Adobe Photoshop 2026 (v27.x), Windows 10/11 or macOS 12+, Node.js 20+ (for the npm path), and an MCP-compatible AI client.
+Your assistant composes those into tool calls, checks the result with previews and measurements, and iterates.
 
-## What it does
+## Design principles
 
-Editmamei gives your AI assistant a working photographer's toolkit inside Photoshop: open and save documents, build layer stacks, make selections, add non-destructive adjustments, run filters, mask, retouch, and check the result with inline previews and histograms. Your AI calls these as building blocks, so you can say _"make the sky more dramatic but keep the foreground natural"_ instead of clicking through menus.
+These are the choices that shape the surface, and the reason an AI assistant can drive it reliably rather than hopefully.
+
+- **Structured results, not prose.** Every tool declares an `outputSchema` and returns a typed JSON payload. Any tool that changes what is active reports the current document and layer back, so the model keeps an accurate picture of Photoshop's state between calls instead of re-deriving it.
+- **Guidance lives in the surface.** `photoshop_overview` returns the working method (assess, plan, enact, check, iterate) and `photoshop_list_capabilities` returns a live map of what exists. The model orients itself from the server rather than from guesswork or a stale prompt.
+- **Measure, don't eyeball.** A dedicated set of verification tools (histogram, region compare, layer-bounds diff, selection preview) lets the model check its own work numerically instead of trusting a thumbnail.
+- **On-device perception.** Local computer vision (ONNX) detects faces, objects, and scene regions and returns real document coordinates. The image stays on your machine for this step and is never sent to a cloud vision model.
+- **Non-destructive by default.** Adjustments are adjustment layers, and destructive pixel operations run on an auto-created duplicate. An edit is reversible by construction.
+- **Verified against real Photoshop.** Every tool is built on Photoshop's own native scripting functions and verified in live Photoshop sessions before it ships. A new tool stays disabled until it has passed live verification, so the shipped surface is the verified surface.
+- **Built for modern Photoshop.** Editmamei targets Photoshop 2026 (v27.x) so it can rely on current, stable scripting descriptors rather than carrying a decade of drifted behavior.
+
+## Tool surface
+
+**75 tools across 16 capability groups** (58 Community, 17 Pro). Every tool is namespaced `photoshop_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license.
+
+| Group | Edition | Tools |
+| --- | --- | --- |
+| **Core** | Community | `ping` · `overview` · `list_capabilities` · `undo` · `redo` |
+| **Inspect** | Community | `inspect` · `get_preview` |
+| **Verify** | Community | `get_histogram` · `compare_regions` · `get_layer_bounds_diff` · `get_selection_preview` |
+| **Document & canvas** | Community | `create_document` · `open_document` · `close_document` · `save_psd` · `export` · `place_image` · `resize_image` · `crop_document` · `convert_image_mode` · `transform_canvas` · `guides` |
+| **Selection** | Community | `select` · `modify_selection` · `selection_channel` |
+| **Adjustments** | Community | `add_adjustment_layer` · `apply_adjustment` |
+| **Filters** | Community | `apply_filter` |
+| **Retouch** | Community | `retouch` |
+| **Layers** | Community | `create_layer` · `delete_layer` · `fill_layer` · `add_fill_layer` · `select_layer` · `move_layer_to_position` · `duplicate_layer` · `layer_via_copy` · `convert_to_smart_object` · `rasterize_layer` · `set_layer` · `merge` · `bake_layer` · `add_layer_style` · `transform_layer` · `create_group` · `move_layer_to_group` · `set_group_blend_mode` · `ungroup` · `delete_group` |
+| **Masks & paths** | Community | `layer_mask` · `create_clipping_mask` · `path` · `vector_mask` |
+| **Type** | Community | `create_text_layer` · `set_text` |
+| **Perception** | Community | `detect` · `scene` · `select_by_reference` |
+| **AI selection** | Pro | `select_subject` · `select_sky` · `select_subject_instance` |
+| **Layers (warp)** | Pro | `warp_layer` · `warp_layer_mesh` |
+| **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` |
+
+## Editions
+
+- **Community** is free and covers the everyday editing surface: documents, layers, selections, non-destructive adjustments, filters, masks, type, retouching, on-device perception, and the inspect/verify primitives.
+- **Pro** adds AI selection (Sensei-backed Select Subject and Select Sky), face-mesh perception, the reproducible-template system, custom mesh warp, and Photoshop Actions plus the scripting escape hatch.
+
+The split is detailed in [pro-features.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/pro-features.md). Pricing is at [editmamei.com](https://editmamei.com).
+
+## Configuration
+
+Settings live in `~/.editmamei/settings.json`, managed by the `editmamei config` CLI:
+
+```bash
+editmamei config list
+editmamei config set telemetry.usage false      # turn off anonymous usage telemetry
+editmamei config set photoshop_path "/path/to/Photoshop"
+```
 
-The full capability surface is at [editmamei.com](https://editmamei.com). The Community and Pro split is in [pro-features.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/pro-features.md): Community is free and covers the everyday editing surface; Pro adds the reproducible-template system, Sensei-backed Select Subject and Select Sky, and Photoshop Actions plus scripting.
+`PHOTOSHOP_PATH` (env var) overrides Photoshop auto-detection for a single run.
 
 ## Privacy
 
-Editmamei runs on your computer and edits in your own Photoshop. No image content, document data, or file paths are sent to Editmamei's servers. It reports anonymous, content-free usage telemetry (on by default; turn it off with `editmamei config set telemetry.usage false`). When your AI assistant needs to see a result, Editmamei sends it a downscaled preview, the same as dropping a photo into a chat with that assistant. Every field is documented in [privacy.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/privacy.md).
+Editmamei runs on your computer and edits in your own Photoshop. No image content, document data, or file paths are sent to Editmamei's servers. It reports anonymous, content-free usage telemetry (on by default, turn it off with `editmamei config set telemetry.usage false`). When your AI assistant needs to see a result, Editmamei sends it a downscaled preview, the same as dropping a photo into a chat with that assistant. Every field is documented in [privacy.md](https://github.com/editmamei/editmamei-wiki/blob/main/docs/privacy.md).
 
 ## Docs and support
 

package/dist/api/extendscript/_helpers.js

@@ -49,6 +49,14 @@ function saveSelectionToTempChannel(doc) {
   if (!hasActiveSelection(doc)) return null;
   var ch = doc.channels.add();
   doc.selection.store(ch, SelectionType.REPLACE);
+  // channels.add() makes the new alpha the ACTIVE channel. A pixel-sampling
+  // selection op that runs next (magic wand / color range / grow / similar)
+  // would then sample THIS alpha — uniform inside the stored selection — and
+  // flood the whole region, so a subsequent add/subtract/intersect collapses
+  // to empty/full. Geometric ops (rectangle/ellipse) are immune. Restore the
+  // composite so the sampler reads RGB. (See restoreCompositeChannel for the
+  // sibling cleanup-time case.)
+  doc.activeChannels = doc.componentChannels;
   return ch;
 }
 

package/dist/cli/clients/json-config.js

@@ -27,7 +27,7 @@ export async function writeJsonMcpConfig(configPath, config) {
     const dir = dirname(configPath);
     const tmpPath = join(dir, `.editmamei.json-config.${process.pid}.tmp`);
     const body = JSON.stringify(config, null, 2) + '\n';
-    await writeFile(tmpPath, body, 'utf8');
+    await writeFile(tmpPath, body, { encoding: 'utf8', mode: 0o600 });
     try {
         await rename(tmpPath, configPath);
     }

package/dist/cli/config.js

@@ -43,6 +43,13 @@ const KEYS = {
         },
         coerce: coercePath,
     },
+    update_check: {
+        get: (s) => s.update_check,
+        set: (s, v) => {
+            s.update_check = v;
+        },
+        coerce: coerceBool,
+    },
 };
 function knownKeysHint() {
     return `Known keys:\n${Object.keys(KEYS)

package/dist/core/server.js

@@ -4,17 +4,19 @@ import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprot
 import { Logger } from '../utils/logger.js';
 import { ToolRegistry } from './tool-registry.js';
 import { tierOf } from './tool-tiers.js';
+import { groupOf, GROUPS } from './tool-groups.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
 import { SessionLog, classifyError } from '../utils/session-log.js';
-import { loadSettings, applyTelemetryEnvOverrides } from './settings.js';
+import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride, } from './settings.js';
 import { TelemetryClient } from '../telemetry/client.js';
+import { checkForUpdate, shouldCheckForUpdate } from '../update/check.js';
 import { join, dirname } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { GoSnippetClient, resolveProBinaryPath, coreBinaryName } from '../api/snippet-client.js';
 import { isProEntitled } from '../license/entitlement.js';
-import { readInstalledModule, moduleHandlersPath, moduleBinDir, PRO_SKU, } from '../delivery/store.js';
+import { loadVerifiedModule, PRO_SKU } from '../delivery/store.js';
 import { runScript } from '../utils/run-script.js';
 import { listTemplates } from '../utils/template-storage.js';
 import { Kernel } from '../kernel/kernel.js';
@@ -48,6 +50,7 @@ export class EditmameiServer {
     kernel;
     proModule = null;
     psVersion = null;
+    updateInfo = null;
     snippetClient = new GoSnippetClient();
     constructor() {
         this.logger = new Logger('EditmameiServer');
@@ -55,13 +58,18 @@ export class EditmameiServer {
         this.sessionLog = new SessionLog(this.session.getSessionId());
         this.logger.info(`Session ${this.session.getSessionId()} → ${this.sessionLog.path}`);
         const { settings, created } = loadSettings();
-        const effectiveSettings = applyTelemetryEnvOverrides(settings);
+        const effectiveSettings = applyUpdateCheckEnvOverride(applyTelemetryEnvOverrides(settings));
         this.telemetry = new TelemetryClient({
             settings: effectiveSettings,
             getPsVersion: () => this.psVersion,
         });
         if (created)
             this.logger.info(FIRST_RUN_DISCLOSURE);
+        if (shouldCheckForUpdate(effectiveSettings.update_check)) {
+            void checkForUpdate().then((info) => {
+                this.updateInfo = info;
+            });
+        }
         warnLogScriptOnErrorOnce(this.logger);
         this.toolRegistry = new ToolRegistry({
             onCall: (entry) => {
@@ -123,6 +131,16 @@ export class EditmameiServer {
                             items: { type: 'string' },
                             description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the in-PS state snippet failed, "templates" if ~/.editmamei/templates was unreadable). Empty when all signals were collected cleanly. Returned defaults for any degraded field cannot be trusted as ground truth.',
                         },
+                        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`.',
+                            properties: {
+                                current: { type: 'string' },
+                                latest: { type: 'string' },
+                                channel: { type: 'string' },
+                                how_to_update: { type: 'string' },
+                            },
+                        },
                     },
                 },
                 annotations: {
@@ -133,6 +151,38 @@ export class EditmameiServer {
             },
             handler: async () => await this.pingPhotoshop(),
         });
+        this.toolRegistry.register('photoshop_list_capabilities', {
+            tool: {
+                name: 'photoshop_list_capabilities',
+                description: 'Live map of every tool this MCP exposes, grouped by capability — each group is a one-line purpose plus the tool names in it. Read-only and cheap. Reach for it to re-orient mid-session (what exists, what to reach for) when the overview brief has scrolled out of context, or to learn which tool names to look up. photoshop_overview tells you HOW to combine tools; this tells you WHAT exists, currently; tools/list has the full schema for any one you pick.',
+                inputSchema: { type: 'object', properties: {} },
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        tool_count: { type: 'number' },
+                        group_count: { type: 'number' },
+                        groups: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                    label: { type: 'string' },
+                                    purpose: { type: 'string' },
+                                    tools: { type: 'array', items: { type: 'string' } },
+                                },
+                            },
+                        },
+                    },
+                },
+                annotations: {
+                    title: 'List Capabilities',
+                    readOnlyHint: true,
+                    idempotentHint: true,
+                },
+            },
+            handler: async () => this.listCapabilities(),
+        });
         this.proModule = this.resolveProModule();
         this.kernel = new Kernel({
             registry: this.toolRegistry,
@@ -150,12 +200,11 @@ export class EditmameiServer {
     }
     resolveProModule() {
         if (isProEntitled()) {
-            const installed = readInstalledModule(PRO_SKU);
-            if (installed) {
-                const entry = moduleHandlersPath(PRO_SKU, installed.version);
+            const verified = loadVerifiedModule(PRO_SKU);
+            if (verified) {
                 return {
-                    importer: () => import(pathToFileURL(entry).href),
-                    binDir: moduleBinDir(PRO_SKU, installed.version),
+                    importer: () => import(pathToFileURL(verified.handlersPath).href),
+                    binDir: verified.binDir,
                 };
             }
         }
@@ -182,8 +231,41 @@ export class EditmameiServer {
     assertToolsClassified() {
         for (const tool of this.toolRegistry.list()) {
             tierOf(tool.name);
+            groupOf(tool.name);
         }
     }
+    listCapabilities() {
+        const registered = this.toolRegistry.list();
+        const toolsByGroup = new Map();
+        for (const tool of registered) {
+            const g = groupOf(tool.name);
+            const arr = toolsByGroup.get(g) ?? [];
+            arr.push(tool.name);
+            toolsByGroup.set(g, arr);
+        }
+        const groups = Object.keys(GROUPS)
+            .map((id) => ({
+            id,
+            label: GROUPS[id].label,
+            purpose: GROUPS[id].purpose,
+            tools: (toolsByGroup.get(id) ?? []).sort(),
+        }))
+            .filter((g) => g.tools.length > 0);
+        const text = `Editmamei exposes ${registered.length} tools across ${groups.length} capability groups. ` +
+            `This is the live map of WHAT exists; photoshop_overview is HOW to combine them, and ` +
+            `tools/list has the full schema for any one tool.\n\n` +
+            groups
+                .map((g) => `${g.label} (${g.tools.length}) — ${g.purpose}\n  ${g.tools.join(', ')}`)
+                .join('\n');
+        return {
+            content: [{ type: 'text', text }],
+            structuredContent: {
+                tool_count: registered.length,
+                group_count: groups.length,
+                groups,
+            },
+        };
+    }
     setupHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             this.logger.debug('Listing available tools');
@@ -193,33 +275,38 @@ export class EditmameiServer {
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             this.logger.debug(`Tool called: ${request.params.name}`);
-            try {
-                const args = request.params.arguments || {};
-                const result = await this.toolRegistry.execute(request.params.name, args);
-                this.session.updateActivity();
-                return result;
-            }
-            catch (error) {
-                this.logger.error(`Tool execution failed: ${request.params.name}`, error);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
+            const args = request.params.arguments || {};
+            return this.handleToolCall(request.params.name, args);
         });
     }
+    async handleToolCall(name, args) {
+        try {
+            const result = await this.toolRegistry.execute(name, args);
+            this.session.updateActivity();
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Tool execution failed: ${name}`, error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
     async pingPhotoshop() {
         const connection = this.session.getConnection();
         const isConnected = await connection.ping();
         if (!isConnected) {
             return {
-                content: [{ type: 'text', text: 'Failed to connect to Photoshop' }],
-                structuredContent: { connected: false },
+                content: [
+                    { type: 'text', text: 'Failed to connect to Photoshop' + this.updateNote() },
+                ],
+                structuredContent: { connected: false, update_available: this.updateInfo },
             };
         }
         let version = 'Unknown';
@@ -268,7 +355,8 @@ export class EditmameiServer {
                     text: `Connected to Photoshop (v${version}). ` +
                         `${actionSetsCount} custom action set(s), ${userTemplates} saved template(s), ` +
                         `${openDocuments.length} open document(s)${openDocuments.length ? ': ' + openDocuments.join(', ') : ''}` +
-                        `${degradedNote}.`,
+                        `${degradedNote}.` +
+                        this.updateNote(),
                 },
             ],
             structuredContent: {
@@ -278,9 +366,16 @@ export class EditmameiServer {
                 user_templates: userTemplates,
                 open_documents: openDocuments,
                 degraded,
+                update_available: this.updateInfo,
             },
         };
     }
+    updateNote() {
+        const u = this.updateInfo;
+        if (!u)
+            return '';
+        return ` Update available: v${u.current} → v${u.latest}. ${u.how_to_update}`;
+    }
     async start() {
         await this.session.initialize();
         await this.loadModules();

package/dist/core/settings.js

@@ -20,6 +20,7 @@ function defaults(installId) {
         telemetry: { usage: true, diagnostics: false, install_id: installId },
         privacy: { send_previews_to_llm: true },
         photoshop_path: null,
+        update_check: true,
     };
 }
 function coerce(raw, installId) {
@@ -43,6 +44,7 @@ function coerce(raw, installId) {
                 : base.privacy.send_previews_to_llm,
         },
         photoshop_path: typeof r.photoshop_path === 'string' ? r.photoshop_path : null,
+        update_check: typeof r.update_check === 'boolean' ? r.update_check : base.update_check,
     };
 }
 export function loadSettings(opts = {}) {
@@ -102,6 +104,12 @@ export function applyTelemetryEnvOverrides(settings, env = process.env) {
         },
     };
 }
+export function applyUpdateCheckEnvOverride(settings, env = process.env) {
+    const v = parseBoolEnv(env.EDITMAMEI_UPDATE_CHECK);
+    if (v === undefined)
+        return settings;
+    return { ...settings, update_check: v };
+}
 export function saveSettings(settings, opts = {}) {
     const path = settingsPath(opts);
     const dir = dirname(path);