maka-agent 0.2.0-dev.47.20260922 → 0.2.0-dev.49.20260924

package/dist/acp/session-event-mapper.js

@@ -142,10 +142,7 @@ export class AcpSessionEventMapper {
     }
 }
 function deltaText(event, current = '') {
-    return foldRuntimeHostAssistantDelta(current, {
-        startOffset: event.startOffset ?? current.length,
-        text: event.text,
-    }).text;
+    return foldRuntimeHostAssistantDelta(current, event).text;
 }
 function streamKey(kind, messageId) {
     return `${kind}:${messageId}`;

package/dist/onboarding-catalog.js

@@ -16,9 +16,9 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { CATALOG_PROVIDER_TYPES, PROVIDER_REGISTRY, providerAuthSupportsApiKey, } from '@maka/core/llm-connections';
+import { CATALOG_PROVIDER_TYPES, MODEL_API_PROTOCOL_LABELS, MODEL_API_PROTOCOLS, PROVIDER_REGISTRY, providerAuthSupportsApiKey, } from '@maka/core/llm-connections';
 export function listApiKeyOnboardableProviders() {
-    // Custom relays have no built-in base URL and stay listed: `requiresBaseUrl`
+    // Custom connections have no built-in base URL and stay listed: `requiresBaseUrl`
     // tells the wizard to collect an endpoint before the API key. The original
     // phase-1 wizard filtered every empty-baseUrl provider out because it had no
     // base-URL step to offer (#1254); that step exists now (#3405). Providers
@@ -30,13 +30,29 @@ export function listApiKeyOnboardableProviders() {
             return false;
         const definition = PROVIDER_REGISTRY[providerType];
         return Boolean(definition.baseUrl) || definition.category === 'custom';
-    }).map((providerType) => {
+    }).flatMap((providerType) => {
         const definition = PROVIDER_REGISTRY[providerType];
-        return {
+        const entry = {
             providerType,
             label: definition.label,
             requiresBaseUrl: !definition.baseUrl,
             setupMethod: 'api_key',
         };
+        if (providerType !== 'custom')
+            return [entry];
+        return MODEL_API_PROTOCOLS.map((defaultApiProtocol) => ({
+            ...entry,
+            defaultApiProtocol,
+            label: `${definition.label} (${MODEL_API_PROTOCOL_LABELS[defaultApiProtocol]})`,
+        }));
     });
 }
+export function onboardingCreateTarget(provider) {
+    return {
+        kind: 'create',
+        providerType: provider.providerType,
+        ...(provider.defaultApiProtocol === undefined
+            ? {}
+            : { defaultApiProtocol: provider.defaultApiProtocol }),
+    };
+}

package/dist/pi-transcript.js

@@ -941,14 +941,6 @@ function systemNoteText(message) {
             return 'Context compacted to keep this task within the model window.';
         case 'context_compaction_failed_open':
             return 'Context summary failed; the session continued without a new summary.';
-        case 'context_provider_dropping': {
-            const data = message.data;
-            const used = typeof data?.inputTokens === 'number' ? data.inputTokens : undefined;
-            const prior = typeof data?.priorInputTokens === 'number' ? data.priorInputTokens : undefined;
-            if (used === undefined || prior === undefined)
-                return "After content was appended, the provider-reported input token count did not grow; context may have been truncated or rewritten. If this persists, check that the model's actual context capacity and the connection settings agree.";
-            return `After content was appended, the provider-reported input token count did not grow; context may have been truncated or rewritten (${used} tokens versus ${prior} before). If this persists, check that the model's actual context capacity and the connection settings agree.`;
-        }
         case 'context_overflow_after_compaction':
             return 'History was compacted and the provider still called this request too large. What remains also carries the system prompt, the tool schemas, the summary and the recent tail; shortening this message is the part you control.';
         case 'context_reported_window_exceeded': {

package/dist/pi-tui-pickers.js

@@ -822,7 +822,7 @@ export function onboardingProviderPickerItems(providers, locale) {
 function onboardingProviderKey(provider) {
     return provider.target.kind === 'existing'
         ? provider.target.connectionId
-        : `create:${provider.target.providerType}`;
+        : `create:${provider.target.providerType}:${provider.target.defaultApiProtocol ?? ''}`;
 }
 export function thinkingLevelPickerItems(levels, current, locale) {
     const copy = getTuiPickerCopy(locale);

package/dist/pi-tui-runner.js

@@ -26,7 +26,7 @@ import { projectRevisionLinkedSessionTree } from '@maka/core/session-revisions';
 import { slashCommandsForSurface, } from '@maka/core/slash-command-catalog';
 import { latestAssistantModelId, } from '@maka/core/session';
 import { defineUiMessageCatalog, formatUiMessage, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
-import { listApiKeyOnboardableProviders } from './onboarding-catalog.js';
+import { listApiKeyOnboardableProviders, onboardingCreateTarget } from './onboarding-catalog.js';
 import { AUTO_RECAP_DISPLAY_LIMIT_BYTES, shouldAutoRecap } from './session-recap.js';
 import { MakaSkillHighlightEditor } from './skill-highlight-editor.js';
 import { parseGraphCommand } from '@maka/core/graph-command';
@@ -2256,7 +2256,7 @@ export async function runMakaPiTui(input) {
             // wizard can report unavailability in-frame at submit instead of throwing.
             providers = listApiKeyOnboardableProviders().map((provider) => ({
                 ...provider,
-                target: { kind: 'create', providerType: provider.providerType },
+                target: onboardingCreateTarget(provider),
                 label: provider.label,
                 suggestedSlug: deriveConnectionSlug(provider.providerType),
                 enabledModelIds: [],
@@ -2288,8 +2288,10 @@ export async function runMakaPiTui(input) {
             onSubmitIdentity: (identity) => {
                 if (wizardTarget?.kind === 'create') {
                     wizardTarget = {
-                        kind: 'create',
-                        providerType: wizardTarget.providerType,
+                        ...onboardingCreateTarget({
+                            providerType: wizardTarget.providerType,
+                            defaultApiProtocol: wizardTarget.defaultApiProtocol,
+                        }),
                         ...(identity.slug === null ? {} : { slug: identity.slug }),
                         ...(identity.name === null ? {} : { name: identity.name }),
                     };

package/dist/runtime-host-capability-provider-command.js

@@ -22,7 +22,7 @@ import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { createCredentialMcpOAuthStorage, formatMcpDiagnosticText, McpClientManager, } from '@maka/mcp';
 import { createFileCredentialStore } from '@maka/storage/credential-store';
-import { normalizeMcpConfig } from '@maka/storage/mcp-config-store';
+import { normalizeMcpConfig, subscribeMcpConfigFileChanges } from '@maka/storage/mcp-config-store';
 import { connectRemoteRuntimeHost, loadOrCreateRuntimeHostClientInstanceId, remoteRuntimeHostUnavailableError, RuntimeHostPermanentReconnectError, startRuntimeHostCapabilityProviderService, } from '@maka/runtime-host/client';
 import { INTERACTIVE_RUNTIME_HOST_COMPOSITION_ID, RUNTIME_HOST_COMPATIBILITY_EPOCH, RUNTIME_HOST_PROTOCOL_VERSION, } from '@maka/runtime-host/protocol';
 import { runRuntimeHostProcessLifecycle } from '@maka/runtime-host/server';
@@ -39,11 +39,14 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
     const credential = process.env[credentialEnv];
     if (!credential)
         throw new Error(`Runtime Host access credential is missing from ${credentialEnv}`);
-    const configText = await readFile(configPath, 'utf8');
-    if (Buffer.byteLength(configText, 'utf8') > MAX_MCP_CONFIG_BYTES) {
-        throw new Error('MCP config exceeds 1 MiB');
-    }
-    const config = normalizeMcpConfig(JSON.parse(configText));
+    const readConfig = async () => {
+        const configText = await readFile(configPath, 'utf8');
+        if (Buffer.byteLength(configText, 'utf8') > MAX_MCP_CONFIG_BYTES) {
+            throw new Error('MCP config exceeds 1 MiB');
+        }
+        return normalizeMcpConfig(JSON.parse(configText));
+    };
+    const config = await readConfig();
     const clientInstanceId = await loadOrCreateRuntimeHostClientInstanceId(identityPath);
     const manager = new McpClientManager({
         clientName: 'maka-capability-provider',
@@ -55,6 +58,21 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
         oauthStorage: createCredentialMcpOAuthStorage(createFileCredentialStore(dirname(configPath))),
     });
     await manager.sync(config);
+    // Desktop and the TUI edit this file while the provider runs. One change is
+    // read and applied at a time, so an older read never lands last.
+    let following = Promise.resolve();
+    const stopFollowing = subscribeMcpConfigFileChanges(configPath, (error) => {
+        if (error) {
+            process.stderr.write(`MCP config is no longer followed: ${error.message}\n`);
+            return;
+        }
+        following = following
+            .then(async () => manager.sync(await readConfig()))
+            .catch((failure) => {
+            const message = failure instanceof Error ? failure.message : String(failure);
+            process.stderr.write(`MCP config change was not applied: ${message}\n`);
+        });
+    });
     let service;
     let publishedRevision = manager.toolSnapshot().revision;
     const disposeChanges = manager.onChange(() => {
@@ -100,6 +118,7 @@ export async function runRuntimeHostCapabilityProviderCli(options) {
     }
     finally {
         clearInterval(reconnectTimer);
+        stopFollowing();
         disposeChanges();
         await service?.close().catch(() => undefined);
         await manager.close();

package/dist/runtime-host-onboarding.js

@@ -19,7 +19,7 @@
 import { randomUUID } from 'node:crypto';
 import { deriveConnectionSlug, deriveInteractiveOAuthConnectionSlug, offerableCatalogEntries, providerFallbackModelIds, PROVIDER_REGISTRY, } from '@maka/core/llm-connections';
 import { createOAuthPresentationClientProvider, readRuntimeHostConnectionCatalog, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, } from '@maka/runtime-host/client';
-import { listApiKeyOnboardableProviders } from './onboarding-catalog.js';
+import { listApiKeyOnboardableProviders, onboardingCreateTarget } from './onboarding-catalog.js';
 /** Adapt the TUI onboarding workflow to Host-owned verification and persistence. */
 export function createRuntimeHostOnboardingSurface(connection, options = {}) {
     const shutdown = new AbortController();
@@ -432,8 +432,10 @@ export function projectProviders(catalog, codexOAuthEnabled = false) {
     const existingSlugs = catalog.connections.map((connection) => connection.slug);
     for (const provider of listApiKeyOnboardableProviders()) {
         for (const connection of catalog.connections) {
-            if (connection.providerType !== provider.providerType)
+            if (connection.providerType !== provider.providerType ||
+                connection.defaultApiProtocol !== provider.defaultApiProtocol) {
                 continue;
+            }
             entries.push({
                 ...provider,
                 target: { kind: 'existing', connectionId: connection.connectionId },
@@ -444,7 +446,7 @@ export function projectProviders(catalog, codexOAuthEnabled = false) {
         }
         entries.push({
             ...provider,
-            target: { kind: 'create', providerType: provider.providerType },
+            target: onboardingCreateTarget(provider),
             label: provider.label,
             suggestedSlug: deriveConnectionSlug(provider.providerType, existingSlugs),
             enabledModelIds: [],

package/dist/runtime-host-session-channel.js

@@ -19,7 +19,7 @@
 import { decodeStoredMessage as decodePersistedStoredMessage, } from '@maka/core/session';
 import { markPersisted } from '@maka/core/persisted-value';
 import { createRuntimeHostSessionProjectionSeed, RuntimeHostSessionProjector, isRuntimeHostTerminalTurn as isTerminalTurn, sameRuntimeHostTerminalTurn, } from '@maka/runtime-host/adapter';
-import { isRuntimeHostReconnectingConnection, RuntimeHostRequestInterruptedError, RuntimeHostSubscriptionError, } from '@maka/runtime-host/client';
+import { isRuntimeHostReconnectingConnection, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, RuntimeHostSubscriptionError, } from '@maka/runtime-host/client';
 import { SESSION_TRANSCRIPT_BOOTSTRAP_MAX_BYTES, SESSION_TRANSCRIPT_PAGE_MAX_BYTES, } from '@maka/runtime-host/protocol';
 const decodeStoredMessage = (value) => decodePersistedStoredMessage(markPersisted(value));
 const PROMPT_TRANSCRIPT_RANGE_MAX_BYTES = 16 * 1024 * 1024;
@@ -652,6 +652,11 @@ export class RuntimeHostSessionChannel {
     #canRecover(error) {
         if (!isRuntimeHostReconnectingConnection(this.#connection))
             return false;
+        // The Host can retire a transcript subscription before its close frame is
+        // consumed. Recover the invalidated read through the same bounded policy.
+        if (error instanceof RuntimeHostOperationError) {
+            return error.operation === 'session.transcript.page' && error.code === 'not_found';
+        }
         if (error instanceof RuntimeHostRequestInterruptedError) {
             return error.reason === 'connection_lost';
         }
@@ -659,6 +664,7 @@ export class RuntimeHostSessionChannel {
             (error.reason === 'connection_closed' ||
                 error.reason === 'sequence_gap' ||
                 error.reason === 'projection_revision_invalid' ||
+                error.reason === 'transcript_changed' ||
                 error.reason === 'slow_consumer'));
     }
     #accept(frame) {
@@ -678,8 +684,8 @@ export class RuntimeHostSessionChannel {
             return;
         }
         if (frame.kind === 'subscription.closed') {
-            if (frame.reason === 'slow_consumer') {
-                throw new RuntimeHostSubscriptionError('slow_consumer', 'Runtime Host Session subscription consumer fell behind');
+            if (frame.reason === 'slow_consumer' || frame.reason === 'transcript_changed') {
+                throw new RuntimeHostSubscriptionError(frame.reason, 'Runtime Host Session transcript requires a fresh subscription');
             }
             this.#fail(new Error(`Runtime Host Session subscription closed: ${frame.reason}`));
             return;

package/dist/tui-mcp-control.js

@@ -17,10 +17,10 @@
  * under the License.
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { MCP_CONFIG_VERSION, mcpConfigChangeRetiresCredentials, resolveMcpProtocolPreference, } from '@maka/core/mcp';
+import { MCP_CONFIG_VERSION, resolveMcpProtocolPreference, } from '@maka/core/mcp';
 import { createCredentialMcpOAuthStorage, McpClientManager } from '@maka/mcp';
 import { createFileCredentialStore } from '@maka/storage/credential-store';
-import { AtomicFileWriteCommitUnknownError, createMcpConfigStore, assertMcpEndpointPolicyOnChanges, McpConfigSourceError, normalizeMcpConfig, normalizeMcpImport, } from '@maka/storage/mcp-config-store';
+import { AtomicFileWriteCommitUnknownError, createMcpConfigStore, updateMcpConfiguration, McpConfigurationValidationError, McpConfigSourceError, normalizeMcpConfig, normalizeMcpImport, } from '@maka/storage/mcp-config-store';
 import { createMcpCapabilityProvider } from './mcp-capability-provider.js';
 import { McpCapabilityPublication } from './mcp-capability-publication.js';
 const RUNTIME_HOST_CREDENTIAL_ENV = 'MAKA_RUNTIME_HOST_ACCESS_CREDENTIAL';
@@ -43,6 +43,7 @@ class TuiMcpControllerImpl {
     #listeners = new Set();
     #disposeManagerChange;
     #disposeConnectionAvailability;
+    #disposeConfigChanges;
     #initialization;
     #availability = { kind: 'unavailable' };
     #closed = false;
@@ -112,6 +113,17 @@ class TuiMcpControllerImpl {
                     this.#requestPublication();
             }
         });
+        // Desktop edits the same file. A change during startup waits for it
+        // rather than being dropped, since startup may have read the file first.
+        // Failing to follow leaves the TUI's own edits working, so it stays quiet
+        // rather than print over the screen.
+        this.#disposeConfigChanges = deps.configStore.subscribeChanges((error) => {
+            if (error)
+                return;
+            void this.#initialization
+                .then(() => this.#serializeAction(() => this.#followConfigChange()))
+                .catch(() => undefined);
+        });
         this.#initialization = this.#initialize();
     }
     snapshot() {
@@ -176,6 +188,7 @@ class TuiMcpControllerImpl {
         this.#closed = true;
         this.#disposeManagerChange();
         this.#disposeConnectionAvailability();
+        this.#disposeConfigChanges();
         this.#listeners.clear();
         this.#preparedImport = undefined;
         const publicationClosing = this.#publication.close().catch(() => undefined);
@@ -264,44 +277,32 @@ class TuiMcpControllerImpl {
     async #commitMutation(action) {
         let committed;
         try {
-            committed = await this.#deps.configStore.transform(async (current) => {
-                if (this.#closed) {
+            committed = await updateMcpConfiguration(this.#deps.configStore, (current) => {
+                if (this.#closed)
                     throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
-                }
                 const prepared = this.#prepareMutation(current, action);
                 if ('status' in prepared)
                     throw new TuiMcpMutationError(prepared);
-                const { next } = prepared;
+                return prepared.next;
+            }, async (serverId, previous) => {
                 try {
-                    assertMcpEndpointPolicyOnChanges(current, next);
+                    await this.#deps.manager.forgetServerCredentials(serverId, previous);
                 }
                 catch {
-                    throw new TuiMcpMutationError({ status: 'failed', reason: 'invalid-config' });
-                }
-                try {
-                    for (const [serverId, previous] of Object.entries(current.mcpServers)) {
-                        if (!mcpConfigChangeRetiresCredentials(previous, next.mcpServers[serverId]))
-                            continue;
-                        await this.#deps.manager.forgetServerCredentials(serverId, previous);
-                        if (this.#closed) {
-                            throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
-                        }
-                    }
-                }
-                catch (error) {
-                    if (error instanceof TuiMcpMutationError)
-                        throw error;
                     throw new TuiMcpMutationError({
                         status: 'failed',
                         reason: 'credential-cleanup-failed',
                     });
                 }
-                return next;
+                if (this.#closed)
+                    throw new TuiMcpMutationError({ status: 'failed', reason: 'closed' });
             });
         }
         catch (error) {
             if (error instanceof TuiMcpMutationError)
                 return error.result;
+            if (error instanceof McpConfigurationValidationError)
+                return { status: 'failed', reason: 'invalid-config' };
             if (error instanceof AtomicFileWriteCommitUnknownError) {
                 // The transform has already published, including any credential
                 // retirement. Reload its authority; never replay those effects.
@@ -336,12 +337,24 @@ class TuiMcpControllerImpl {
             }
             return { status: 'failed', reason: 'persist-failed' };
         }
+        this.#preparedImport = undefined;
         return (await this.#synchronizeCommittedConfig(committed)).result;
     }
+    async #followConfigChange() {
+        if (this.#closed)
+            return;
+        if (this.#snapshot.initialization === 'error')
+            return this.#initialize();
+        const latest = await this.#deps.configStore.get();
+        // An import preview survives: its commit re-checks each server it replaces.
+        if (this.#snapshot.configuration !== 'ready' ||
+            JSON.stringify(latest) !== JSON.stringify(this.#config)) {
+            await this.#synchronizeCommittedConfig(latest);
+        }
+    }
     async #synchronizeCommittedConfig(committed) {
         if (this.#closed)
             return { result: { status: 'failed', reason: 'closed' } };
-        this.#preparedImport = undefined;
         this.#config = cloneConfig(committed);
         this.#updateSnapshot({ configuration: 'synchronizing' });
         this.#refreshManagerSnapshot();

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

@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export class AcpRuntimeError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AcpRuntimeError';
+    }
+}

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

@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { constants } from 'node:fs';
+import { lstat, open, realpath, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+const MAX_TEXT_FILE_BYTES = 8 * 1024 * 1024;
+export async function readWorkspaceTextFile(cwd, path, line, limit) {
+    if (line != null && (!Number.isSafeInteger(line) || line < 1))
+        throw new Error('ACP file line must be a positive integer');
+    if (limit != null && (!Number.isSafeInteger(limit) || limit < 0))
+        throw new Error('ACP file limit must be a non-negative integer');
+    const file = await openWorkspaceFile(cwd, path, false);
+    try {
+        const info = await file.stat();
+        if (info.size > MAX_TEXT_FILE_BYTES)
+            throw new Error('ACP text file is too large');
+        const text = await file.readFile('utf8');
+        const start = line == null ? 0 : line - 1;
+        return line != null || limit != null
+            ? text
+                .split('\n')
+                .slice(start, limit == null ? undefined : start + limit)
+                .join('\n')
+            : text;
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function writeWorkspaceTextFile(cwd, path, content) {
+    if (Buffer.byteLength(content) > MAX_TEXT_FILE_BYTES)
+        throw new Error('ACP text file is too large');
+    const file = await openWorkspaceFile(cwd, path, true);
+    try {
+        // Validation happens against this exact open file descriptor before any
+        // existing content is truncated, so later path swaps cannot redirect data.
+        await file.truncate(0);
+        await file.writeFile(content, 'utf8');
+    }
+    finally {
+        await file.close();
+    }
+}
+async function openWorkspaceFile(cwd, path, forWrite) {
+    if (!isAbsolute(path))
+        throw new Error('ACP file path must be absolute');
+    const root = await realpath(cwd);
+    const candidate = resolve(path);
+    if (forWrite) {
+        const parent = await realpath(dirname(candidate));
+        assertContained(root, parent);
+        const entry = await lstat(candidate).catch((error) => {
+            if (error.code !== 'ENOENT')
+                throw error;
+            return undefined;
+        });
+        if (entry?.isSymbolicLink())
+            throw new Error('ACP file path could not be resolved');
+    }
+    const flags = forWrite
+        ? constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0)
+        : constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0);
+    const file = await open(candidate, flags, 0o600);
+    try {
+        const opened = await file.stat();
+        if (!opened.isFile())
+            throw new Error('ACP file path is not a regular file');
+        // Resolve and compare after opening. If the path or an ancestor changed
+        // between lookup and open, either containment or file identity no longer
+        // matches. Operations after this point use only the verified descriptor.
+        const canonical = await realpath(candidate);
+        assertContained(root, canonical);
+        const current = await stat(canonical);
+        if (opened.dev !== current.dev || opened.ino !== current.ino)
+            throw new Error('ACP file path changed during validation');
+        return file;
+    }
+    catch (error) {
+        await file.close();
+        throw error;
+    }
+}
+function assertContained(root, candidate) {
+    const relation = relative(root, candidate);
+    if (relation === '..' || relation.startsWith('../') || isAbsolute(relation))
+        throw new Error('ACP file path leaves the workspace');
+}

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

@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { setTimeout as delay } from 'node:timers/promises';
+import { client, ndJsonStream, } from '@agentclientprotocol/sdk';
+import { terminateProcessTree } from '@maka/runtime/process-tree-terminator';
+import { AcpRuntimeError } from './acp-errors.js';
+const PROCESS_EXIT_TIMEOUT_MS = 2_000;
+export function createAcpConnection(input) {
+    let child;
+    try {
+        child = spawn(input.executable, [...(input.args ?? [])], {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: 'pipe',
+            detached: true,
+            shell: false,
+        });
+    }
+    catch {
+        throw new AcpRuntimeError('ACP executable is unavailable', 'acp_executable_unavailable');
+    }
+    let disposing = false;
+    let disposed = false;
+    let disposal;
+    let rejectFailure;
+    const failed = new Promise((_resolve, reject) => {
+        rejectFailure = reject;
+    });
+    void failed.catch(() => undefined);
+    const fail = () => {
+        if (!disposing)
+            rejectFailure(new Error('ACP connection failed'));
+    };
+    child.once('error', fail);
+    child.stdin.once('error', fail);
+    child.stderr.once('error', fail);
+    child.stderr.on('data', () => undefined);
+    child.once('close', fail);
+    const app = client({ name: input.clientName });
+    input.configureClient(app);
+    const connection = app.connect(ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+    void connection.closed.then(fail, fail);
+    return {
+        connection,
+        failed,
+        dispose() {
+            if (disposed)
+                return Promise.resolve();
+            if (disposal)
+                return disposal;
+            disposing = true;
+            disposal = terminate(child, connection).then(() => {
+                disposed = true;
+            }, (error) => {
+                disposal = undefined;
+                throw error;
+            });
+            return disposal;
+        },
+    };
+}
+async function terminate(child, connection) {
+    const pid = child.pid;
+    const alive = () => {
+        if (!pid)
+            return false;
+        if (process.platform === 'win32')
+            return child.exitCode === null && child.signalCode === null;
+        try {
+            process.kill(-pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code !== 'ESRCH';
+        }
+    };
+    try {
+        if (pid) {
+            await terminateProcessTree({ pid, signal: 'SIGTERM', fallback: () => child.kill('SIGTERM') });
+            for (let elapsed = 0; elapsed < PROCESS_EXIT_TIMEOUT_MS && alive(); elapsed += 50)
+                await delay(50);
+            if (alive()) {
+                await terminateProcessTree({
+                    pid,
+                    signal: 'SIGKILL',
+                    fallback: () => child.kill('SIGKILL'),
+                });
+                for (let elapsed = 0; elapsed < PROCESS_EXIT_TIMEOUT_MS && alive(); elapsed += 50)
+                    await delay(50);
+            }
+            if (alive())
+                throw new Error('ACP process cleanup failed');
+        }
+    }
+    finally {
+        connection.close();
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
+    }
+}