editmamei 1.3.0 → 1.4.0

package/dist/tools/sequence-tools.js

@@ -0,0 +1,435 @@
+import { validateArgs } from '../utils/validate.js';
+import { toolErrorResult } from '../utils/tool-helpers.js';
+import { SEQUENCE_OVERALL_TIMEOUT_MS } from '../utils/operation-timeouts.js';
+const SEQUENCE_TOOL_NAME = 'ps_sequence';
+const MIN_STEPS = 1;
+const MAX_STEPS = 25;
+export const HISTORY_UNSAFE_TOOLS = new Set([
+    'ps_open_document',
+    'ps_create_document',
+    'ps_close_document',
+    'ps_save_psd',
+    'ps_export',
+    'ps_document',
+    'ps_undo',
+    'ps_redo',
+]);
+const HISTORY_UNSAFE_TOOLS_LIST = Array.from(HISTORY_UNSAFE_TOOLS).join(', ');
+const stepItemSchema = {
+    type: 'object',
+    description: 'One call: `tool` is a registered tool name, `args` is the object it would normally receive.',
+    properties: {
+        tool: { type: 'string', description: 'A tool name from tools/list, e.g. "ps_set_layer".' },
+        args: {
+            type: 'object',
+            description: 'Arguments for that call, exactly as the named tool expects them.',
+        },
+    },
+    required: ['tool'],
+};
+const sequenceSchema = {
+    type: 'object',
+    properties: {
+        steps: {
+            type: 'array',
+            description: `Ordered list of tool calls to run against the current document, ${MIN_STEPS} to ${MAX_STEPS} items.`,
+            items: stepItemSchema,
+            minItems: MIN_STEPS,
+            maxItems: MAX_STEPS,
+        },
+        on_error: {
+            type: 'string',
+            enum: ['stop', 'continue', 'rollback'],
+            default: 'stop',
+            description: `stop: halt at the first failing step and return results so far. continue: record the failure and run every remaining step anyway. rollback: on the first failing step, undo back to the history state captured before step one and VERIFY the document actually landed there (index, state name, and active document all re-checked) before reporting success — refused at VALIDATION time (before any step runs) if any step names one of: ${HISTORY_UNSAFE_TOOLS_LIST}, since those sit outside what the history cursor can undo. Assumes nothing else edits the document while the sequence runs; a manual edit interleaved between steps corrupts the undo distance rollback computes.`,
+        },
+        return: {
+            type: 'string',
+            enum: ['summary', 'full'],
+            default: 'summary',
+            description: "summary: one line per step plus the LAST step's full result. full: every step's full result — note this means every embedded payload (not just the last step's) lands in the logged call record. Either way, an inline preview (image content) is stripped from every step except the last — previews are most of a result's bytes, and a sequence exists to stop paying for them on intermediate steps.",
+        },
+    },
+    required: ['steps'],
+};
+const stepResultItemSchema = {
+    type: 'object',
+    properties: {
+        index: { type: 'number' },
+        tool: { type: 'string' },
+        ok: { type: 'boolean' },
+        duration_ms: { type: 'number' },
+        text: {
+            type: 'string',
+            description: "The first line of that step's own result text (return='summary').",
+        },
+        result: {
+            type: 'object',
+            description: "That step's full CallToolResult (return='full').",
+        },
+    },
+    required: ['index', 'tool', 'ok'],
+};
+const sequenceOutputSchema = {
+    type: 'object',
+    properties: {
+        on_error: { type: 'string' },
+        return: { type: 'string' },
+        total_steps: { type: 'number' },
+        ran_steps: {
+            type: 'number',
+            description: 'How many steps actually ran — excludes a step skipped by the time budget.',
+        },
+        failed_step: {
+            type: ['object', 'null'],
+            description: 'The first failing step, or the step skipped by the overall time budget. Null when every step succeeded.',
+            properties: {
+                index: { type: 'number' },
+                tool: { type: 'string' },
+            },
+        },
+        cap_exceeded: { type: 'boolean' },
+        rolled_back: { type: 'boolean' },
+        rollback_reason: {
+            type: 'string',
+            description: 'Set only when on_error="rollback" and rolled_back is false: history_evicted, undo_failed, cursor_moved_backward, or document_changed.',
+            enum: ['history_evicted', 'undo_failed', 'cursor_moved_backward', 'document_changed'],
+        },
+        steps: {
+            type: 'array',
+            description: 'One entry per step run — carries `text` in summary mode, `result` in full mode.',
+            items: stepResultItemSchema,
+        },
+        final: {
+            type: 'object',
+            description: "The last step's full CallToolResult (summary mode only).",
+        },
+    },
+    required: ['on_error', 'return', 'total_steps', 'ran_steps', 'steps'],
+};
+function validateSequenceArgs(rawArgs, hasTool) {
+    const args = validateArgs(sequenceSchema, rawArgs);
+    const rawSteps = args.steps;
+    if (!Array.isArray(rawSteps)) {
+        throw new Error('"steps" must be an array');
+    }
+    if (rawSteps.length < MIN_STEPS || rawSteps.length > MAX_STEPS) {
+        throw new Error(`"steps" must contain ${MIN_STEPS} to ${MAX_STEPS} items, got ${rawSteps.length}`);
+    }
+    const steps = rawSteps.map((raw, i) => {
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new Error(`step ${i + 1}: expected an object with "tool" and "args"`);
+        }
+        const stepObj = raw;
+        const tool = stepObj.tool;
+        if (typeof tool !== 'string' || tool.length === 0) {
+            throw new Error(`step ${i + 1}: "tool" must be a non-empty string`);
+        }
+        if (tool === SEQUENCE_TOOL_NAME) {
+            throw new Error(`step ${i + 1}: cannot nest ${SEQUENCE_TOOL_NAME} inside itself`);
+        }
+        if (!hasTool(tool)) {
+            throw new Error(`step ${i + 1}: "${tool}" is not a tool registered right now`);
+        }
+        const rawStepArgs = stepObj.args;
+        if (rawStepArgs !== undefined &&
+            (typeof rawStepArgs !== 'object' || rawStepArgs === null || Array.isArray(rawStepArgs))) {
+            throw new Error(`step ${i + 1}: "args" must be an object`);
+        }
+        return { tool, args: rawStepArgs ?? {} };
+    });
+    const onError = args.on_error;
+    const returnMode = args.return;
+    if (onError === 'rollback') {
+        const firstUnsafe = steps.findIndex((s) => HISTORY_UNSAFE_TOOLS.has(s.tool));
+        if (firstUnsafe !== -1) {
+            const tool = steps[firstUnsafe].tool;
+            throw new Error(`step ${firstUnsafe + 1}: on_error="rollback" can't be honored because "${tool}" is one of the tools ps_sequence treats as unsafe for rollback (${HISTORY_UNSAFE_TOOLS_LIST}) — outside what the history cursor can undo. Use on_error="stop" or "continue", or drop that step.`);
+        }
+    }
+    return { steps, onError, returnMode };
+}
+function syntheticError(message) {
+    return { content: [{ type: 'text', text: message }], isError: true };
+}
+function firstTextLine(result) {
+    const block = result.content?.find((b) => b.type === 'text');
+    if (!block || !('text' in block))
+        return '';
+    const newline = block.text.indexOf('\n');
+    return newline === -1 ? block.text : block.text.slice(0, newline);
+}
+function stripImages(result) {
+    if (!Array.isArray(result.content))
+        return result;
+    const kept = result.content.filter((b) => b.type !== 'image');
+    return kept.length === result.content.length ? result : { ...result, content: kept };
+}
+function extractHistorySnapshot(result) {
+    if (result.isError)
+        return null;
+    const sc = result.structuredContent;
+    const index = sc?.currentIndex;
+    const stateName = sc?.currentState;
+    const totalStates = sc?.totalStates;
+    const documentName = sc?.context?.document?.name;
+    if (typeof index !== 'number' ||
+        !Number.isFinite(index) ||
+        typeof stateName !== 'string' ||
+        typeof totalStates !== 'number' ||
+        !Number.isFinite(totalStates)) {
+        return null;
+    }
+    return {
+        index,
+        stateName,
+        totalStates,
+        documentName: typeof documentName === 'string' ? documentName : null,
+    };
+}
+async function readHistorySnapshot(invokeTool) {
+    const result = await invokeTool('ps_inspect', { what: 'history' });
+    return extractHistorySnapshot(result);
+}
+async function performRollback(invokeTool, captured) {
+    try {
+        const before = await readHistorySnapshot(invokeTool);
+        if (before === null) {
+            return {
+                ok: false,
+                reason: 'undo_failed',
+                message: 'could not read the document history to compute the rollback distance',
+            };
+        }
+        if (before.documentName !== captured.documentName) {
+            return {
+                ok: false,
+                reason: 'document_changed',
+                message: `the active document changed since step 1 (captured "${captured.documentName}", now "${before.documentName}") — history is per-document, so nothing was undone`,
+            };
+        }
+        const delta = before.index - captured.index;
+        if (delta < 0) {
+            return {
+                ok: false,
+                reason: 'cursor_moved_backward',
+                message: `the history cursor is already earlier than the captured state (captured index ${captured.index}, now ${before.index}) — a step likely called undo or redo itself`,
+            };
+        }
+        if (delta > 0) {
+            const undone = await invokeTool('ps_undo', { steps: delta });
+            if (undone.isError) {
+                return {
+                    ok: false,
+                    reason: 'undo_failed',
+                    message: `ps_undo failed: ${firstTextLine(undone)}`,
+                };
+            }
+        }
+        const after = await readHistorySnapshot(invokeTool);
+        if (after === null) {
+            return {
+                ok: false,
+                reason: 'undo_failed',
+                message: 'could not re-read the document history to verify the rollback',
+            };
+        }
+        if (after.documentName !== captured.documentName) {
+            return {
+                ok: false,
+                reason: 'document_changed',
+                message: `the active document changed during rollback (captured "${captured.documentName}", now "${after.documentName}")`,
+            };
+        }
+        if (after.index !== captured.index || after.stateName !== captured.stateName) {
+            return {
+                ok: false,
+                reason: 'history_evicted',
+                message: `the history state Photoshop reports at index ${after.index} ("${after.stateName}") does not match what was captured ` +
+                    `(index ${captured.index}, "${captured.stateName}") — Photoshop's history buffer is finite and likely evicted it ` +
+                    `(captured ${captured.totalStates} total states, now ${after.totalStates})`,
+            };
+        }
+        return {
+            ok: true,
+            message: delta > 0
+                ? `document verified restored to its state before step 1 ("${captured.stateName}", ${delta} step${delta === 1 ? '' : 's'} undone)`
+                : `document verified already at its state before step 1 ("${captured.stateName}"); no edits to undo`,
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { ok: false, reason: 'undo_failed', message: `rollback failed: ${msg}` };
+    }
+}
+function buildMessage(input) {
+    const { ranSteps, total, onError, failedStep, capExceeded, rolledBack, rollbackMessage } = input;
+    if (capExceeded && failedStep) {
+        const base = `Sequence exceeded its overall time budget (${SEQUENCE_OVERALL_TIMEOUT_MS}ms) before step ${failedStep.index + 1} (${failedStep.tool}) could run; stopped after ${ranSteps}/${total} step(s).`;
+        if (onError !== 'rollback')
+            return base;
+        return rolledBack
+            ? `${base} Document rolled back: ${rollbackMessage}.`
+            : `${base} Rollback did not complete: ${rollbackMessage}.`;
+    }
+    if (!failedStep) {
+        return `Sequence completed all ${total} step(s).`;
+    }
+    if (onError === 'continue') {
+        return `Sequence completed all ${total} step(s); step ${failedStep.index + 1} (${failedStep.tool}) failed and was recorded.`;
+    }
+    if (onError === 'rollback') {
+        return rolledBack
+            ? `Sequence stopped at step ${failedStep.index + 1} (${failedStep.tool}) after a failure; ${rollbackMessage}.`
+            : `Sequence stopped at step ${failedStep.index + 1} (${failedStep.tool}) after a failure; rollback did not complete: ${rollbackMessage}.`;
+    }
+    return `Sequence stopped at step ${failedStep.index + 1} (${failedStep.tool}) after a failure; ${ranSteps}/${total} step(s) ran.`;
+}
+async function runSequence(invokeTool, hasTool, rawArgs, now) {
+    let parsed;
+    try {
+        parsed = validateSequenceArgs(rawArgs, hasTool);
+    }
+    catch (error) {
+        return toolErrorResult('Error validating sequence', error);
+    }
+    const { steps, onError, returnMode } = parsed;
+    let capturedHistory = null;
+    if (onError === 'rollback') {
+        let captured;
+        try {
+            captured = await readHistorySnapshot(invokeTool);
+        }
+        catch (error) {
+            return toolErrorResult('Error capturing history state before the sequence', error);
+        }
+        if (captured === null) {
+            return toolErrorResult('Error capturing history state before the sequence', new Error('ps_inspect(what="history") did not return a usable history snapshot'));
+        }
+        capturedHistory = captured;
+    }
+    const startedAt = now();
+    const entries = [];
+    let failedStep = null;
+    let capExceeded = false;
+    let rolledBack = false;
+    let rollbackReason;
+    let rollbackMessage = '';
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (now() - startedAt > SEQUENCE_OVERALL_TIMEOUT_MS) {
+            capExceeded = true;
+            if (failedStep === null)
+                failedStep = { index: i, tool: step.tool };
+            entries.push({
+                index: i,
+                tool: step.tool,
+                ok: false,
+                duration_ms: 0,
+                result: syntheticError(`Sequence exceeded its overall time budget (${SEQUENCE_OVERALL_TIMEOUT_MS}ms) before this step could run.`),
+            });
+            if (onError === 'rollback') {
+                const r = await performRollback(invokeTool, capturedHistory);
+                rolledBack = r.ok;
+                rollbackReason = r.reason;
+                rollbackMessage = r.message;
+            }
+            break;
+        }
+        const stepStarted = now();
+        let result;
+        try {
+            result = await invokeTool(step.tool, step.args);
+        }
+        catch (error) {
+            result = syntheticError(error instanceof Error ? error.message : String(error));
+        }
+        const duration_ms = now() - stepStarted;
+        const ok = !result.isError;
+        entries.push({ index: i, tool: step.tool, ok, duration_ms, result });
+        if (!ok) {
+            if (failedStep === null)
+                failedStep = { index: i, tool: step.tool };
+            if (onError === 'rollback') {
+                const r = await performRollback(invokeTool, capturedHistory);
+                rolledBack = r.ok;
+                rollbackReason = r.reason;
+                rollbackMessage = r.message;
+                break;
+            }
+            if (onError === 'stop') {
+                break;
+            }
+        }
+    }
+    const lastRealIndex = capExceeded ? entries.length - 2 : entries.length - 1;
+    const stripped = entries.map((e, idx) => idx === lastRealIndex ? e : { ...e, result: stripImages(e.result) });
+    const ranSteps = capExceeded ? entries.length - 1 : entries.length;
+    const anyFailure = failedStep !== null;
+    const isError = capExceeded || (anyFailure && onError !== 'continue');
+    const message = buildMessage({
+        ranSteps,
+        total: steps.length,
+        onError,
+        failedStep,
+        capExceeded,
+        rolledBack,
+        rollbackMessage,
+    });
+    const common = {
+        on_error: onError,
+        return: returnMode,
+        total_steps: steps.length,
+        ran_steps: ranSteps,
+        failed_step: failedStep,
+        cap_exceeded: capExceeded,
+        rolled_back: rolledBack,
+        ...(rollbackReason ? { rollback_reason: rollbackReason } : {}),
+    };
+    const structuredContent = returnMode === 'full'
+        ? {
+            ...common,
+            steps: stripped.map((e) => ({
+                index: e.index,
+                tool: e.tool,
+                ok: e.ok,
+                duration_ms: e.duration_ms,
+                result: e.result,
+            })),
+        }
+        : {
+            ...common,
+            steps: stripped.map((e) => ({
+                index: e.index,
+                tool: e.tool,
+                ok: e.ok,
+                duration_ms: e.duration_ms,
+                text: firstTextLine(e.result),
+            })),
+            final: lastRealIndex >= 0 ? stripped[lastRealIndex].result : undefined,
+        };
+    return {
+        content: [{ type: 'text', text: message }],
+        structuredContent,
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export function createSequenceTools(invokeTool, hasTool, opts = {}) {
+    const { now = Date.now } = opts;
+    return [
+        {
+            tool: {
+                name: SEQUENCE_TOOL_NAME,
+                description: "Run an ordered list of tool calls against the current document in ONE round trip. WHEN TO REACH FOR THIS: several dependent steps you already know you want (e.g. select → adjust → merge, or a repeated resize/export pass) where you do not need to look at the result between them — each step is dispatched the same way an ordinary call is and sees the document exactly as the previous step left it. Not for exploratory work: if the next step depends on inspecting this one first, call the tools individually instead. Every step must name a tool that already exists in this edition (ps_sequence cannot call itself). An inline preview (image content) returned by a step is dropped unless that step is the LAST one in the sequence, since previews are most of a result's bytes and the point of batching calls is to stop paying for them on every intermediate step. Each step keeps its own time limit, exactly as it would if you called it on its own. The sequence's overall budget only decides whether to START another step, so it never cuts one off mid-run — a call can therefore finish after that ceiling by however long the in-flight step still needs, plus the undo and its verification reads when on_error='rollback'. With return='full', every step's complete result (not just the last one's) lands in the logged call payload.",
+                inputSchema: sequenceSchema,
+                outputSchema: sequenceOutputSchema,
+                annotations: {
+                    title: 'Run a Tool Sequence',
+                    destructiveHint: true,
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => runSequence(invokeTool, hasTool, args, now),
+        },
+    ];
+}

package/dist/utils/operation-timeouts.js

@@ -1,3 +1,7 @@
+import { Logger } from './logger.js';
+const logger = new Logger('operation-timeouts');
+export const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
+export const SCRIPT_TIMEOUT_FLOOR_MS = 5_000;
 export const OPEN_DOCUMENT_TIMEOUT_MS = 120_000;
 export const OPEN_DOCUMENT_REPROBE_TIMEOUT_MS = 10_000;
 export const CAMERA_RAW_FILTER_TIMEOUT_MS = 120_000;
@@ -7,3 +11,91 @@ export const SELECT_FOCUS_AREA_TIMEOUT_MS = 120_000;
 export const SKY_REPLACEMENT_TIMEOUT_MS = 120_000;
 export const ANNOTATED_PREVIEW_TIMEOUT_MS = 90_000;
 export const SCENE_CHANNEL_TIMEOUT_MS = 120_000;
+export const SEQUENCE_OVERALL_TIMEOUT_MS = 300_000;
+export const TOOL_TIMEOUT_BUDGETS_MS = {
+    ps_open_document: OPEN_DOCUMENT_TIMEOUT_MS,
+    ps_select_subject: SELECT_SUBJECT_TIMEOUT_MS,
+    ps_select_sky: SELECT_SKY_TIMEOUT_MS,
+    ps_replace_sky: SKY_REPLACEMENT_TIMEOUT_MS,
+    ps_ping: 30_000,
+    ps_read_scene: 164_000,
+    ps_selection_channel: 123_000,
+    ps_select: 54_000,
+    ps_modify_selection: 37_000,
+    ps_save_psd: 32_000,
+    ps_filter: 31_000,
+    ps_get_histogram: 25_000,
+    ps_create_document: 20_000,
+    ps_detect: 19_000,
+    ps_get_preview: 17_000,
+    ps_resize_image: 16_000,
+    ps_get_selection_preview: 14_000,
+    ps_undo: 12_000,
+    ps_export: 9_000,
+    ps_path: 10_000,
+    ps_crop_document: 10_000,
+    ps_inspect: 7_000,
+    ps_duplicate_layer: 7_000,
+    ps_shape: 7_000,
+    ps_text: 7_000,
+    ps_set_layer: 6_000,
+    ps_bake_layer: 6_000,
+    ps_document: 30_000,
+    ps_apply_adjustment: 30_000,
+    ps_close_document: 30_000,
+    ps_group: 30_000,
+    ps_clipping_mask: 30_000,
+    ps_convert_image_mode: 30_000,
+    ps_convert_to_smart_object: 30_000,
+    ps_create_layer: 30_000,
+    ps_fill_layer: 30_000,
+    ps_select_layer: 30_000,
+    ps_transform_layer: 30_000,
+    ps_transform_canvas: 30_000,
+    ps_guides: 30_000,
+    ps_retouch: 30_000,
+    ps_select_by_reference: 30_000,
+    ps_list_capabilities: 5_000,
+    ps_add_adjustment_layer: 5_000,
+    ps_redo: 5_000,
+    ps_place_image: 5_000,
+    ps_move_layer_to_position: 5_000,
+    ps_rasterize_layer: 5_000,
+    ps_copy_to_new_layer: 5_000,
+    ps_merge: 5_000,
+    ps_add_layer_style: 5_000,
+    ps_delete_layer: 5_000,
+    ps_add_fill_layer: 5_000,
+    ps_overview: 5_000,
+    ps_get_layer_bounds_diff: 5_000,
+    ps_compare_regions: 5_000,
+    ps_layer_mask: 5_000,
+    ps_vector_mask: 5_000,
+    ps_apply_image: 5_000,
+    ps_sequence: Number.POSITIVE_INFINITY,
+};
+export const TOOLS_WITHOUT_A_BUDGET = {
+    ps_report_problem: 'n=3 measured calls',
+    ps_calculations: 'n=8 measured calls',
+};
+const MAX_SCRIPT_TIMEOUT_SCALE = 10;
+function resolveScriptTimeoutScale() {
+    const raw = process.env.EDITMAMEI_SCRIPT_TIMEOUT_MS;
+    if (!raw)
+        return 1;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        logger.warn(`EDITMAMEI_SCRIPT_TIMEOUT_MS="${raw}" is not a positive number — ignoring it.`);
+        return 1;
+    }
+    return Math.min(n / DEFAULT_SCRIPT_TIMEOUT_MS, MAX_SCRIPT_TIMEOUT_SCALE);
+}
+export const SCRIPT_TIMEOUT_SCALE = resolveScriptTimeoutScale();
+export function getToolTimeoutMs(toolName) {
+    const base = Object.hasOwn(TOOL_TIMEOUT_BUDGETS_MS, toolName)
+        ? TOOL_TIMEOUT_BUDGETS_MS[toolName]
+        : DEFAULT_SCRIPT_TIMEOUT_MS;
+    if (!Number.isFinite(base))
+        return base;
+    return Math.max(Math.round(base * SCRIPT_TIMEOUT_SCALE), SCRIPT_TIMEOUT_FLOOR_MS);
+}

package/dist/utils/run-script.js

@@ -1,4 +1,5 @@
 import { PhotoshopAPIFactory } from '../api/photoshop-api.js';
+import { currentToolBudget } from './tool-budget-context.js';
 const apiCache = new WeakMap();
 export async function runScript(connection, script, timeoutMs) {
     let api = apiCache.get(connection);
@@ -7,5 +8,28 @@ export async function runScript(connection, script, timeoutMs) {
         api = await apiFactory.createAPI();
         apiCache.set(connection, api);
     }
-    return api.executeScript(script, timeoutMs);
+    const budget = currentToolBudget();
+    let effectiveTimeoutMs = timeoutMs;
+    if (timeoutMs === undefined && budget) {
+        const remaining = budget.deadline - Date.now();
+        if (remaining <= 0) {
+            throw new Error(`Tool '${budget.toolName}' exceeded its ${budget.budgetMs}ms budget before this script could run.`);
+        }
+        effectiveTimeoutMs = remaining;
+    }
+    try {
+        return await api.executeScript(script, effectiveTimeoutMs);
+    }
+    catch (error) {
+        if (budget && isScriptTimeoutError(error)) {
+            throw new Error(`Tool '${budget.toolName}' exceeded its ${effectiveTimeoutMs}ms budget: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+}
+function isScriptTimeoutError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return (error.message.startsWith('Script execution timeout') ||
+        /AppleEvent timed out|-1712\b/.test(error.message));
 }

package/dist/utils/session-log.js

@@ -51,6 +51,10 @@ export const ERROR_CLASS_TABLE = [
         errorClass: 'file_io',
         pattern: /\b(ENOENT|EBUSY|EACCES|EPERM|EMFILE|ENOSPC)\b/,
     },
+    {
+        errorClass: 'unknown_discriminator',
+        pattern: /unknown [^"]{1,40}"[^"]*"\. Allowed: /i,
+    },
     {
         errorClass: 'schema_validation',
         pattern: /\bvalidat|required.*field|missing required argument|must be.*type|invalid (input|argument)/i,
@@ -76,6 +80,7 @@ export const ERROR_CLASS_TABLE = [
         errorClass: 'wrong_layer_kind',
         pattern: /pixel layer|text layer|smart object layer|layer kind|rasterize it first/i,
     },
+    { errorClass: 'channel_not_visible', pattern: /histogram for visible channels/i },
     { errorClass: 'ps_command_unavailable', pattern: /not currently available/i },
     { errorClass: 'timeout', pattern: /timed? ?out|Script execution timeout|exceeded.*bytes/i },
     {
@@ -85,6 +90,10 @@ export const ERROR_CLASS_TABLE = [
     { errorClass: 'ai_selection_no_result', pattern: /returned no result/i },
     { errorClass: 'ps_general_error', pattern: /general photoshop error/i },
     { errorClass: 'ps_no_such_element', pattern: /no such element/i },
+    {
+        errorClass: 'extendscript_reference_error',
+        pattern: /\b[A-Za-z_$][\w$]*\s+is undefined\s*$/,
+    },
     { errorClass: 'write_not_verified', pattern: /did not verify/i },
     { errorClass: 'ps_empty_error', pattern: /:\s*$/ },
     { errorClass: 'ps_op_failed', pattern: /failed[: (]/i },
@@ -98,6 +107,11 @@ export function classifyError(error) {
     }
     return 'other';
 }
+export const NO_ERROR_TEXT_CLASS = 'no_error_text';
+export const ALL_ERROR_CLASSES = [
+    ...ERROR_CLASS_TABLE.map((entry) => entry.errorClass),
+    NO_ERROR_TEXT_CLASS,
+];
 export function elideImagePayloads(value) {
     if (Array.isArray(value))
         return value.map(elideImagePayloads);
@@ -270,7 +284,7 @@ export class SessionLog {
         }
         catch {
         }
-        const errorClass = classifyError(entry.error);
+        const errorClass = entry.success ? null : (classifyError(entry.error) ?? NO_ERROR_TEXT_CLASS);
         const captureResult = process.env.EDITMAMEI_LOG_RESULTS === '1' && result !== undefined
             ? this.sanitizeValue(elideImagePayloads(result))
             : undefined;

package/dist/utils/tool-budget-context.js

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const storage = new AsyncLocalStorage();
+export function budgetContextFor(toolName, budgetMs, now = Date.now()) {
+    const ownDeadline = now + budgetMs;
+    const outer = storage.getStore();
+    const deadline = outer ? Math.min(ownDeadline, outer.deadline) : ownDeadline;
+    return { toolName, budgetMs, deadline };
+}
+export function runWithToolBudget(context, fn) {
+    return storage.run(context, fn);
+}
+export function currentToolBudget() {
+    return storage.getStore();
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.3.0';
+export const VERSION = '1.4.0';

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "editmamei",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Photoshop MCP server: natural-language AI photo editing with your own Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
   "editmamei": {
     "fixesByVersion": {
+      "1.4.0": [
+        "ps_read_scene",
+        "ps_selection_channel",
+        "ps_select",
+        "ps_modify_selection"
+      ],
       "1.1.0": [
         "ps_create_clipping_mask"
       ],
@@ -65,6 +71,6 @@
     "@modelcontextprotocol/sdk": "^1.0.4",
     "adm-zip": "^0.6.0",
     "jpeg-js": "^0.4.4",
-    "onnxruntime-web": "1.27.0"
+    "onnxruntime-web": "1.29.0"
   }
 }