editmamei 1.7.0 → 1.8.0

package/dist/cli/config.js

@@ -50,6 +50,13 @@ const KEYS = {
         },
         coerce: coerceBool,
     },
+    'automation.allow_execute_script': {
+        get: (s) => s.automation.allow_execute_script,
+        set: (s, v) => {
+            s.automation.allow_execute_script = v;
+        },
+        coerce: coerceBool,
+    },
     ps_path: {
         get: (s) => s.ps_path,
         set: (s, v) => {

package/dist/cli/help.js

@@ -27,8 +27,8 @@ Install options:
 
   --skip-skill               Skip copying the editmamei skill bundle to your Downloads folder.
                              By default, install drops editmamei-skill.zip in Downloads with
-                             instructions for uploading it to claude.ai (Settings > Customize >
-                             Skills). Pass this flag for headless / CI installs where the skill
+                             instructions for uploading it to claude.ai (Settings > Skills).
+                             Pass this flag for headless / CI installs where the skill
                              upload step doesn't apply.
 
 Config examples:

package/dist/cli/install.js

@@ -61,8 +61,8 @@ export async function runInstall(opts = {}) {
     }
     if (skillResult?.status === 'copied') {
         out(`  2. Upload the editmamei skill to your Claude account:\n`);
-        out(`       - Open https://claude.ai/settings (Customize > Skills)\n`);
-        out(`       - Click "Upload skill"\n`);
+        out(`       - Open https://claude.ai/settings (Settings > Skills)\n`);
+        out(`       - Click Add, then "Upload skill"\n`);
         out(`       - Choose the file at ${skillResult.destPath}\n`);
         out(`     The skill auto-loads in any photo-editing conversation. It's a one-time upload.\n`);
         out(`  3. Then ask the AI: "Is Photoshop connected?" — it will call ps_ping and return your Photoshop version.\n`);

package/dist/core/settings.js

@@ -21,6 +21,7 @@ function defaults(installId) {
     return {
         telemetry: { usage: true, diagnostics: false, install_id: installId },
         privacy: { send_previews_to_llm: true },
+        automation: { allow_execute_script: true },
         ps_path: null,
         update_check: true,
         editor: 'auto',
@@ -34,6 +35,7 @@ function coerce(raw, installId) {
     const r = raw;
     const t = (r.telemetry ?? {});
     const p = (r.privacy ?? {});
+    const a = (r.automation ?? {});
     return {
         telemetry: {
             usage: typeof t.usage === 'boolean' ? t.usage : base.telemetry.usage,
@@ -47,6 +49,11 @@ function coerce(raw, installId) {
                 ? p.send_previews_to_llm
                 : base.privacy.send_previews_to_llm,
         },
+        automation: {
+            allow_execute_script: typeof a.allow_execute_script === 'boolean'
+                ? a.allow_execute_script
+                : base.automation.allow_execute_script,
+        },
         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)

package/dist/core/tool-activity.js

@@ -1,3 +1,9 @@
+export const RECIPE_TOOLS = new Set([
+    'ps_template_apply',
+    'ps_batch',
+    'ps_sequence',
+    'ps_play_action',
+]);
 export const READ_ONLY_TOOLS = new Set([
     'ps_sequence',
     'ps_batch',
@@ -29,6 +35,7 @@ export const READ_ONLY_TOOLS = new Set([
     'gimp_get_preview',
     'gimp_get_histogram',
     'gimp_compare',
+    'gimp_get_selection_preview',
 ]);
 export const KEPT_WORK_TOOLS = new Set([
     'ps_export',
@@ -109,14 +116,19 @@ export const MUTATING_TOOLS = new Set([
     '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_text',
     'gimp_convert_image_mode',
+    'gimp_select',
+    'gimp_modify_selection',
+    'gimp_layer_mask',
+    'gimp_transform_layer',
+    'gimp_match_layer',
 ]);
 export const RAW_DEVELOP_TOOL = 'ps_develop_raw';
 export const CAMERA_RAW_TOOL = 'ps_apply_camera_raw';

package/dist/core/tool-groups.js

@@ -187,14 +187,20 @@ export const TOOL_GROUPS = {
     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_transform_layer: 'layers',
     gimp_create_document: 'document',
     gimp_place_image: 'layers',
     gimp_canvas: 'document',
+    gimp_text: 'layers',
     gimp_convert_image_mode: 'document',
+    gimp_select: 'select',
+    gimp_modify_selection: 'select',
+    gimp_layer_mask: 'masks',
+    gimp_get_selection_preview: 'verify',
+    gimp_match_layer: 'layers',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -102,17 +102,23 @@ export const TOOL_TIERS = {
     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_transform_layer: 'community',
     gimp_create_document: 'community',
     gimp_place_image: 'community',
     gimp_canvas: 'community',
+    gimp_text: 'community',
     gimp_convert_image_mode: 'community',
+    gimp_select: 'community',
+    gimp_modify_selection: 'dev',
+    gimp_layer_mask: 'community',
+    gimp_get_selection_preview: 'community',
+    gimp_match_layer: 'dev',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/install-channel.js

@@ -30,6 +30,8 @@ export function resolveInstallChannel(env = process.env, edition = EDITION, argv
         return 'dev';
     if (env.EDITMAMEI_INSTALL_CHANNEL === 'mcpb')
         return 'mcpb';
+    if (env.EDITMAMEI_INSTALL_CHANNEL === 'plugin')
+        return 'plugin';
     const trimmedArgv1 = argv1?.trim();
     if (!trimmedArgv1)
         return 'unknown';

package/dist/modules/gimp/index.js

@@ -8,11 +8,14 @@ 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 { createGimpTransformLayerTools } from '../../tools/gimp-transform-layer-tools.js';
 import { createGimpComposeTools } from '../../tools/gimp-compose-tools.js';
+import { createGimpTextTools } from '../../tools/gimp-text-tools.js';
+import { createGimpSelectionTools } from '../../tools/gimp-selection-tools.js';
+import { createGimpMatchTools } from '../../tools/gimp-match-tools.js';
 export const gimpFactories = [
     createGimpCoreTools,
     createGimpDocumentTools,
@@ -21,11 +24,14 @@ export const gimpFactories = [
     createGimpEffectTools,
     createGimpFilterTools,
     createGimpGeometryTools,
-    createGimpMaskTools,
     createGimpVerifyTools,
     createGimpCheckpointTools,
     createGimpLayerTools,
+    createGimpTransformLayerTools,
     createGimpComposeTools,
+    createGimpTextTools,
+    createGimpSelectionTools,
+    createGimpMatchTools,
 ];
 export const gimpModule = {
     manifest: { id: 'gimp', name: 'Editmamei GIMP Tools', abi: KERNEL_ABI },

package/dist/telemetry/client.js

@@ -7,7 +7,7 @@ import { READ_ONLY_TOOLS, KEPT_WORK_TOOLS, nodeMajor, archToken, osMajor, boundM
 import { buildClientConnected, buildDiagnosticEvent, buildModuleStatus, buildSessionStart, buildSessionSummary, buildUsageEvent, dayBucket, normalizeDayBucket, isContentSafe, PS_VERSION_UNKNOWN, } from './events.js';
 import { sanitizeMessage, sanitizeSnippet, sanitizeStderrTail } from './sanitize.js';
 import { httpTransport, resolveEndpoint } from './transport.js';
-import { appendOutboxSync, clearOutbox, clearSessionState, readOutboxWithDiscards, readSessionState, rewriteOutbox, writeSessionStateSync, } from './outbox.js';
+import { appendOutboxSync, claimOrphanedSessionStates, claimOutboxForDrain, clearSessionState, writeSessionStateSync, } from './outbox.js';
 const MAX_BATCH_SIZE = 100;
 const MAX_QUEUE_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 5 * 60_000;
@@ -50,6 +50,8 @@ export class TelemetryClient {
     moduleUpdate = 'none';
     installAssets = {};
     lastSessionPersistMs = 0;
+    sessionStatePersisted = false;
+    startupFlushStarted = false;
     startDayBucket = null;
     constructor(opts) {
         this.settings = opts.settings;
@@ -59,7 +61,11 @@ export class TelemetryClient {
         this.flushIntervalMs = opts.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
         this.maxBatchSize = opts.maxBatchSize ?? MAX_BATCH_SIZE;
         this.active = opts.active ?? (EDITION !== 'dev' && !isTestEnv());
-        this.outboxOpts = opts.outboxDir ? { dir: opts.outboxDir } : {};
+        this.outboxOpts = {
+            ...(opts.outboxDir ? { dir: opts.outboxDir } : {}),
+            ...(opts.outboxPid !== undefined ? { pid: opts.outboxPid } : {}),
+            ...(opts.isPidAlive ? { isPidAlive: opts.isPidAlive } : {}),
+        };
         this.getModuleStatus = opts.getModuleStatus ?? (() => null);
         this.dims = {
             install_id: this.settings.telemetry.install_id,
@@ -200,6 +206,7 @@ export class TelemetryClient {
             ...this.summaryFields(),
         };
         writeSessionStateSync(state, this.outboxOpts);
+        this.sessionStatePersisted = true;
     }
     onPsVersionResolved() {
         if (!this.active || !this.settings.telemetry.usage || this.toolCallCount === 0)
@@ -297,22 +304,27 @@ export class TelemetryClient {
         clearSessionState(this.outboxOpts);
     }
     async flushOutboxOnStartup() {
-        if (!this.active)
+        if (!this.active || this.startupFlushStarted)
             return;
+        this.startupFlushStarted = true;
         try {
-            const stale = readSessionState(this.outboxOpts);
-            if (stale && this.settings.telemetry.usage && stale.tool_call_count > 0) {
-                appendOutboxSync([summaryFromState(stale)], this.outboxOpts);
+            const orphans = claimOrphanedSessionStates(this.outboxOpts, {
+                includeOwn: !this.sessionStatePersisted,
+            });
+            if (this.settings.telemetry.usage) {
+                const summaries = orphans.states.filter((s) => s.tool_call_count > 0).map(summaryFromState);
+                this.droppedOutbox += appendOutboxSync(summaries, this.outboxOpts);
             }
-            clearSessionState(this.outboxOpts);
-            const { events: pending, discarded } = readOutboxWithDiscards(this.outboxOpts);
+            orphans.release();
+            const claimed = claimOutboxForDrain(this.outboxOpts);
+            const { events: pending, discarded } = claimed;
             this.droppedOutbox += discarded;
             if (pending.length === 0) {
-                clearOutbox(this.outboxOpts);
+                claimed.release([]);
                 return;
             }
             if (!this.settings.telemetry.usage) {
-                clearOutbox(this.outboxOpts);
+                claimed.release([]);
                 return;
             }
             const sendable = pending.filter(isContentSafe);
@@ -330,12 +342,7 @@ export class TelemetryClient {
                 }
                 settled = i + batch.length;
             }
-            if (settled >= sendable.length) {
-                clearOutbox(this.outboxOpts);
-            }
-            else {
-                rewriteOutbox(sendable.slice(settled), this.outboxOpts);
-            }
+            this.droppedOutbox += claimed.release(sendable.slice(settled));
         }
         catch (err) {
             this.logger.debug(`startup outbox flush error: ${errMsg(err)}`);

package/dist/telemetry/outbox.js

@@ -1,21 +1,86 @@
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, appendFileSync, statSync, rmSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, renameSync, appendFileSync, statSync, rmSync, } from 'node:fs';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('TelemetryOutbox');
 const DIRNAME = '.editmamei';
 const OUTBOX_FILENAME = 'telemetry-outbox.ndjson';
-const SESSION_STATE_FILENAME = 'telemetry-session.json';
+const LEGACY_SESSION_STATE_FILENAME = 'telemetry-session.json';
+const SESSION_STATE_RE = /^telemetry-session\.(\d+)\.json$/;
+const RECOVER_RE = /^\.session-recover\.(\d+)\.(telemetry-session(?:\.\d+)?\.json)$/;
+const CLAIM_RE = /^telemetry-outbox\.(?:draining|compacting)\.(\d+)\.(\d+)\.ndjson$/;
 export const MAX_OUTBOX_EVENTS = 5_000;
 export const MAX_OUTBOX_BYTES = 2_000_000;
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
 function baseDir(opts) {
     return opts.dir ?? join(homedir(), DIRNAME);
 }
 export function outboxPath(opts = {}) {
     return join(baseDir(opts), OUTBOX_FILENAME);
 }
+function ownPid(opts) {
+    return opts.pid ?? process.pid;
+}
 export function sessionStatePath(opts = {}) {
-    return join(baseDir(opts), SESSION_STATE_FILENAME);
+    return join(baseDir(opts), `telemetry-session.${ownPid(opts)}.json`);
+}
+function listDir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function claim(from, to) {
+    try {
+        renameSync(from, to);
+        return to;
+    }
+    catch {
+        return null;
+    }
+}
+function freeClaimName(dir, kind, pid) {
+    for (let seq = 0;; seq++) {
+        const path = join(dir, `telemetry-outbox.${kind}.${pid}.${seq}.ndjson`);
+        if (!existsSync(path))
+            return path;
+    }
+}
+function readClaim(path) {
+    const buf = readFileSync(path);
+    const bytes = buf.lastIndexOf(0x0a) + 1;
+    return { ...parseOutbox(buf.subarray(0, bytes).toString('utf8')), bytes };
+}
+function readClaimTail(path, bytes) {
+    const buf = readFileSync(path);
+    if (buf.length <= bytes)
+        return { events: [], discarded: 0 };
+    return parseOutbox(buf.subarray(bytes).toString('utf8'));
+}
+function removeClaim(path, what) {
+    try {
+        rmSync(path, { force: true });
+        return;
+    }
+    catch (err) {
+        logger.debug(`${what} delete failed: ${errMsg(err)}`);
+    }
+    try {
+        writeFileSync(path, '');
+    }
+    catch (err) {
+        logger.debug(`${what} truncate failed: ${errMsg(err)}`);
+    }
 }
 function ensureDir(path) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
@@ -44,31 +109,100 @@ export function readOutboxWithDiscards(opts = {}) {
     if (!existsSync(path))
         return { events: [], discarded: 0 };
     try {
-        const raw = readFileSync(path, 'utf8');
-        const events = [];
-        let discarded = 0;
-        for (const line of raw.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                continue;
-            try {
-                events.push(JSON.parse(trimmed));
-            }
-            catch {
-                discarded += 1;
-            }
-        }
-        if (events.length > MAX_OUTBOX_EVENTS) {
-            const over = events.length - MAX_OUTBOX_EVENTS;
-            return { events: events.slice(over), discarded: discarded + over };
-        }
-        return { events, discarded };
+        return boundOutbox(parseOutbox(readFileSync(path, 'utf8')));
     }
     catch (err) {
         logger.debug(`outbox read failed: ${errMsg(err)}`);
         return { events: [], discarded: 0 };
     }
 }
+function parseOutbox(raw) {
+    const events = [];
+    let discarded = 0;
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            discarded += 1;
+        }
+    }
+    return { events, discarded };
+}
+function boundOutbox({ events, discarded }) {
+    if (events.length <= MAX_OUTBOX_EVENTS)
+        return { events, discarded };
+    const over = events.length - MAX_OUTBOX_EVENTS;
+    return { events: events.slice(over), discarded: discarded + over };
+}
+export function claimOutboxForDrain(opts = {}) {
+    const dir = baseDir(opts);
+    const me = ownPid(opts);
+    const alive = opts.isPidAlive ?? isPidAlive;
+    const claimed = [];
+    const nextName = () => freeClaimName(dir, 'draining', me);
+    const abandoned = listDir(dir)
+        .flatMap((name) => {
+        const m = CLAIM_RE.exec(name);
+        return m ? [{ name, pid: Number(m[1]), seq: Number(m[2]) }] : [];
+    })
+        .filter((c) => c.pid === me || !alive(c.pid))
+        .sort((a, b) => a.pid - b.pid || a.seq - b.seq || a.name.localeCompare(b.name));
+    for (const c of abandoned) {
+        const from = join(dir, c.name);
+        const got = c.pid === me ? from : claim(from, nextName());
+        if (got)
+            claimed.push(got);
+    }
+    const live = claim(outboxPath(opts), nextName());
+    if (live)
+        claimed.push(live);
+    const consumed = [];
+    let read = { events: [], discarded: 0 };
+    for (const path of claimed) {
+        try {
+            const part = readClaim(path);
+            read = {
+                events: read.events.concat(part.events),
+                discarded: read.discarded + part.discarded,
+            };
+            consumed.push({ path, bytes: part.bytes });
+        }
+        catch (err) {
+            logger.debug(`claimed outbox read failed: ${errMsg(err)}`);
+        }
+    }
+    const { events, discarded } = boundOutbox(read);
+    let released = false;
+    return {
+        events,
+        discarded,
+        release(undelivered) {
+            if (released)
+                return 0;
+            released = true;
+            const late = [];
+            let lost = 0;
+            for (const { path, bytes } of consumed) {
+                try {
+                    const tail = readClaimTail(path, bytes);
+                    late.push(...tail.events);
+                    lost += tail.discarded;
+                }
+                catch (err) {
+                    logger.debug(`claimed outbox re-read failed: ${errMsg(err)}`);
+                }
+            }
+            lost += appendOutboxSync(undelivered.concat(late), opts);
+            for (const { path } of consumed)
+                removeClaim(path, 'claimed outbox');
+            return lost;
+        },
+    };
+}
 export function readOutbox(opts = {}) {
     return readOutboxWithDiscards(opts).events;
 }
@@ -88,7 +222,7 @@ export function rewriteOutbox(events, opts = {}) {
     const path = outboxPath(opts);
     try {
         ensureDir(path);
-        const tmp = join(dirname(path), `.outbox.${process.pid}.tmp`);
+        const tmp = join(dirname(path), `.outbox.${ownPid(opts)}.tmp`);
         writeFileSync(tmp, events.map((e) => JSON.stringify(e)).join('\n') + '\n', {
             encoding: 'utf8',
             mode: 0o600,
@@ -100,7 +234,18 @@ export function rewriteOutbox(events, opts = {}) {
     }
 }
 function compactOutbox(opts = {}) {
-    const { events, discarded } = readOutboxWithDiscards(opts);
+    const path = claim(outboxPath(opts), freeClaimName(baseDir(opts), 'compacting', ownPid(opts)));
+    if (!path)
+        return 0;
+    let read;
+    try {
+        read = readClaim(path);
+    }
+    catch (err) {
+        logger.debug(`compaction read failed, leaving the claim for recovery: ${errMsg(err)}`);
+        return 0;
+    }
+    const { events, discarded } = boundOutbox(read);
     const target = MAX_OUTBOX_BYTES / 2;
     let bytes = 0;
     let firstKept = Math.max(events.length - 1, 0);
@@ -111,14 +256,34 @@ function compactOutbox(opts = {}) {
         firstKept = i;
     }
     const kept = events.slice(firstKept);
-    rewriteOutbox(kept, opts);
-    return discarded + (events.length - kept.length);
+    let late = { events: [], discarded: 0 };
+    try {
+        late = readClaimTail(path, read.bytes);
+    }
+    catch (err) {
+        logger.debug(`compaction re-read failed: ${errMsg(err)}`);
+    }
+    const back = kept.concat(late.events);
+    if (back.length > 0) {
+        try {
+            appendFileSync(outboxPath(opts), back.map((e) => JSON.stringify(e)).join('\n') + '\n', {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+        }
+        catch (err) {
+            logger.debug(`compaction write-back failed, leaving the claim for recovery: ${errMsg(err)}`);
+            return 0;
+        }
+    }
+    removeClaim(path, 'compaction claim');
+    return discarded + (events.length - kept.length) + late.discarded;
 }
 export function writeSessionStateSync(state, opts = {}) {
     const path = sessionStatePath(opts);
     try {
         ensureDir(path);
-        const tmp = join(dirname(path), `.session.${process.pid}.tmp`);
+        const tmp = join(dirname(path), `.session.${ownPid(opts)}.tmp`);
         writeFileSync(tmp, JSON.stringify(state), { encoding: 'utf8', mode: 0o600 });
         renameSync(tmp, path);
     }
@@ -127,7 +292,62 @@ export function writeSessionStateSync(state, opts = {}) {
     }
 }
 export function readSessionState(opts = {}) {
-    const path = sessionStatePath(opts);
+    return readSessionStateAt(sessionStatePath(opts));
+}
+export function claimOrphanedSessionStates(opts = {}, { includeOwn }) {
+    const dir = baseDir(opts);
+    const me = ownPid(opts);
+    const alive = opts.isPidAlive ?? isPidAlive;
+    const takeable = (pid) => (pid === me ? includeOwn : !alive(pid));
+    const claimed = [];
+    for (const name of listDir(dir)) {
+        let original;
+        const r = RECOVER_RE.exec(name);
+        if (r) {
+            const pid = Number(r[1]);
+            if (!takeable(pid))
+                continue;
+            if (pid === me) {
+                claimed.push(join(dir, name));
+                continue;
+            }
+            original = r[2];
+        }
+        else if (name === LEGACY_SESSION_STATE_FILENAME) {
+            original = name;
+        }
+        else {
+            const m = SESSION_STATE_RE.exec(name);
+            if (!m || !takeable(Number(m[1])))
+                continue;
+            original = name;
+        }
+        const target = join(dir, `.session-recover.${me}.${original}`);
+        if (existsSync(target))
+            continue;
+        const got = claim(join(dir, name), target);
+        if (got)
+            claimed.push(got);
+    }
+    const states = [];
+    for (const path of claimed) {
+        const state = readSessionStateAt(path);
+        if (state)
+            states.push(state);
+    }
+    let released = false;
+    return {
+        states,
+        release() {
+            if (released)
+                return;
+            released = true;
+            for (const path of claimed)
+                removeClaim(path, 'session-state recover');
+        },
+    };
+}
+function readSessionStateAt(path) {
     if (!existsSync(path))
         return null;
     try {

package/dist/telemetry/sanitize.js

@@ -23,8 +23,22 @@ function homedirPrefixes() {
     return [...set];
 }
 const SINGLE_SEG_POSIX = /(^|\s)\/[^\s"'/]+(?=$|\s)/;
+const WORD = String.raw `[^\s"'\\/:]+`;
+const DIR = String.raw `${WORD}(?: ${WORD})*`;
+const TILDE_WORD = String.raw `[^\s"'\\/]+`;
+const TILDE_DIR = String.raw `${TILDE_WORD}(?: ${TILDE_WORD})*`;
+const POSIX_WORD = String.raw `[^\s"'/]+`;
+const POSIX_DIR = String.raw `${POSIX_WORD}(?: ${POSIX_WORD})*`;
+const PATH_TOKEN = new RegExp([
+    String.raw `[A-Za-z]:[\\/](?:${DIR}[\\/])*[^\s"']*`,
+    String.raw `\\\\(?:${DIR}[\\/])*[^\s"']+`,
+    String.raw `file:\/\/[^\s"']*`,
+    String.raw `(?<![\w~])~(?:[\\/]${TILDE_DIR}(?=[\\/]))*[\\/]${TILDE_WORD}[\\/]?`,
+    String.raw `\/${POSIX_WORD}(?:\/${POSIX_DIR}(?=\/))*\/${POSIX_WORD}\/?`,
+    String.raw `(?:^|\s)\/[^\s"'/]+(?=$|\s)`,
+].join('|'), 'gi');
 function basenamePaths(s) {
-    return s.replace(/[A-Za-z]:[\\/][^\s"']*|\\\\[^\s"']+|file:\/\/[^\s"']*|(?:\/[^\s"'/]+){2,}\/?|(?:^|\s)\/[^\s"'/]+(?=$|\s)/gi, (m) => {
+    return s.replace(PATH_TOKEN, (m) => {
         const single = SINGLE_SEG_POSIX.exec(m);
         if (single)
             return `${single[1]}/…`;