editmamei 1.5.0 → 1.6.0

package/dist/core/server.js

@@ -5,6 +5,7 @@ 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 { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
@@ -19,6 +20,7 @@ import { createHash } from 'node:crypto';
 import { GoSnippetClient, coreBinaryName } from '../api/snippet-client.js';
 import { isProEntitled } from '../license/entitlement.js';
 import { createPingLicenseRefresher } from '../license/ping-refresh.js';
+import { licenseAdvisory } from '../license/advisory.js';
 import { runScript } from '../utils/run-script.js';
 import { listTemplates } from '../utils/template-storage.js';
 import { toolErrorResult } from '../utils/tool-helpers.js';
@@ -28,6 +30,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) {
@@ -67,6 +72,9 @@ export class EditmameiServer {
     session;
     sessionLog;
     telemetry;
+    editorOpts;
+    gimpBackend;
+    lastLoggedGimpVersion;
     kernel;
     moduleLifecycle;
     get moduleSkipReason() {
@@ -84,7 +92,24 @@ export class EditmameiServer {
     updateNoticeShown = false;
     snippetClient = new GoSnippetClient();
     refreshLicenseOnPing = createPingLicenseRefresher();
+    moduleUpdateFailed = false;
+    licenseAdvisorySource;
+    licenseStoreOptions;
+    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());
@@ -121,6 +146,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({
@@ -189,56 +221,77 @@ export class EditmameiServer {
                 capRoots: caps?.roots != null,
             });
         };
+        this.licenseAdvisorySource =
+            opts.licenseAdvisory ??
+                ((advisoryOpts) => {
+                    if (process.env.VITEST !== undefined || process.env.NODE_ENV === 'test')
+                        return null;
+                    return licenseAdvisory(advisoryOpts);
+                });
         this.registerTools();
         this.setupHandlers();
     }
+    buildLicenseAdvisoryNote() {
+        if (this.licenseAdvisoryShown)
+            return { note: '', stamp: () => { } };
+        const text = this.licenseAdvisorySource({ moduleUpdateFailed: this.moduleUpdateFailed });
+        if (!text)
+            return { note: '', stamp: () => { } };
+        return {
+            note: ' ' + text,
+            stamp: () => {
+                this.licenseAdvisoryShown = true;
+            },
+        };
+    }
     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',
@@ -274,9 +327,14 @@ export class EditmameiServer {
         this.moduleLifecycle = new ModuleLifecycle({
             toolRegistry: this.toolRegistry,
             logger: this.logger,
+            licenseStore: this.licenseStoreOptions,
             assertToolsClassified: () => this.assertToolsClassified(),
             classifyTool: (name) => this.classifyTool(name),
-            onModuleUpdate: (outcome) => this.telemetry.setModuleUpdate(outcome),
+            onModuleUpdate: (outcome) => {
+                if (outcome === 'failed')
+                    this.moduleUpdateFailed = true;
+                this.telemetry.setModuleUpdate(outcome);
+            },
         });
         const proModule = this.moduleLifecycle.resolveProModule();
         this.kernel = new Kernel({
@@ -284,6 +342,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,
@@ -291,11 +350,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() {
@@ -378,7 +448,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 ?? ''));
             }
@@ -386,12 +456,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();
         }
     }
@@ -425,6 +495,11 @@ export class EditmameiServer {
         if (this.updateCheck)
             await this.updateCheck;
         const update = await this.buildUpdateNotice();
+        const advisory = this.buildLicenseAdvisoryNote();
+        const withAdvisory = (text) => {
+            advisory.stamp();
+            return text + advisory.note;
+        };
         const connection = this.session.getConnection();
         let version = 'Unknown';
         let actionSetsCount = 0;
@@ -451,8 +526,8 @@ export class EditmameiServer {
                 content: [
                     {
                         type: 'text',
-                        text: 'Photoshop does not appear to be running. Start Photoshop, then call ps_ping again.' +
-                            update.note,
+                        text: withAdvisory('Photoshop does not appear to be running. Start Photoshop, then call ps_ping again.' +
+                            update.note),
                     },
                 ],
                 structuredContent: {
@@ -478,7 +553,7 @@ export class EditmameiServer {
                     content: [
                         {
                             type: 'text',
-                            text: (reason ?? 'Photoshop did not respond') + update.note,
+                            text: withAdvisory((reason ?? 'Photoshop did not respond') + update.note),
                         },
                     ],
                     structuredContent: {
@@ -501,7 +576,12 @@ export class EditmameiServer {
                 this.lastDocDepth = null;
                 this.lastDocMode = null;
                 return {
-                    content: [{ type: 'text', text: 'Photoshop did not respond' + update.note }],
+                    content: [
+                        {
+                            type: 'text',
+                            text: withAdvisory('Photoshop did not respond' + update.note),
+                        },
+                    ],
                     structuredContent: {
                         connected: false,
                         update_available: this.updateInfo,
@@ -567,11 +647,11 @@ export class EditmameiServer {
             content: [
                 {
                     type: 'text',
-                    text: `Connected to Photoshop (v${version}). ` +
+                    text: withAdvisory(`Connected to Photoshop (v${version}). ` +
                         `${actionSetsCount} custom action set(s), ${userTemplates} saved template(s), ` +
                         `${openDocuments.length} open document(s)${openDocuments.length ? ': ' + openDocuments.join(', ') : ''}` +
                         `${degradedNote}.` +
-                        update.note,
+                        update.note),
                 },
             ],
             structuredContent: {
@@ -626,18 +706,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,114 @@
+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_filter',
+    'gimp_crop_document',
+    'gimp_resize_image',
+    'gimp_transform_canvas',
+    'gimp_create_mask',
+]);
+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,22 @@ 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_create_mask: 'masks',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -89,6 +89,22 @@ 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_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',
 };
 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}`),
         };