editmamei 1.2.1 → 1.4.0

package/README.md

@@ -47,7 +47,7 @@ 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](https://github.com/editmamei/editmamei/releases/latest/download/editmamei.mcpb) directly (no system Node required, Claude Desktop ships its own runtime). Full walkthrough in the [install guide](docs/installation.md).
 
-**Requirements:** Adobe Photoshop 2026 (v27.x), Windows 10/11 or macOS 12+, Node.js 22+ (for the npm path), and an MCP-compatible AI client (Claude Desktop, Cursor, Claude Code).
+**Requirements:** Adobe Photoshop 2026 (v27.x), Windows 10/11 or macOS 13+, Node.js 22+ (for the npm path), and an MCP-compatible AI client (Claude Desktop, Cursor, Claude Code).
 
 ## A session, end to end
 
@@ -75,14 +75,14 @@ These are the choices that shape the surface, and the reason an AI assistant can
 
 ## Tool surface
 
-**79 tools across 16 capability groups** (59 Community, 20 Pro). Every tool is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license.
+**82 tools across 16 capability groups** (62 Community, 20 Pro). Every tool is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license.
 
 | Group | Edition | Tools |
 | --- | --- | --- |
 | **Core** | Community | `ping` · `overview` · `list_capabilities` · `undo` · `redo` · `report_problem` |
 | **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` |
+| **Document & canvas** | Community | `document` · `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 | `filter` |
@@ -91,7 +91,8 @@ These are the choices that shape the surface, and the reason an AI assistant can
 | **Masks & paths** | Community | `layer_mask` · `clipping_mask` · `path` · `vector_mask` · `apply_image` · `calculations` |
 | **Type** | Community | `text` |
 | **Perception** | Community | `detect` · `read_scene` · `select_by_reference` |
-| **AI selection** | Community | `select_subject` · `select_sky` |
+| **AI selection** | Community | `select_subject` · `select_sky` · `replace_sky` |
+| **Automation** | Community | `sequence` |
 | **AI selection** | Pro | `select_subject_instance` · `select_object` |
 | **Filters** | Pro | `apply_camera_raw` |
 | **Layers (warp)** | Pro | `warp_layer` |
@@ -119,7 +120,7 @@ npm run build
 npm test
 ```
 
-You need Node.js 22+ and a Go toolchain (the build compiles the `editmamei-core` binary that generates Photoshop scripts). The build warns instead of failing when Go is missing, so you can still run the test suite; set `EDITMAMEI_CORE_BIN` to a prebuilt binary if you would rather not install Go.
+You need Node.js 22+ and Go 1.21+ (the build compiles the `editmamei-core` binary that generates Photoshop scripts; it needs Go 1.27, which Go fetches for you from 1.21 on). The build warns instead of failing when Go is missing, so you can still run the test suite; set `EDITMAMEI_CORE_BIN` to a prebuilt binary if you would rather not install Go.
 
 The test suite runs without Photoshop. It verifies the ExtendScript Editmamei generates, never that Photoshop accepted it, so live verification against a real Photoshop is a separate step.
 

package/dist/cli/repair.js

@@ -26,11 +26,19 @@ export async function runRepair(opts = {}) {
         out(`  Installed ${m.sku} module v${m.version}.\n`);
     for (const s of prov.skipped)
         out(`  Skipped ${s.sku} v${s.version}: ${s.reason}.\n`);
-    for (const e of prov.errors) {
+    const tooNew = prov.errors.filter((e) => e.code === 'abi_too_new');
+    const failures = prov.errors.filter((e) => e.code !== 'abi_too_new');
+    for (const e of tooNew) {
+        out(`  The published ${e.sku} module needs a newer Editmamei than this one — ` +
+            `update Editmamei to load it. Your installed module is unchanged.\n`);
+    }
+    for (const e of failures) {
         err(`  Error: could not provision the ${e.sku} module: ${e.message}\n`);
     }
-    if (prov.errors.length > 0) {
+    if (failures.length > 0) {
         throw new Error('module re-provisioning failed');
     }
-    out('\nRestart your MCP client (Claude Desktop / Claude Code) to load Pro tools.\n');
+    if (prov.installed.length > 0 || tooNew.length === 0) {
+        out('\nRestart your MCP client (Claude Desktop / Claude Code) to load Pro tools.\n');
+    }
 }

package/dist/core/server.js

@@ -8,7 +8,7 @@ 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 { SessionLog, classifyError, NO_ERROR_TEXT_CLASS } from '../utils/session-log.js';
 import { loadSettings, applyTelemetryEnvOverrides, applyUpdateCheckEnvOverride, } from './settings.js';
 import { TelemetryClient } from '../telemetry/client.js';
 import { resolveInstallChannel } from '../install-channel.js';
@@ -107,7 +107,7 @@ export class EditmameiServer {
                 const telemetrySuccess = entry.tool === 'ps_ping' && this.lastPingReachedPs === false ? false : entry.success;
                 const isPingDowngrade = entry.tool === 'ps_ping' && !telemetrySuccess && entry.error === undefined;
                 const errorClass = classifyError(entry.error) ??
-                    (telemetrySuccess ? null : isPingDowngrade ? 'ps_not_running' : 'other');
+                    (telemetrySuccess ? null : isPingDowngrade ? 'ps_not_running' : NO_ERROR_TEXT_CLASS);
                 this.telemetry.recordCall({
                     tool: entry.tool,
                     success: telemetrySuccess,
@@ -117,7 +117,7 @@ export class EditmameiServer {
                 if (!telemetrySuccess) {
                     this.telemetry.recordDiagnostic({
                         tool: entry.tool,
-                        error_class: errorClass ?? 'other',
+                        error_class: errorClass ?? NO_ERROR_TEXT_CLASS,
                         error_message: entry.error ||
                             (isPingDowngrade
                                 ? 'ps_ping did not reach Photoshop'

package/dist/core/tool-groups.js

@@ -76,8 +76,8 @@ export const GROUPS = {
     },
     automation: {
         id: 'automation',
-        label: 'Automation (Pro)',
-        purpose: 'Batch files, play recorded Actions, and the ExtendScript escape hatch (Pro).',
+        label: 'Automation',
+        purpose: 'Run several tool calls in one round trip (community), plus batch files, recorded Actions, and the ExtendScript escape hatch (Pro).',
     },
 };
 export const TOOL_GROUPS = {
@@ -112,7 +112,6 @@ export const TOOL_GROUPS = {
     ps_select_sky: 'select_ai',
     ps_select_subject_instance: 'select_ai',
     ps_select_object: 'select_ai',
-    ps_select_focus_area: 'select_ai',
     ps_replace_sky: 'select_ai',
     ps_add_adjustment_layer: 'adjust',
     ps_apply_adjustment: 'adjust',
@@ -166,6 +165,7 @@ export const TOOL_GROUPS = {
     ps_template_verify: 'templates',
     ps_template_recall: 'templates',
     ps_template_delete: 'templates',
+    ps_sequence: 'automation',
     ps_list_actions: 'automation',
     ps_play_action: 'automation',
     ps_execute_script: 'automation',

package/dist/core/tool-registry.js

@@ -1,4 +1,6 @@
 import { Logger } from '../utils/logger.js';
+import { getToolTimeoutMs } from '../utils/operation-timeouts.js';
+import { budgetContextFor, runWithToolBudget } from '../utils/tool-budget-context.js';
 export class ToolRegistry {
     logger;
     tools;
@@ -46,7 +48,7 @@ export class ToolRegistry {
         let error;
         let result;
         try {
-            result = await definition.handler(args);
+            result = await runWithToolBudget(budgetContextFor(name, getToolTimeoutMs(name)), () => definition.handler(args));
             if (result?.isError) {
                 success = false;
                 const firstText = result.content?.find((c) => c.type === 'text');

package/dist/core/tool-tiers.js

@@ -6,9 +6,10 @@ export const TOOL_TIERS = {
     ps_play_action: 'pro',
     ps_execute_script: 'pro',
     ps_batch: 'pro',
+    ps_sequence: 'community',
     ps_add_adjustment_layer: 'community',
     ps_apply_adjustment: 'community',
-    ps_document: 'dev',
+    ps_document: 'community',
     ps_create_document: 'community',
     ps_close_document: 'community',
     ps_open_document: 'community',
@@ -68,8 +69,7 @@ export const TOOL_TIERS = {
     ps_select_sky: 'community',
     ps_select_subject_instance: 'pro',
     ps_select_object: 'pro',
-    ps_select_focus_area: 'dev',
-    ps_replace_sky: 'dev',
+    ps_replace_sky: 'community',
     ps_modify_selection: 'community',
     ps_get_selection_preview: 'community',
     ps_selection_channel: 'community',

package/dist/delivery/provision.js

@@ -2,6 +2,7 @@ import { DeliveryClient, DeliveryError } from './client.js';
 import { sha256Hex } from './crypto.js';
 import { verifyModuleSignature, verifyModuleSignatureV2, digestsRootSha256Hex, isModuleFileDigestArray, } from './signing.js';
 import { installModule, readInstalledModule } from './store.js';
+import { KERNEL_ABI } from '../kernel/host-api.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('Modules');
 const SKU_RE = /^[a-z0-9-]{2,32}$/;
@@ -52,6 +53,23 @@ export async function provisionModules(key, opts = {}) {
                 });
                 continue;
             }
+            const abi = entry.abi;
+            if (!Number.isInteger(abi) || abi < 1) {
+                result.errors.push({
+                    sku,
+                    code: 'abi_invalid',
+                    message: `the manifest entry for ${sku} declares an invalid abi '${String(abi)}' (expected a whole number of at least 1) — refusing to install it`,
+                });
+                continue;
+            }
+            if (abi > KERNEL_ABI) {
+                result.errors.push({
+                    sku,
+                    code: 'abi_too_new',
+                    message: `the published ${sku} module needs a newer Editmamei than this one (module abi ${abi}, this host runs up to abi ${KERNEL_ABI}) — update Editmamei; the installed module is left as it is`,
+                });
+                continue;
+            }
             const installed = readInstalledModule(sku, opts);
             if (installed && installed.version === latest && !opts.force) {
                 result.skipped.push({ sku, version: latest, reason: 'up-to-date' });
@@ -119,7 +137,7 @@ export async function provisionModules(key, opts = {}) {
             installModule({
                 sku,
                 version: latest,
-                abi: entry.abi,
+                abi,
                 sha256: digest,
                 alg: contentKey.alg,
                 content_key: contentKey.key,

package/dist/kernel/kernel.js

@@ -35,6 +35,7 @@ export class Kernel {
             abi: KERNEL_ABI,
             registerTools: (defs) => this.registry.registerAll(defs),
             invokeTool: (name, args) => this.invokeTool(name, args),
+            hasTool: (name) => this.registry.get(name) !== undefined,
             connection: this.connection,
             executeScript: (innerBody, timeoutMs) => runScript(this.connection, innerBody, timeoutMs),
             snippet: this.snippetFor(manifest),
@@ -73,9 +74,10 @@ export class Kernel {
             throw new Error('downloaded module export is not an EditmameiModule (expected a default export with a manifest + register())');
         }
         if (this.abiTooNew(mod.manifest))
-            return;
+            return 'abi-too-new';
         const before = this.registry.count();
         await mod.register(this.hostApiFor(mod.manifest));
         this.logger.info(`Loaded downloaded module '${mod.manifest.id}' (${mod.manifest.name}) — ${this.registry.count() - before} tools.`);
+        return 'loaded';
     }
 }

package/dist/kernel/module-lifecycle.js

@@ -7,7 +7,7 @@ import { isProEntitled } from '../license/entitlement.js';
 import { loadVerifiedModule, readInstalledModule, installedPath, PRO_SKU, } from '../delivery/store.js';
 import { provisionModules, compareVersions, VERSION_RE, } from '../delivery/provision.js';
 import { readLicense } from '../license/store.js';
-import { HOST_MIN_ABI } from './host-api.js';
+import { HOST_MIN_ABI, KERNEL_ABI } from './host-api.js';
 import { VERSION } from '../version.js';
 export function classifyModuleOutcome(inputs) {
     if (inputs.proModuleLoaded && inputs.skipReason === null)
@@ -79,9 +79,21 @@ export class ModuleLifecycle {
             this._moduleSkipReason = 'incompatible';
             return;
         }
+        if (this._proModule.abi !== null && this._proModule.abi > KERNEL_ABI) {
+            this.deps.logger.warn(`Pro module (abi ${this._proModule.abi}) needs a newer host than this build ` +
+                `(kernel abi ${KERNEL_ABI}) — booting Community; update Editmamei to load it.`);
+            this._moduleSkipReason = 'incompatible';
+            return;
+        }
         const snapshot = this.deps.toolRegistry.snapshot();
         try {
-            await this.kernel.loadDownloaded(this._proModule.importer);
+            const outcome = await this.kernel.loadDownloaded(this._proModule.importer);
+            if (outcome === 'abi-too-new') {
+                this.deps.logger.warn(`The installed Pro module needs a newer host than this build (kernel abi ` +
+                    `${KERNEL_ABI}) — booting Community; update Editmamei to load it.`);
+                this._moduleSkipReason = 'incompatible';
+                return;
+            }
             if (this._proModule.version !== null &&
                 VERSION_RE.test(this._proModule.version) &&
                 compareVersions(this._proModule.version, VERSION) > 0) {
@@ -159,11 +171,14 @@ export class ModuleLifecycle {
                 this.deps.logger.warn('Module delivery is not configured — staying Community.');
                 return;
             }
+            const abiTooNew = prov.errors.some((e) => e.code === 'abi_too_new');
             for (const e of prov.errors) {
+                if (e.code === 'abi_too_new')
+                    continue;
                 this.deps.logger.warn(`Could not re-provision the ${e.sku} module (staying Community): ${e.message}`);
             }
-            if (prov.errors.length === 0) {
-                if (reason === 'incompatible') {
+            if (prov.errors.length === 0 || abiTooNew) {
+                if (reason === 'incompatible' || abiTooNew) {
                     this.deps.logger.warn('The published Pro module does not yet support this host version — staying ' +
                         'Community. Update Editmamei when a compatible release ships; ' +
                         '`editmamei report` files a diagnostic.');
@@ -201,6 +216,11 @@ export class ModuleLifecycle {
                 this.deps.logger.info(`Pro module updated to v${m.version} — restart to load.`);
             }
             for (const e of prov.errors) {
+                if (e.code === 'abi_too_new') {
+                    this.deps.logger.info(`A newer Pro module is published but needs a newer Editmamei than this ` +
+                        `one — staying on the installed version, which works. Update Editmamei to get it.`);
+                    continue;
+                }
                 this.deps.logger.warn(`Pro-module freshness check could not provision the ${e.sku} module ` +
                     `(staying on the installed version): ${e.message}`);
             }

package/dist/modules/ce/index.js

@@ -30,7 +30,8 @@ import { createVectorMaskTools } from '../../tools/vector-mask-tools.js';
 import { createChannelComposeTools } from '../../tools/channel-compose-tools.js';
 import { createShapeTools } from '../../tools/shape-tools.js';
 import { createSkyTools } from '../../tools/sky-tools.js';
-const ceFactories = [
+import { createSequenceTools } from '../../tools/sequence-tools.js';
+export const ceFactories = [
     createDocumentTools,
     createLayerTools,
     createGroupTools,
@@ -67,6 +68,12 @@ export const ceModule = {
         const defs = [
             ...ceFactories.flatMap((f) => f(connection, snippet)),
             ...createSceneTools(connection, snippet, { invokeTool: host.invokeTool }),
+            ...createSequenceTools(host.invokeTool, (name) => {
+                if (!host.hasTool) {
+                    throw new Error(`cannot validate "${name}" — this host does not expose hasTool`);
+                }
+                return host.hasTool(name);
+            }),
         ].filter((def) => isToolAllowedInEdition(def.tool.name, EDITION));
         host.registerTools(defs);
     },

package/dist/perception/facets.js

@@ -41,7 +41,7 @@ export function estimateHorizon(rowMeans, docHeight, pick, mainSubjectBox, prima
     const split = pick.bright_fraction;
     const splitConfidence = Math.max(0, Math.min(1, 1 - Math.abs(0.5 - split) * 2)) * 0.6 + 0.2;
     if (!rowMeans || rowMeans.length === 0) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'no-row-profile' };
     }
     const R = rowMeans.length;
     let crossRow = -1;
@@ -52,14 +52,15 @@ export function estimateHorizon(rowMeans, docHeight, pick, mainSubjectBox, prima
         }
     }
     if (crossRow <= 0) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'no-luminance-crossing' };
     }
     const y = Math.round((crossRow / R) * docHeight);
     if ((mainSubjectBox && isDominantSubjectCrossing(y, docHeight, mainSubjectBox)) ||
         (primaryFaceBox && isPortraitFaceCrossing(y, docHeight, primaryFaceBox))) {
-        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+        return { detected: false, reason: 'dominant-subject' };
     }
     return {
+        detected: true,
         y,
         placement: y / docHeight,
         confidence: Math.max(0, Math.min(1, splitConfidence)),

package/dist/perception/grounding-locate.js

@@ -254,17 +254,19 @@ export const PLACEMENT_SCHEMA = {
     type: 'object',
     description: 'ANCHOR-RELATIONAL placement (preferred over guessing pixels): name anchors + a relation and the ' +
         'spatial-grounding resolver computes the geometry, verified by an objective gate; the action runs ONLY if the ' +
-        'gate PASSES. For a HARD or ambiguous placement, first concur on ps_resolve_placement (review_crop: true) — a ' +
-        'read-only zoomed crop with a marker at the resolved spot — then pass the SAME anchors + relation here. See ' +
-        'ps_resolve_placement for the full anchors + relation vocabulary.',
+        'gate PASSES. For a HARD or ambiguous placement, first concur with the placement-resolver tool — when this ' +
+        'build has one, it appears in tools/list — by calling it with review_crop: true for a read-only zoomed crop ' +
+        'with a marker at the resolved spot, then pass the SAME anchors + relation here. The full anchors + relation ' +
+        'vocabulary is documented on that tool.',
     properties: {
         anchors: {
             type: 'array',
-            description: 'Named anchors, same vocabulary as ps_resolve_placement (face/object/grid/extremum/corner/edge/landmark).',
+            description: 'Named anchors, same vocabulary as the placement-resolver tool, when this build has one ' +
+                '(face/object/grid/extremum/corner/edge/landmark).',
         },
         relation: {
             type: 'object',
-            description: 'The relation, same vocabulary as ps_resolve_placement.',
+            description: 'The relation, same vocabulary as the placement-resolver tool, when this build has one.',
         },
         max_dimension: {
             type: 'number',

package/dist/perception/region-scorer.js

@@ -49,7 +49,7 @@ export function buildRegionSignals(info, scene) {
         centroidY = (bounds.top + bounds.bottom) / 2 / docH;
         touchesBottom = bounds.bottom >= docH * 0.97;
         touchesTop = bounds.top <= docH * 0.03;
-        if (scene.horizonConfidence > 0) {
+        if (scene.horizonConfidence > 0 && scene.horizonY !== null) {
             lowerEdgeAlign = 1 - Math.min(1, Math.abs(bounds.bottom - scene.horizonY) / docH);
             upperEdgeAlign = 1 - Math.min(1, Math.abs(bounds.top - scene.horizonY) / docH);
         }

package/dist/perception/scene-model.js

@@ -142,7 +142,7 @@ export async function buildSceneModel(connection, snippet, client, opts = {}) {
             recipe: { kind: 'posterize_region', levels: 3, sample: 'below_horizon' },
         },
     ];
-    const composition = computeComposition(mainBox, allBoxes, docW, docH, horizon.placement);
+    const composition = computeComposition(mainBox, allBoxes, docW, docH, horizon.detected ? horizon.placement : null);
     const backends = {
         faces: det.result.backends.faces,
         objects: det.result.backends.objects,

package/dist/perception/select-recipes.js

@@ -58,8 +58,8 @@ function sceneCtx(model) {
     return {
         docW: model.doc.width,
         docH: model.doc.height,
-        horizonY: model.horizon.y,
-        horizonConfidence: model.horizon.confidence,
+        horizonY: model.horizon.detected ? model.horizon.y : null,
+        horizonConfidence: model.horizon.detected ? model.horizon.confidence : 0,
         indoorObjectCount,
     };
 }
@@ -490,7 +490,18 @@ async function resolveFaceFeature(connection, snippet, target, feature, opts) {
     };
 }
 async function resolveAboveHorizon(connection, snippet, model, composition) {
-    const y = Math.max(1, Math.min(model.doc.height, model.horizon.y));
+    const horizon = model.horizon;
+    if (!horizon.detected) {
+        return {
+            target: 'above_horizon',
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: [`no horizon was measured in this frame (${horizon.reason})`],
+            detail: { horizon_detected: false, horizon_reason: horizon.reason },
+        };
+    }
+    const y = Math.max(1, Math.min(model.doc.height, horizon.y));
     const result = (await runScript(connection, await snippet.build('selectRectangle', {
         left: 0,
         top: 0,

package/dist/platform/launch-readiness.js

@@ -0,0 +1,25 @@
+const DEFAULT_POLL_INTERVAL_MS = 250;
+export const LAUNCH_READY_MAX_WAIT_MS = 5_000;
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms).unref();
+    });
+}
+export async function waitForLaunchReady(isReady, options = {}) {
+    const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const maxWaitMs = options.maxWaitMs ?? LAUNCH_READY_MAX_WAIT_MS;
+    const sleep = options.sleep ?? defaultSleep;
+    const isAborted = options.isAborted ?? (() => false);
+    const now = options.now ?? Date.now;
+    const deadline = now() + maxWaitMs;
+    while (now() < deadline) {
+        if (isAborted())
+            return false;
+        if (await isReady())
+            return true;
+        if (now() >= deadline)
+            break;
+        await sleep(intervalMs);
+    }
+    return false;
+}

package/dist/platform/macos-runner.js

@@ -2,12 +2,14 @@ import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { Logger } from '../utils/logger.js';
 import { TempDir } from '../utils/temp.js';
+import { DEFAULT_SCRIPT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 import { ScriptQueue } from './script-queue.js';
 import { runChildWithTimeout } from './run-child.js';
 import { decodeScriptResult } from './script-result.js';
+import { waitForLaunchReady } from './launch-readiness.js';
 const execAsync = promisify(exec);
-const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
-const LAUNCH_GRACE_MS = 5_000;
+const LAUNCH_PROBE_TIMEOUT_MS = 2_000;
+const IS_RUNNING_EXEC_TIMEOUT_MS = 3_000;
 const UNSAFE_IN_APPLESCRIPT_LITERAL = /["\\\r\n\t]/;
 export class MacOSScriptRunner {
     logger = new Logger('MacOSScriptRunner');
@@ -69,7 +71,9 @@ end timeout`;
     }
     async isRunning() {
         try {
-            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"');
+            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"', {
+                timeout: IS_RUNNING_EXEC_TIMEOUT_MS,
+            });
             return stdout.trim().length > 0;
         }
         catch {
@@ -81,14 +85,20 @@ end timeout`;
             this.logger.info('Launching Photoshop', executablePath);
             const child = spawn('open', ['-a', executablePath], { detached: true, stdio: 'ignore' });
             child.unref();
-            const grace = setTimeout(() => {
-                grace.unref();
-                resolve();
-            }, LAUNCH_GRACE_MS);
+            let aborted = false;
             child.on('error', (error) => {
-                clearTimeout(grace);
+                aborted = true;
                 reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
             });
+            const probe = () => this.run("'pong';", LAUNCH_PROBE_TIMEOUT_MS)
+                .then(() => true)
+                .catch(() => false);
+            waitForLaunchReady(probe, { isAborted: () => aborted })
+                .catch(() => false)
+                .then(() => {
+                if (!aborted)
+                    resolve();
+            });
         });
     }
 }

package/dist/platform/script-queue.js

@@ -8,23 +8,7 @@ export class ScriptQueue {
     }
     enqueue(run, timeout) {
         return new Promise((resolve, reject) => {
-            const task = {
-                run,
-                resolve,
-                reject,
-                cancelled: false,
-                settled: false,
-                timeoutId: null,
-            };
-            task.timeoutId = setTimeout(() => {
-                if (task.settled)
-                    return;
-                task.cancelled = true;
-                task.settled = true;
-                task.timeoutId = null;
-                reject(new Error('Script execution timeout'));
-            }, timeout + QUEUE_SLACK_MS);
-            this.queue.push(task);
+            this.queue.push({ run, timeout, resolve, reject, settled: false, timeoutId: null });
             void this.processQueue();
         });
     }
@@ -45,8 +29,10 @@ export class ScriptQueue {
         try {
             while (this.queue.length > 0) {
                 const task = this.queue.shift();
-                if (task.cancelled)
-                    continue;
+                task.timeoutId = setTimeout(() => {
+                    this.settleTask(task, () => task.reject(new Error('Script execution timeout')));
+                }, task.timeout + QUEUE_SLACK_MS);
+                task.timeoutId.unref?.();
                 try {
                     const result = await task.run();
                     this.settleTask(task, () => task.resolve(result));

package/dist/platform/windows-runner.js

@@ -2,12 +2,14 @@ import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { Logger } from '../utils/logger.js';
 import { TempDir } from '../utils/temp.js';
+import { DEFAULT_SCRIPT_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 import { ScriptQueue } from './script-queue.js';
 import { runChildWithTimeout } from './run-child.js';
 import { decodeScriptResult } from './script-result.js';
+import { waitForLaunchReady } from './launch-readiness.js';
 const execAsync = promisify(exec);
-const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
-const LAUNCH_GRACE_MS = 5_000;
+const LAUNCH_PROBE_TIMEOUT_MS = 2_000;
+const IS_RUNNING_EXEC_TIMEOUT_MS = 3_000;
 export class WindowsScriptRunner {
     logger = new Logger('WindowsScriptRunner');
     queue = new ScriptQueue(this.logger);
@@ -59,7 +61,9 @@ End If
     }
     async isRunning() {
         try {
-            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"');
+            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"', {
+                timeout: IS_RUNNING_EXEC_TIMEOUT_MS,
+            });
             return stdout.toLowerCase().includes('photoshop.exe');
         }
         catch {
@@ -71,14 +75,20 @@ End If
             this.logger.info('Launching Photoshop', executablePath);
             const child = spawn(executablePath, [], { detached: true, stdio: 'ignore' });
             child.unref();
-            const grace = setTimeout(() => {
-                grace.unref();
-                resolve();
-            }, LAUNCH_GRACE_MS);
+            let aborted = false;
             child.on('error', (error) => {
-                clearTimeout(grace);
+                aborted = true;
                 reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
             });
+            const probe = () => this.run("'pong';", LAUNCH_PROBE_TIMEOUT_MS)
+                .then(() => true)
+                .catch(() => false);
+            waitForLaunchReady(probe, { isAborted: () => aborted })
+                .catch(() => false)
+                .then(() => {
+                if (!aborted)
+                    resolve();
+            });
         });
     }
 }