editmamei 1.6.0 → 1.7.1

package/dist/backends/gimp/session.js

@@ -122,6 +122,9 @@ export class GimpSession {
     get lastStartOrigin() {
         return this.startOrigin;
     }
+    get generation() {
+        return this.deadGeneration;
+    }
     latestPreviewPath() {
         return join(this.rootDir, 'latest-preview.jpg');
     }

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/preview-privacy.js

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

package/dist/core/server.js

@@ -6,6 +6,7 @@ import { ToolRegistry } from './tool-registry.js';
 import { tierOf } from './tool-tiers.js';
 import { groupOf, GROUPS } from './tool-groups.js';
 import { CAMERA_RAW_TOOL, RAW_DEVELOP_TOOL } from './tool-activity.js';
+import { hasImageContent, withholdImages } from './preview-privacy.js';
 import { EDITION } from '../edition.js';
 import { VERSION } from '../version.js';
 import { Session } from './session.js';
@@ -90,6 +91,7 @@ export class EditmameiServer {
     updateInfo = null;
     updateCheck = null;
     updateNoticeShown = false;
+    previewsAllowed = () => loadSettings().settings.privacy.send_previews_to_llm;
     snippetClient = new GoSnippetClient();
     refreshLicenseOnPing = createPingLicenseRefresher();
     moduleUpdateFailed = false;
@@ -436,6 +438,8 @@ export class EditmameiServer {
             const result = await this.toolRegistry.execute(name, args);
             this.session.updateActivity();
             this.trackRawDevelopState(name, result);
+            if (hasImageContent(result) && !this.previewsAllowed())
+                return withholdImages(result);
             return result;
         }
         catch (error) {

package/dist/core/tool-activity.js

@@ -104,11 +104,19 @@ export const MUTATING_TOOLS = new Set([
     'gimp_open_document',
     'gimp_close_document',
     'gimp_add_adjustment',
+    'gimp_add_effect',
     'gimp_filter',
     'gimp_crop_document',
     'gimp_resize_image',
     'gimp_transform_canvas',
     'gimp_create_mask',
+    'gimp_checkpoint',
+    'gimp_layer',
+    'gimp_bake',
+    'gimp_create_document',
+    'gimp_place_image',
+    'gimp_canvas',
+    'gimp_convert_image_mode',
 ]);
 export const RAW_DEVELOP_TOOL = 'ps_develop_raw';
 export const CAMERA_RAW_TOOL = 'ps_apply_camera_raw';

package/dist/core/tool-groups.js

@@ -186,7 +186,15 @@ export const TOOL_GROUPS = {
     gimp_transform_canvas: 'document',
     gimp_add_adjustment: 'adjust',
     gimp_filter: 'filter',
+    gimp_add_effect: 'filter',
     gimp_create_mask: 'masks',
+    gimp_checkpoint: 'document',
+    gimp_layer: 'layers',
+    gimp_bake: 'layers',
+    gimp_create_document: 'document',
+    gimp_place_image: 'layers',
+    gimp_canvas: 'document',
+    gimp_convert_image_mode: 'document',
 };
 export function groupOf(toolName) {
     const group = TOOL_GROUPS[toolName];

package/dist/core/tool-tiers.js

@@ -98,6 +98,7 @@ export const TOOL_TIERS = {
     gimp_inspect: 'community',
     gimp_add_adjustment: 'community',
     gimp_filter: 'community',
+    gimp_add_effect: 'community',
     gimp_crop_document: 'community',
     gimp_resize_image: 'community',
     gimp_transform_canvas: 'community',
@@ -105,6 +106,13 @@ export const TOOL_TIERS = {
     gimp_get_preview: 'community',
     gimp_get_histogram: 'community',
     gimp_compare: 'community',
+    gimp_checkpoint: 'community',
+    gimp_layer: 'community',
+    gimp_bake: 'community',
+    gimp_create_document: 'community',
+    gimp_place_image: 'community',
+    gimp_canvas: 'community',
+    gimp_convert_image_mode: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/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

@@ -5,19 +5,27 @@ import { createGimpCoreTools } from '../../tools/gimp-core-tools.js';
 import { createGimpDocumentTools } from '../../tools/gimp-document-tools.js';
 import { createGimpInspectTools } from '../../tools/gimp-inspect-tools.js';
 import { createGimpAdjustmentTools } from '../../tools/gimp-adjustment-tools.js';
+import { createGimpEffectTools } from '../../tools/gimp-effect-tools.js';
 import { createGimpFilterTools } from '../../tools/gimp-filter-tools.js';
 import { createGimpGeometryTools } from '../../tools/gimp-geometry-tools.js';
 import { createGimpMaskTools } from '../../tools/gimp-mask-tools.js';
 import { createGimpVerifyTools } from '../../tools/gimp-verify-tools.js';
+import { createGimpCheckpointTools } from '../../tools/gimp-checkpoint-tools.js';
+import { createGimpLayerTools } from '../../tools/gimp-layer-tools.js';
+import { createGimpComposeTools } from '../../tools/gimp-compose-tools.js';
 export const gimpFactories = [
     createGimpCoreTools,
     createGimpDocumentTools,
     createGimpInspectTools,
     createGimpAdjustmentTools,
+    createGimpEffectTools,
     createGimpFilterTools,
     createGimpGeometryTools,
     createGimpMaskTools,
     createGimpVerifyTools,
+    createGimpCheckpointTools,
+    createGimpLayerTools,
+    createGimpComposeTools,
 ];
 export const gimpModule = {
     manifest: { id: 'gimp', name: 'Editmamei GIMP Tools', abi: KERNEL_ABI },

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 {