maka-agent 0.2.0-dev.53.20260927 → 0.2.0-dev.62.20260928

package/LICENSE

@@ -469,17 +469,18 @@ THE SOFTWARE.
 
 electron-builder dependency patches
 
-Source: https://www.npmjs.com/package/app-builder-lib/v/26.15.3
+Source: https://www.npmjs.com/package/app-builder-lib/v/26.16.1
         https://www.npmjs.com/package/electron-updater/v/6.8.9
 Repository: https://github.com/electron-userland/electron-builder
-Versions: app-builder-lib 26.15.3; electron-updater 6.8.9
-Dependency patch: patches/app-builder-lib+26.15.3.patch
+Versions: app-builder-lib 26.16.1; electron-updater 6.8.9
+Dependency patch: patches/app-builder-lib+26.16.1.patch
                   patches/electron-updater+6.8.9.patch
 License: MIT
 
 Maka redistributes source patches that omit modification and access times
-from ZIP archives and skip withdrawn prereleases whose update metadata is
-missing. The following MIT License applies to that material:
+from 7-Zip ZIP archives, keep macOS ZIP archives on the system zip, and skip
+withdrawn prereleases whose update metadata is missing. The following MIT
+License applies to that material:
 
 The MIT License (MIT)
 

package/dist/workspace-root.js

@@ -16,6 +16,6 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-// Workspace-root resolution now lives in @maka/storage. This file remains
-// as a re-export so existing relative CLI importers keep working.
+// Keep the CLI compatibility path while storage owns workspace-root resolution.
+// New callers should import the storage subpath directly.
 export { deriveMakaDataRoots, resolveMakaClientDataRoot, resolveMakaDataRoots, resolveMakaWorkspaceRoot, } from '@maka/storage/workspace-root';

package/node_modules/@maka/acp-executor-plugin/dist/index.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
+import { constants, createReadStream } from 'node:fs';
 import { access, mkdtemp, rm, realpath, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, isAbsolute, resolve } from 'node:path';
@@ -89,22 +89,56 @@ export class AcpExecutor {
         const session = this.#sessions.get(input.conversationKey);
         if (this.#disposed)
             return this.#catalogEntry('unavailable');
-        if (session?.lost || (!session && (await this.#state?.has(input.conversationKey, input.cwd))))
-            return this.#catalogEntry('history_only');
-        return this.#catalogEntry('ready', session?.configOptions ?? [], input.configuration?.model);
+        if (session && session.cwd !== resolve(input.cwd))
+            return this.#catalogEntry('history_only', [], input.configuration?.model);
+        if (session?.restoring)
+            return this.#catalogEntry('restoring', session.configOptions, input.configuration?.model);
+        if (session?.restoreFailed)
+            return this.#catalogEntry('restore_failed', session.configOptions, input.configuration?.model);
+        if (session?.historyGap)
+            return this.#catalogEntry('history_gap', session.configOptions, input.configuration?.model);
+        if (session && !session.lost)
+            return this.#catalogEntry('ready', session.configOptions, input.configuration?.model);
+        if (session?.lost && !session.record)
+            return this.#catalogEntry('history_only', session.configOptions, input.configuration?.model);
+        const stored = this.#state?.read
+            ? decodeContinuity(await this.#state.read(input.conversationKey))
+            : (await this.#state?.has(input.conversationKey, input.cwd))
+                ? 'legacy'
+                : undefined;
+        if (!stored)
+            return this.#catalogEntry('ready', [], input.configuration?.model);
+        if (stored === 'invalid' || stored === 'legacy' || stored.cwd !== resolve(input.cwd))
+            return this.#catalogEntry('history_only', [], input.configuration?.model);
+        if (stored.phase === 'reserved')
+            return this.#catalogEntry('history_only', [], input.configuration?.model);
+        return this.#catalogEntry(stored.phase === 'prompt_pending' || stored.phase === 'history_gap'
+            ? 'history_gap'
+            : 'restorable', [], input.configuration?.model ?? stored.confirmedModel);
     }
     async configureConversation(input, signal) {
-        const session = this.#sessions.get(input.conversationKey);
-        if (!session?.connection ||
-            session.lost ||
-            session.active ||
-            session.configuring ||
-            !input.configuration?.model)
+        if (!input.configuration?.model)
+            throw new Error('ACP model change is unavailable');
+        const session = await this.#session(input);
+        if (session.active || session.configuring)
             throw new Error('ACP model change is unavailable');
         session.configuring = true;
+        const wasConnected = !!session.connection;
         try {
+            await this.#ensureInitialized(session, signal);
             await this.#applyInitialConfig(session, { model: input.configuration.model }, signal, true);
         }
+        catch (error) {
+            if (!wasConnected || session.lost) {
+                await this.#lose(session);
+                if (session.record?.sessionId && !session.historyGap)
+                    session.restoreFailed = true;
+                const retryable = !session.acpSessionId && !session.continuityReserved && !session.record;
+                if (retryable && this.#sessions.get(session.conversationKey) === session)
+                    this.#sessions.delete(session.conversationKey);
+            }
+            throw error;
+        }
         finally {
             session.configuring = false;
         }
@@ -115,12 +149,17 @@ export class AcpExecutor {
             ? model.options
                 .flatMap((entry) => ('options' in entry ? entry.options : [entry]))
                 .map((entry) => ({ id: entry.value, name: entry.name }))
-            : [];
+            : (this.#catalog?.models ?? []);
         return {
             id: this.id,
             displayName: this.displayName,
             readiness,
-            ...(this.#adapter.describeModels?.(models) ?? { models }),
+            ...(model?.type === 'select'
+                ? (this.#adapter.describeModels?.(models) ?? { models })
+                : {
+                    models,
+                    ...(this.#catalog?.modelGroups ? { modelGroups: this.#catalog.modelGroups } : {}),
+                }),
             ...(model?.type === 'select'
                 ? { currentModel: model.currentValue }
                 : selected
@@ -146,12 +185,12 @@ export class AcpExecutor {
             request = { ...request, configuration: { model } };
         let session;
         try {
-            session = this.#session(request);
+            session = await this.#session(request);
         }
         catch (error) {
             return failure(safeErrorMessage(error), errorCode(error));
         }
-        if (session.active || session.configuring)
+        if (session.active || session.configuring || session.awaitingAck)
             return failure(`${this.displayName} ACP Session is busy`, 'acp_busy', true);
         const active = { context, tools: new Map(), text: '' };
         session.active = active;
@@ -160,6 +199,7 @@ export class AcpExecutor {
             context.signal.throwIfAborted();
             if (request.configuration?.model)
                 await this.#applyInitialConfig(session, { model: request.configuration.model }, context.signal);
+            await this.#beginPrompt(session, request.turnId);
             const prompt = session.connection.agent.request(methods.agent.session.prompt, {
                 sessionId: session.acpSessionId,
                 prompt: [{ type: 'text', text: promptText(request) }],
@@ -167,6 +207,11 @@ export class AcpExecutor {
             const response = await this.#awaitPrompt(session, prompt, context.signal);
             if (!response)
                 return { status: 'cancelled', reason: 'timeout' };
+            // A settled prompt can be checkpointed even when it was cancelled or failed.
+            // Timeouts and transport failures never reach this point, and the Runtime
+            // must still durably consume the terminal event before acknowledging it.
+            if (session.record)
+                session.awaitingAck = request.turnId;
             if (context.signal.aborted || response.stopReason === 'cancelled') {
                 return { status: 'cancelled', providerStopReason: response.stopReason };
             }
@@ -179,12 +224,17 @@ export class AcpExecutor {
             return { status: 'completed', text: active.text };
         }
         catch (error) {
+            if (errorCode(error) === 'acp_history_gap')
+                session.historyGap = true;
             await this.#lose(session);
+            if (session.record?.sessionId && !session.historyGap)
+                session.restoreFailed = true;
             // Retry only when no session/new was attempted. Once continuity is
             // reserved, a lost response may hide an established Agent Session.
             const retryable = !session.acpSessionId &&
                 !session.continuityReserved &&
-                errorCode(error) !== 'acp_history_only';
+                errorCode(error) !== 'acp_history_only' &&
+                errorCode(error) !== 'acp_history_gap';
             if (retryable && this.#sessions.get(session.conversationKey) === session)
                 this.#sessions.delete(session.conversationKey);
             if (context.signal.aborted) {
@@ -216,15 +266,22 @@ export class AcpExecutor {
         if (failures.length)
             throw new AggregateError(failures, 'ACP process cleanup failed');
     }
-    #session(request) {
+    async #session(request) {
         const cwd = resolve(request.cwd);
         const existing = this.#sessions.get(request.conversationKey);
         if (existing) {
             if (existing.cwd !== cwd)
                 throw new AcpRuntimeError('ACP conversation cannot change workspace', 'acp_cwd_changed');
-            if (existing.lost)
+            if (!existing.lost)
+                return existing;
+            if (existing.active || existing.configuring)
+                throw new AcpRuntimeError('ACP Session is busy', 'acp_busy');
+            if (!existing.record)
                 throw new AcpRuntimeError('ACP conversation is history-only because its external process was lost', 'acp_history_only');
-            return existing;
+            await existing.loss;
+            if (this.#sessions.get(request.conversationKey) !== existing)
+                return this.#session(request);
+            this.#sessions.delete(request.conversationKey);
         }
         const created = {
             conversationKey: request.conversationKey,
@@ -246,17 +303,41 @@ export class AcpExecutor {
         }
         catch (error) {
             session.initialization = undefined;
+            session.restoring = false;
+            session.replay = undefined;
             throw error;
         }
     }
     async #initialize(session, signal, probe = false) {
-        if (!probe && (await this.#state?.has(session.conversationKey, session.cwd))) {
-            throw new AcpRuntimeError('ACP conversation is history-only after the Plugin or Host was restarted', 'acp_history_only');
-        }
         const timeout = AbortSignal.timeout(INITIALIZE_TIMEOUT_MS);
         const startupSignal = AbortSignal.any([signal, timeout]);
         startupSignal.throwIfAborted();
         const launch = this.#configured.launch;
+        const stored = probe
+            ? undefined
+            : this.#state?.read
+                ? decodeContinuity(await this.#state.read(session.conversationKey))
+                : (await this.#state?.has(session.conversationKey, session.cwd))
+                    ? 'legacy'
+                    : undefined;
+        if (stored === 'legacy')
+            throw new AcpRuntimeError('ACP conversation is history-only after the Plugin or Host was restarted', 'acp_history_only');
+        if (stored === 'invalid' ||
+            (stored && stored.cwd !== session.cwd) ||
+            stored?.phase === 'reserved')
+            throw new AcpRuntimeError('ACP conversation has no recoverable external Session identity', 'acp_history_only');
+        if (stored?.phase === 'history_gap')
+            throw new AcpRuntimeError('External Session history cannot be aligned with saved conversation events', 'acp_history_gap');
+        if (stored) {
+            session.record = stored;
+            session.acpSessionId = stored.sessionId;
+            session.restoring = true;
+        }
+        const binding = !probe && this.#state?.write
+            ? await launchBinding(this.id, launch, startupSignal)
+            : undefined;
+        if (stored && stored.binding !== binding)
+            throw new AcpRuntimeError('ACP Agent installation changed', 'acp_restore_identity_changed');
         const executable = await checkedExecutable(launch.executable);
         await Promise.all((launch.requiredExecutables ?? []).map(checkedExecutable));
         const owner = this.#createConnection({
@@ -283,11 +364,62 @@ export class AcpExecutor {
         ]);
         if (initialized.protocolVersion !== 1)
             throw new Error('Unsupported ACP protocol version');
+        if (stored) {
+            session.replay = { updates: 0, userChunks: 0 };
+            const pending = stored.phase === 'prompt_pending';
+            const supported = pending
+                ? initialized.agentCapabilities?.loadSession
+                : initialized.agentCapabilities?.sessionCapabilities?.resume;
+            if (!supported)
+                throw new AcpRuntimeError('ACP Agent cannot restore this Session', 'acp_restore_unsupported');
+            const restored = await Promise.race([
+                owner.connection.agent.request(pending ? methods.agent.session.load : methods.agent.session.resume, { sessionId: stored.sessionId, cwd: session.cwd, mcpServers: [] }, { cancellationSignal: startupSignal }),
+                owner.failed,
+            ]);
+            session.configOptions = restored.configOptions ?? [];
+            const restoredModel = currentAcpModel(session.configOptions);
+            if (restoredModel)
+                await this.#persistConfirmedModel(session, restoredModel);
+            session.restoring = false;
+            if (pending) {
+                // The Agent may have progressed beyond Maka's last durable event. Replay
+                // identities are not sufficient to fabricate canonical history: failed
+                // turns can change tool IDs between live output and load. Keep every
+                // replay notification separate and expose an explicit history gap.
+                session.historyGap = true;
+                session.record = {
+                    ...session.record,
+                    phase: 'history_gap',
+                    pendingTurnId: undefined,
+                    gapEvidence: {
+                        replayedUpdates: session.replay?.updates ?? 0,
+                        replayedUserChunks: session.replay?.userChunks ?? 0,
+                    },
+                };
+                await this.#state?.write?.(session.conversationKey, session.record);
+                session.replay = undefined;
+                throw new AcpRuntimeError('External Session was restored, but conversation history may have a gap', 'acp_history_gap');
+            }
+            session.replay = undefined;
+            return;
+        }
         if (!probe) {
             startupSignal.throwIfAborted();
             // Reserve continuity before asking the Agent to create a Session. A failed
             // or interrupted session/new may still have created one remotely.
-            await this.#state?.mark(session.conversationKey, session.cwd);
+            if (this.#state?.write && binding) {
+                session.record = {
+                    version: 2,
+                    cwd: session.cwd,
+                    binding,
+                    phase: 'reserved',
+                    committedPrompts: 0,
+                };
+                await this.#state.write(session.conversationKey, session.record);
+            }
+            else {
+                await this.#state?.mark(session.conversationKey, session.cwd);
+            }
             session.continuityReserved = true;
         }
         const created = await Promise.race([
@@ -296,12 +428,82 @@ export class AcpExecutor {
         ]);
         session.acpSessionId = created.sessionId;
         session.configOptions = created.configOptions ?? [];
+        if (session.record) {
+            const established = {
+                ...session.record,
+                phase: 'established',
+                sessionId: created.sessionId,
+            };
+            await this.#state?.write?.(session.conversationKey, established);
+            session.record = established;
+            const createdModel = currentAcpModel(session.configOptions);
+            if (createdModel)
+                await this.#persistConfirmedModel(session, createdModel);
+        }
         if (!probe) {
             await this.#applyInitialConfig(session, session.configuration?.model
                 ? { model: session.configuration.model }
                 : (launch.initialConfig ?? {}), startupSignal);
         }
     }
+    async #beginPrompt(session, turnId) {
+        if (!session.record)
+            return;
+        const pending = {
+            ...session.record,
+            phase: 'prompt_pending',
+            pendingTurnId: turnId,
+        };
+        await this.#state?.write?.(session.conversationKey, pending);
+        session.record = pending;
+    }
+    /** Called only after the Runtime Kernel has durably accepted the terminal event. */
+    async acknowledgeExecution(conversationKey, turnId) {
+        const session = this.#sessions.get(conversationKey);
+        if (!session?.record ||
+            session.awaitingAck !== turnId ||
+            session.record.phase !== 'prompt_pending' ||
+            session.record.pendingTurnId !== turnId)
+            return;
+        const committed = {
+            ...session.record,
+            phase: 'committed',
+            committedPrompts: session.record.committedPrompts + 1,
+            pendingTurnId: undefined,
+        };
+        try {
+            await this.#state?.write?.(conversationKey, committed);
+        }
+        catch (error) {
+            session.historyGap = true;
+            await this.#lose(session);
+            throw error;
+        }
+        session.record = committed;
+        session.awaitingAck = undefined;
+    }
+    /** The external turn settled, but Maka did not durably consume its terminal event. */
+    async abandonExecution(conversationKey, turnId) {
+        const session = this.#sessions.get(conversationKey);
+        if (!session?.record ||
+            session.awaitingAck !== turnId ||
+            session.record.phase !== 'prompt_pending' ||
+            session.record.pendingTurnId !== turnId)
+            return;
+        session.historyGap = true;
+        session.awaitingAck = undefined;
+        session.record = {
+            ...session.record,
+            phase: 'history_gap',
+            pendingTurnId: undefined,
+        };
+        try {
+            await this.#state?.write?.(conversationKey, session.record);
+        }
+        finally {
+            await this.#lose(session);
+        }
+    }
     async #applyInitialConfig(session, values, signal, restoreOnFailure = false) {
         for (const [key, value] of Object.entries(values)) {
             const option = session.configOptions.find((candidate) => candidate.type === 'select' && (candidate.id === key || candidate.category === key));
@@ -310,8 +512,11 @@ export class AcpExecutor {
             const options = option.options.flatMap((entry) => 'options' in entry ? entry.options : [entry]);
             if (!options.some((entry) => entry.value === value))
                 throw new AcpRuntimeError(`ACP configuration value is unavailable: ${key}`, 'acp_config_invalid');
-            if (option.currentValue === value)
+            if (option.currentValue === value) {
+                if (key === 'model')
+                    await this.#persistConfirmedModel(session, value);
                 continue;
+            }
             signal.throwIfAborted();
             try {
                 const updated = await session.connection.agent.request(methods.agent.session.setConfigOption, { sessionId: session.acpSessionId, configId: option.id, value }, { cancellationSignal: signal });
@@ -319,6 +524,8 @@ export class AcpExecutor {
                 if (confirmed?.type !== 'select' || confirmed.currentValue !== value)
                     throw new AcpRuntimeError('Agent did not confirm the selected configuration', 'acp_config_unconfirmed');
                 session.configOptions = updated.configOptions;
+                if (key === 'model')
+                    await this.#persistConfirmedModel(session, value);
             }
             catch (error) {
                 // A rejected/unconfirmed mutation can have reached the Agent. Restore the
@@ -332,6 +539,8 @@ export class AcpExecutor {
                             confirmed.currentValue === option.currentValue &&
                             !session.lost) {
                             session.configOptions = rollback.configOptions;
+                            if (key === 'model')
+                                await this.#persistConfirmedModel(session, option.currentValue);
                             restored = true;
                         }
                     }
@@ -345,6 +554,13 @@ export class AcpExecutor {
             }
         }
     }
+    async #persistConfirmedModel(session, model) {
+        if (!session.record || session.record.confirmedModel === model)
+            return;
+        const record = { ...session.record, confirmedModel: model };
+        await this.#state?.write?.(session.conversationKey, record);
+        session.record = record;
+    }
     #configureClient(session, app) {
         app
             .onNotification(methods.client.session.update, ({ params }) => {
@@ -352,13 +568,13 @@ export class AcpExecutor {
                 this.#acceptUpdate(session, params.update);
         })
             .onRequest(methods.client.fs.readTextFile, async ({ params }) => {
-            this.#assertSession(session, params.sessionId);
+            this.#assertWorkspaceAccess(session, params.sessionId);
             return {
                 content: await readWorkspaceTextFile(session.cwd, params.path, params.line, params.limit),
             };
         })
             .onRequest(methods.client.fs.writeTextFile, async ({ params }) => {
-            this.#assertSession(session, params.sessionId);
+            this.#assertWorkspaceAccess(session, params.sessionId);
             await writeWorkspaceTextFile(session.cwd, params.path, params.content);
             return {};
         })
@@ -366,6 +582,8 @@ export class AcpExecutor {
     }
     async #requestPermission(session, request) {
         this.#assertSession(session, request.sessionId);
+        if (session.restoring || session.historyGap || session.lost)
+            return { outcome: { outcome: 'cancelled' } };
         const active = session.active;
         if (!active)
             return { outcome: { outcome: 'cancelled' } };
@@ -378,6 +596,16 @@ export class AcpExecutor {
         return { outcome };
     }
     #acceptUpdate(session, update) {
+        if (session.restoring) {
+            if (session.replay) {
+                session.replay.updates++;
+                if (update.sessionUpdate === 'user_message_chunk')
+                    session.replay.userChunks++;
+            }
+            return;
+        }
+        if (session.historyGap || session.lost)
+            return;
         if (update.sessionUpdate === 'config_option_update') {
             // During our mutation, its response (or rollback response) is authoritative.
             if (!session.configuring && !session.lost)
@@ -401,6 +629,12 @@ export class AcpExecutor {
         if (update.sessionUpdate === 'tool_call_update')
             this.#acceptTool(active, update);
     }
+    #assertWorkspaceAccess(session, sessionId) {
+        this.#assertSession(session, sessionId);
+        if (session.restoring || session.historyGap || session.lost) {
+            throw new AcpRuntimeError('ACP filesystem access is unavailable while Session history is untrusted', 'acp_history_gap');
+        }
+    }
     #acceptTool(active, update) {
         const snapshot = active.tools.get(update.toolCallId) ?? {
             id: update.toolCallId,
@@ -516,6 +750,10 @@ export class AcpExecutor {
             await owner.dispose();
     }
 }
+function currentAcpModel(options) {
+    const option = options.find((candidate) => candidate.type === 'select' && (candidate.id === 'model' || candidate.category === 'model'));
+    return option?.type === 'select' ? option.currentValue : undefined;
+}
 function toolTextContent(content) {
     return content
         .flatMap((item) => item.type === 'content' && item.content.type === 'text' ? [item.content.text] : [])
@@ -549,15 +787,82 @@ function pluginStateStore(storage, executorId) {
     const key = (conversationKey) => `acp/${executorId}/${createHash('sha256').update(conversationKey).digest('hex')}`;
     return {
         async has(conversationKey) {
-            const value = (await storage.get(key(conversationKey)))
-                .value;
-            return value?.version === 1;
+            return (await storage.get(key(conversationKey))).value !== undefined;
         },
         async mark(conversationKey, cwd) {
             await storage.set(key(conversationKey), { version: 1, cwd });
         },
+        async read(conversationKey) {
+            return (await storage.get(key(conversationKey))).value;
+        },
+        async write(conversationKey, state) {
+            await storage.set(key(conversationKey), state);
+        },
     };
 }
+function decodeContinuity(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return 'invalid';
+    const record = value;
+    if (record.version === 1)
+        return 'legacy';
+    if (record.version !== 2 ||
+        typeof record.cwd !== 'string' ||
+        !isAbsolute(record.cwd) ||
+        typeof record.binding !== 'string' ||
+        !/^sha256:[a-f0-9]{64}$/u.test(record.binding) ||
+        !Number.isSafeInteger(record.committedPrompts) ||
+        record.committedPrompts < 0 ||
+        !['reserved', 'established', 'prompt_pending', 'committed', 'history_gap'].includes(String(record.phase)) ||
+        (record.sessionId !== undefined &&
+            (typeof record.sessionId !== 'string' ||
+                !record.sessionId ||
+                record.sessionId.length > 4096)) ||
+        (record.pendingTurnId !== undefined &&
+            (typeof record.pendingTurnId !== 'string' || !record.pendingTurnId)) ||
+        (record.confirmedModel !== undefined &&
+            (typeof record.confirmedModel !== 'string' || !record.confirmedModel)) ||
+        (record.phase === 'reserved' && record.sessionId !== undefined) ||
+        (record.phase !== 'reserved' && !record.sessionId) ||
+        (record.phase === 'prompt_pending' && !record.pendingTurnId) ||
+        (record.phase !== 'prompt_pending' && record.pendingTurnId !== undefined) ||
+        (record.gapEvidence !== undefined &&
+            (record.phase !== 'history_gap' ||
+                !record.gapEvidence ||
+                typeof record.gapEvidence !== 'object' ||
+                !Number.isSafeInteger(record.gapEvidence.replayedUpdates) ||
+                !Number.isSafeInteger(record.gapEvidence.replayedUserChunks) ||
+                record.gapEvidence.replayedUpdates < 0 ||
+                record.gapEvidence.replayedUserChunks < 0)))
+        return 'invalid';
+    return record;
+}
+async function launchBinding(adapterId, launch, signal) {
+    const paths = [launch.executable, ...(launch.requiredExecutables ?? [])];
+    const files = [];
+    for (const path of paths) {
+        signal.throwIfAborted();
+        const resolved = await checkedExecutable(path);
+        const hash = createHash('sha256');
+        for await (const chunk of createReadStream(resolved)) {
+            signal.throwIfAborted();
+            hash.update(chunk);
+        }
+        files.push({ path: resolved, digest: hash.digest('hex') });
+    }
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify({
+        adapterId,
+        files,
+        args: launch.args ?? [],
+        cwd: launch.cwd ?? dirname(files[0].path),
+        platform: process.platform,
+        arch: process.arch,
+    }))
+        .digest('hex')}`;
+}
 function validateAdapter(adapter) {
     if (!adapter ||
         typeof adapter !== 'object' ||