editmamei 1.5.1 → 1.7.0

package/dist/core/preview-privacy.js

@@ -0,0 +1,54 @@
+function isImageBlock(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const block = value;
+    if (block.type === 'image') {
+        return typeof block.data === 'string' && typeof block.mimeType === 'string';
+    }
+    return (block.type === 'resource' &&
+        typeof block.resource?.blob === 'string' &&
+        typeof block.resource.mimeType === 'string' &&
+        block.resource.mimeType.startsWith('image/'));
+}
+function strip(value, counter) {
+    if (Array.isArray(value)) {
+        const out = [];
+        for (const item of value) {
+            if (isImageBlock(item))
+                counter.n++;
+            else
+                out.push(strip(item, counter));
+        }
+        return out;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = strip(v, counter);
+        return out;
+    }
+    return value;
+}
+export function hasImageContent(result) {
+    const counter = { n: 0 };
+    strip(result, counter);
+    return counter.n > 0;
+}
+export function withholdImages(result) {
+    const counter = { n: 0 };
+    const stripped = strip(result, counter);
+    if (counter.n === 0)
+        return result;
+    const what = counter.n === 1 ? 'An image was' : `${counter.n} images were`;
+    return {
+        ...stripped,
+        content: [
+            ...(stripped.content ?? []),
+            {
+                type: 'text',
+                text: `${what} withheld because the user's privacy.send_previews_to_llm setting is off. ` +
+                    'Work from the text and numbers; ask the user if you need to see the image.',
+            },
+        ],
+    };
+}

package/dist/core/server.js

@@ -5,6 +5,8 @@ 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 { CAMERA_RAW_TOOL, RAW_DEVELOP_TOOL } from './tool-activity.js';
+import { hasImageContent, withholdImages } from './preview-privacy.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
@@ -29,6 +31,9 @@ import { ceModule } from '../modules/ce/index.js';
 import { hostDetectionRuntime } from '../detection/runtime.js';
 import { ModuleLifecycle, classifyModuleOutcome } from '../kernel/module-lifecycle.js';
 import { unsupportedHostReason } from '../platform/host-platform.js';
+import { gimpModule } from '../modules/gimp/index.js';
+import { GimpBackend } from '../backends/gimp/backend.js';
+import { createDiagnosticsTools } from '../tools/diagnostics-tools.js';
 export { classifyModuleOutcome };
 let logScriptOnErrorWarned = false;
 function warnLogScriptOnErrorOnce(logger) {
@@ -68,6 +73,9 @@ export class EditmameiServer {
     session;
     sessionLog;
     telemetry;
+    editorOpts;
+    gimpBackend;
+    lastLoggedGimpVersion;
     kernel;
     moduleLifecycle;
     get moduleSkipReason() {
@@ -83,6 +91,7 @@ export class EditmameiServer {
     updateInfo = null;
     updateCheck = null;
     updateNoticeShown = false;
+    previewsAllowed = () => loadSettings().settings.privacy.send_previews_to_llm;
     snippetClient = new GoSnippetClient();
     refreshLicenseOnPing = createPingLicenseRefresher();
     moduleUpdateFailed = false;
@@ -91,6 +100,18 @@ export class EditmameiServer {
     licenseAdvisoryShown = false;
     constructor(opts = {}) {
         this.licenseStoreOptions = opts.licenseStore ?? {};
+        this.editorOpts = opts.editors ?? {
+            registerPhotoshop: true,
+            registerGimp: false,
+            gimpInstall: null,
+            gimpDetectionTimedOut: false,
+        };
+        if (this.editorOpts.registerGimp) {
+            this.gimpBackend = new GimpBackend(this.editorOpts.gimpInstall, {
+                gimpDetectionTimedOut: this.editorOpts.gimpDetectionTimedOut,
+                gimpPath: this.editorOpts.gimpPathOverride,
+            });
+        }
         this.logger = new Logger('EditmameiServer');
         this.session = new Session();
         this.sessionLog = new SessionLog(this.session.getSessionId());
@@ -127,6 +148,13 @@ export class EditmameiServer {
                         this.resolveLiveVersionInBackground();
                     }
                 }
+                if (entry.success && entry.tool.startsWith('gimp_') && this.gimpBackend?.gimpVersion) {
+                    const version = this.gimpBackend.gimpVersion;
+                    if (version !== this.lastLoggedGimpVersion) {
+                        this.lastLoggedGimpVersion = version;
+                        void this.sessionLog.setGimpVersion(version);
+                    }
+                }
                 const resultBytes = computeResultBytes(entry.result);
                 void this.sessionLog
                     .append({
@@ -219,52 +247,53 @@ export class EditmameiServer {
         };
     }
     registerTools() {
-        this.toolRegistry.register('ps_ping', {
-            tool: {
-                name: 'ps_ping',
-                description: 'Test connection to Photoshop and report session-start discovery signals. Read-only and idempotent. Call this once at the start of a session to confirm liveness before invoking any other tool. **If the user has given you an open-ended editing task, ALSO call `ps_overview` after this** — it returns the workflow contract + capabilities map + verification primitives so you can plan well. Returns `version` (folds the removed get-version tool), `custom_action_sets` (count of Action Sets loaded in the Photoshop Actions palette — non-zero means recorded workflows exist; if action tools are available in this build they will appear in `tools/list`), `user_templates` (count of saved Editmamei templates), and `open_documents` (names of documents already open in Photoshop, so the LLM does not have to ask which doc to edit).',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        connected: { type: 'boolean' },
-                        version: { type: 'string' },
-                        custom_action_sets: { type: 'number' },
-                        user_templates: { type: 'number' },
-                        open_documents: { type: 'array', items: { type: 'string' } },
-                        degraded: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the go-core snippet builder itself failed to produce the in-PS state script — a broken/missing local install, unrelated to whether Photoshop is reachable; liveness falls back to a cheap ping probe in that case — "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: { 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' } },
+        if (this.editorOpts.registerPhotoshop)
+            this.toolRegistry.register('ps_ping', {
+                tool: {
+                    name: 'ps_ping',
+                    description: 'Test connection to Photoshop and report session-start discovery signals. Read-only and idempotent. Call this once at the start of a session to confirm liveness before invoking any other tool. **If the user has given you an open-ended editing task, ALSO call `ps_overview` after this** — it returns the workflow contract + capabilities map + verification primitives so you can plan well. Returns `version` (folds the removed get-version tool), `custom_action_sets` (count of Action Sets loaded in the Photoshop Actions palette — non-zero means recorded workflows exist; if action tools are available in this build they will appear in `tools/list`), `user_templates` (count of saved Editmamei templates), and `open_documents` (names of documents already open in Photoshop, so the LLM does not have to ask which doc to edit).',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                    outputSchema: {
+                        type: 'object',
+                        properties: {
+                            connected: { type: 'boolean' },
+                            version: { type: 'string' },
+                            custom_action_sets: { type: 'number' },
+                            user_templates: { type: 'number' },
+                            open_documents: { type: 'array', items: { type: 'string' } },
+                            degraded: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'List of optional discovery signals that could not be gathered (e.g. "pingState" if the go-core snippet builder itself failed to produce the in-PS state script — a broken/missing local install, unrelated to whether Photoshop is reachable; liveness falls back to a cheap ping probe in that case — "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: { 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.',
                             },
-                        },
-                        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: {
+                        title: 'Ping Photoshop',
+                        readOnlyHint: true,
+                        idempotentHint: true,
+                    },
                 },
-                annotations: {
-                    title: 'Ping Photoshop',
-                    readOnlyHint: true,
-                    idempotentHint: true,
-                },
-            },
-            handler: async () => await this.pingPhotoshop(),
-        });
+                handler: async () => await this.pingPhotoshop(),
+            });
         this.toolRegistry.register('ps_list_capabilities', {
             tool: {
                 name: 'ps_list_capabilities',
@@ -315,6 +344,7 @@ export class EditmameiServer {
             connection: this.session.getConnection(),
             snippet: this.snippetClient,
             detection: hostDetectionRuntime(),
+            gimp: this.gimpBackend,
             resolveModuleSnippet: (manifest) => manifest.goCoreSnippets && manifest.goCoreSnippets.length > 0 && proModule
                 ? new GoSnippetClient({ binaryPath: join(proModule.binDir, coreBinaryName()) })
                 : null,
@@ -322,11 +352,22 @@ export class EditmameiServer {
             logger: this.logger,
         });
         this.moduleLifecycle.setKernel(this.kernel);
-        this.kernel.loadBuiltins([ceModule]);
+        const builtins = [];
+        if (this.editorOpts.registerPhotoshop)
+            builtins.push(ceModule);
+        if (this.editorOpts.registerGimp)
+            builtins.push(gimpModule);
+        this.kernel.loadBuiltins(builtins);
         this.assertToolsClassified();
+        if (!this.editorOpts.registerPhotoshop) {
+            const diagnosticsDefs = createDiagnosticsTools(this.session.getConnection(), this.snippetClient).filter((def) => def.tool.name === 'ps_report_problem');
+            this.toolRegistry.registerAll(diagnosticsDefs);
+        }
         this.logger.info(`Registered ${this.toolRegistry.count()} tools (edition: ${EDITION})`);
     }
     async loadModules() {
+        if (!this.editorOpts.registerPhotoshop)
+            return;
         return this.moduleLifecycle.loadModules();
     }
     computeModuleStatus() {
@@ -397,6 +438,8 @@ export class EditmameiServer {
             const result = await this.toolRegistry.execute(name, args);
             this.session.updateActivity();
             this.trackRawDevelopState(name, result);
+            if (hasImageContent(result) && !this.previewsAllowed())
+                return withholdImages(result);
             return result;
         }
         catch (error) {
@@ -409,7 +452,7 @@ export class EditmameiServer {
             return;
         if (name === 'ps_open_document') {
             const sc = result.structuredContent;
-            if (sc?.is_raw_source === true && this.toolRegistry.get('ps_apply_camera_raw')) {
+            if (sc?.is_raw_source === true && this.toolRegistry.get(CAMERA_RAW_TOOL)) {
                 const opened = sc;
                 markRawOpened(String(opened.document_name ?? ''), String(opened.file_path ?? ''));
             }
@@ -417,12 +460,12 @@ export class EditmameiServer {
                 clearPendingRawDevelop();
             }
         }
-        else if (name === 'ps_develop_raw') {
+        else if (name === RAW_DEVELOP_TOOL) {
             const sc = result.structuredContent;
             if (sc?.opened === true)
                 clearPendingRawDevelop();
         }
-        else if (name === 'ps_apply_camera_raw' || name === 'ps_close_document') {
+        else if (name === CAMERA_RAW_TOOL || name === 'ps_close_document') {
             clearPendingRawDevelop();
         }
     }
@@ -667,18 +710,24 @@ export class EditmameiServer {
         await this.loadModules();
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        void this.session.initialize().catch(() => undefined);
-        void this.reprovisionIfModuleSkipped();
-        void this.ensureEntitledModuleFresh();
+        if (this.editorOpts.registerPhotoshop) {
+            void this.session.initialize().catch(() => undefined);
+            void this.reprovisionIfModuleSkipped();
+            void this.ensureEntitledModuleFresh();
+        }
         this.telemetry.start();
         void this.telemetry.flushOutboxOnStartup();
         this.server.onclose = () => {
             void this.telemetry.shutdown();
+            if (this.gimpBackend)
+                void this.gimpBackend.shutdown();
         };
         this.logger.info('Editmamei is listening on stdio');
     }
     async stop() {
         await this.telemetry.shutdown();
+        if (this.gimpBackend)
+            await this.gimpBackend.shutdown();
         await this.session.disconnect();
         await this.sessionLog.close();
         this.logger.info('Editmamei has shut down');

package/dist/core/settings.js

@@ -3,6 +3,7 @@ import { join, dirname } from 'node:path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { Logger } from '../utils/logger.js';
+import { requireAbsoluteGimpPath } from '../utils/gimp-path.js';
 const logger = new Logger('Settings');
 const SETTINGS_DIRNAME = '.editmamei';
 const SETTINGS_FILENAME = 'settings.json';
@@ -15,12 +16,15 @@ export function settingsPath(opts = {}) {
 export function mintInstallId() {
     return randomBytes(16).toString('hex');
 }
+const EDITOR_PINS = ['auto', 'photoshop', 'gimp'];
 function defaults(installId) {
     return {
         telemetry: { usage: true, diagnostics: false, install_id: installId },
         privacy: { send_previews_to_llm: true },
         ps_path: null,
         update_check: true,
+        editor: 'auto',
+        gimp_path: null,
     };
 }
 function coerce(raw, installId) {
@@ -45,8 +49,23 @@ function coerce(raw, installId) {
         },
         ps_path: typeof r.ps_path === 'string' ? r.ps_path : null,
         update_check: typeof r.update_check === 'boolean' ? r.update_check : base.update_check,
+        editor: typeof r.editor === 'string' && EDITOR_PINS.includes(r.editor)
+            ? r.editor
+            : base.editor,
+        gimp_path: coerceGimpPath(r.gimp_path),
     };
 }
+function coerceGimpPath(raw) {
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return null;
+    try {
+        return requireAbsoluteGimpPath('gimp_path', raw);
+    }
+    catch (err) {
+        logger.warn(`ignoring settings.json gimp_path (falling back to auto-detect): ${errMsg(err)}`);
+        return null;
+    }
+}
 export function loadSettings(opts = {}) {
     const path = settingsPath(opts);
     if (!existsSync(path)) {
@@ -110,6 +129,12 @@ export function applyUpdateCheckEnvOverride(settings, env = process.env) {
         return settings;
     return { ...settings, update_check: v };
 }
+export function applyEditorEnvOverride(settings, env = process.env) {
+    const raw = env.EDITMAMEI_EDITOR?.trim().toLowerCase();
+    if (!raw || !EDITOR_PINS.includes(raw))
+        return settings;
+    return { ...settings, editor: raw };
+}
 export function saveSettings(settings, opts = {}) {
     const path = settingsPath(opts);
     const dir = dirname(path);

package/dist/core/tool-activity.js

@@ -0,0 +1,122 @@
+export const READ_ONLY_TOOLS = new Set([
+    'ps_sequence',
+    'ps_batch',
+    'ps_ping',
+    'ps_overview',
+    'ps_list_capabilities',
+    'ps_get_preview',
+    'ps_get_selection_preview',
+    'ps_get_histogram',
+    'ps_inspect',
+    'ps_read_scene',
+    'ps_compare_regions',
+    'ps_get_layer_bounds_diff',
+    'ps_template_list',
+    'ps_template_recall',
+    'ps_list_actions',
+    'ps_report_problem',
+    'ps_detect',
+    'ps_detect_landmarks',
+    'ps_document',
+    'ps_template_verify',
+    'ps_resolve_placement',
+    'ps_template_save',
+    'ps_template_delete',
+    'ps_template_create_evidence',
+    'gimp_ping',
+    'gimp_overview',
+    'gimp_inspect',
+    'gimp_get_preview',
+    'gimp_get_histogram',
+    'gimp_compare',
+]);
+export const KEPT_WORK_TOOLS = new Set([
+    'ps_export',
+    'ps_save_psd',
+    'gimp_export',
+    'gimp_save_xcf',
+]);
+export const MUTATING_TOOLS = new Set([
+    'ps_play_action',
+    'ps_execute_script',
+    'ps_add_adjustment_layer',
+    'ps_apply_adjustment',
+    'ps_create_document',
+    'ps_close_document',
+    'ps_open_document',
+    'ps_develop_raw',
+    'ps_filter',
+    'ps_group',
+    'ps_clipping_mask',
+    'ps_undo',
+    'ps_redo',
+    'ps_place_image',
+    'ps_resize_image',
+    'ps_crop_document',
+    'ps_convert_image_mode',
+    'ps_move_layer_to_position',
+    'ps_convert_to_smart_object',
+    'ps_rasterize_layer',
+    'ps_set_layer',
+    'ps_duplicate_layer',
+    'ps_copy_to_new_layer',
+    'ps_merge',
+    'ps_bake_layer',
+    'ps_add_layer_style',
+    'ps_create_layer',
+    'ps_delete_layer',
+    'ps_fill_layer',
+    'ps_add_fill_layer',
+    'ps_select_layer',
+    'ps_transform_layer',
+    'ps_warp_layer',
+    'ps_warp_layer_mesh',
+    'ps_warp_layer_along',
+    'ps_warp_layer_region',
+    'ps_warp_layer_to',
+    'ps_apply_camera_raw',
+    'ps_transform_canvas',
+    'ps_guides',
+    'ps_retouch',
+    'ps_apply_brush_stroke',
+    'ps_edit_object',
+    'ps_portrait_touchup',
+    'ps_add_text_to_object',
+    'ps_select_face_feature',
+    'ps_stroke_face_contour',
+    'ps_select_by_reference',
+    'ps_select',
+    'ps_select_subject',
+    'ps_select_sky',
+    'ps_select_subject_instance',
+    'ps_select_object',
+    'ps_replace_sky',
+    'ps_modify_selection',
+    'ps_selection_channel',
+    'ps_layer_mask',
+    'ps_path',
+    'ps_vector_mask',
+    'ps_apply_image',
+    'ps_calculations',
+    'ps_shape',
+    'ps_template_apply',
+    'ps_text',
+    'gimp_open_document',
+    'gimp_close_document',
+    'gimp_add_adjustment',
+    'gimp_add_effect',
+    'gimp_filter',
+    'gimp_crop_document',
+    'gimp_resize_image',
+    'gimp_transform_canvas',
+    'gimp_create_mask',
+    'gimp_checkpoint',
+    'gimp_layer',
+    'gimp_bake',
+    'gimp_create_document',
+    'gimp_place_image',
+    'gimp_canvas',
+    'gimp_convert_image_mode',
+]);
+export const RAW_DEVELOP_TOOL = 'ps_develop_raw';
+export const CAMERA_RAW_TOOL = 'ps_apply_camera_raw';

package/dist/core/tool-groups.js

@@ -171,6 +171,30 @@ export const TOOL_GROUPS = {
     ps_play_action: 'automation',
     ps_execute_script: 'automation',
     ps_batch: 'automation',
+    gimp_ping: 'core',
+    gimp_overview: 'core',
+    gimp_inspect: 'inspect',
+    gimp_get_preview: 'verify',
+    gimp_get_histogram: 'verify',
+    gimp_compare: 'verify',
+    gimp_open_document: 'document',
+    gimp_close_document: 'document',
+    gimp_save_xcf: 'document',
+    gimp_export: 'document',
+    gimp_crop_document: 'document',
+    gimp_resize_image: 'document',
+    gimp_transform_canvas: 'document',
+    gimp_add_adjustment: 'adjust',
+    gimp_filter: 'filter',
+    gimp_add_effect: 'filter',
+    gimp_create_mask: 'masks',
+    gimp_checkpoint: 'document',
+    gimp_layer: 'layers',
+    gimp_bake: 'layers',
+    gimp_create_document: 'document',
+    gimp_place_image: 'layers',
+    gimp_canvas: 'document',
+    gimp_convert_image_mode: 'document',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -89,6 +89,30 @@ export const TOOL_TIERS = {
     ps_template_recall: 'pro',
     ps_template_delete: 'pro',
     ps_text: 'community',
+    gimp_ping: 'community',
+    gimp_overview: 'community',
+    gimp_open_document: 'community',
+    gimp_close_document: 'community',
+    gimp_save_xcf: 'community',
+    gimp_export: 'community',
+    gimp_inspect: 'community',
+    gimp_add_adjustment: 'community',
+    gimp_filter: 'community',
+    gimp_add_effect: 'community',
+    gimp_crop_document: 'community',
+    gimp_resize_image: 'community',
+    gimp_transform_canvas: 'community',
+    gimp_create_mask: 'community',
+    gimp_get_preview: 'community',
+    gimp_get_histogram: 'community',
+    gimp_compare: 'community',
+    gimp_checkpoint: 'community',
+    gimp_layer: 'community',
+    gimp_bake: 'community',
+    gimp_create_document: 'community',
+    gimp_place_image: 'community',
+    gimp_canvas: 'community',
+    gimp_convert_image_mode: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/diagnostics/collect.js

@@ -35,6 +35,7 @@ export async function collectDiagnostics(opts = {}) {
     const recentIds = await listRecentSessionIds(MAX_RECENT_SESSIONS, { dir: sessionsDir });
     const recent_sessions = [];
     let psVersion = opts.psVersion ?? null;
+    let gimpVersion = null;
     let mcpClient = null;
     for (const id of recentIds) {
         const entries = await readSessionLog(id, { dir: sessionsDir });
@@ -51,6 +52,8 @@ export async function collectDiagnostics(opts = {}) {
         if (meta) {
             if (!psVersion && meta.ps_version)
                 psVersion = meta.ps_version;
+            if (!gimpVersion && meta.gimp_version)
+                gimpVersion = meta.gimp_version;
             if (!mcpClient)
                 mcpClient = mcpClientLabel(meta);
         }
@@ -78,6 +81,7 @@ export async function collectDiagnostics(opts = {}) {
         node_version: process.version,
         install_id: settings.telemetry.install_id,
         ps_version: psVersion,
+        gimp_version: gimpVersion,
         mcp_client: mcpClient,
         settings: {
             telemetry_usage: settings.telemetry.usage,

package/dist/index.js

@@ -6,6 +6,8 @@ import { routeCli } from './cli/router.js';
 import { maybeActivateFromEnv } from './license/env-activation.js';
 import { refreshIfStale } from './license/entitlement.js';
 import { Logger } from './utils/logger.js';
+import { resolveBootEditors } from './backends/detect-editors.js';
+import { loadSettings } from './core/settings.js';
 const logger = new Logger('Main');
 function installProcessHandlers() {
     process.on('unhandledRejection', (reason, promise) => {
@@ -39,7 +41,9 @@ async function main() {
         logger.info('Starting Editmamei...');
         await maybeActivateFromEnv();
         await refreshIfStale();
-        const server = new EditmameiServer();
+        const { settings } = loadSettings();
+        const editors = await resolveBootEditors({ settings });
+        const server = new EditmameiServer({ editors });
         await server.start();
         let shuttingDown = false;
         const shutdown = async (signal) => {

package/dist/kernel/kernel.js

@@ -9,6 +9,7 @@ export class Kernel {
     snippet;
     resolveModuleSnippet;
     detection;
+    gimp;
     sessionId;
     logger;
     invokeDepth = new AsyncLocalStorage();
@@ -19,6 +20,7 @@ export class Kernel {
         this.snippet = deps.snippet;
         this.resolveModuleSnippet = deps.resolveModuleSnippet;
         this.detection = deps.detection;
+        this.gimp = deps.gimp;
         this.sessionId = deps.sessionId;
         this.logger = deps.logger;
     }
@@ -40,6 +42,7 @@ export class Kernel {
             executeScript: (innerBody, timeoutMs) => runScript(this.connection, innerBody, timeoutMs),
             snippet: this.snippetFor(manifest),
             detection: this.detection,
+            gimp: this.gimp,
             session: { id: this.sessionId },
             logger: new Logger(`module:${manifest.id}`),
         };

package/dist/modules/gimp/index.js

@@ -0,0 +1,43 @@
+import { KERNEL_ABI } from '../../kernel/host-api.js';
+import { EDITION } from '../../edition.js';
+import { isToolAllowedInEdition } from '../../core/tool-tiers.js';
+import { createGimpCoreTools } from '../../tools/gimp-core-tools.js';
+import { createGimpDocumentTools } from '../../tools/gimp-document-tools.js';
+import { createGimpInspectTools } from '../../tools/gimp-inspect-tools.js';
+import { createGimpAdjustmentTools } from '../../tools/gimp-adjustment-tools.js';
+import { createGimpEffectTools } from '../../tools/gimp-effect-tools.js';
+import { createGimpFilterTools } from '../../tools/gimp-filter-tools.js';
+import { createGimpGeometryTools } from '../../tools/gimp-geometry-tools.js';
+import { createGimpMaskTools } from '../../tools/gimp-mask-tools.js';
+import { createGimpVerifyTools } from '../../tools/gimp-verify-tools.js';
+import { createGimpCheckpointTools } from '../../tools/gimp-checkpoint-tools.js';
+import { createGimpLayerTools } from '../../tools/gimp-layer-tools.js';
+import { createGimpComposeTools } from '../../tools/gimp-compose-tools.js';
+export const gimpFactories = [
+    createGimpCoreTools,
+    createGimpDocumentTools,
+    createGimpInspectTools,
+    createGimpAdjustmentTools,
+    createGimpEffectTools,
+    createGimpFilterTools,
+    createGimpGeometryTools,
+    createGimpMaskTools,
+    createGimpVerifyTools,
+    createGimpCheckpointTools,
+    createGimpLayerTools,
+    createGimpComposeTools,
+];
+export const gimpModule = {
+    manifest: { id: 'gimp', name: 'Editmamei GIMP Tools', abi: KERNEL_ABI },
+    register(host) {
+        if (!host.gimp) {
+            host.logger.warn('gimpModule.register called with no host.gimp backend — skipping.');
+            return;
+        }
+        const gimp = host.gimp;
+        const defs = gimpFactories
+            .flatMap((f) => f(gimp))
+            .filter((def) => isToolAllowedInEdition(def.tool.name, EDITION));
+        host.registerTools(defs);
+    },
+};