@borgee/agents-host 0.2.28 → 0.2.31

package/dist/managed-daemon.js

@@ -5,8 +5,8 @@ import { createConnection, createServer } from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
-import { COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
-import { loadConfigFromEnv } from './config.js';
+import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
+import { DEFAULT_PROVIDER_COMMAND_CONFIG, hasLegacyClaudeOneShotArgs, loadConfigFromEnv, } from './config.js';
 import { loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
 import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonLogPath, resolveManagedDaemonSocketPath, resolveManagedRuntimeRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
 const MANAGED_ROOT_MODE = 0o700;
@@ -149,8 +149,9 @@ function resolveDesiredManagedRuntimeSettings(env = process.env) {
 function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
     const compatibilityGates = [...new Set(snapshot.compatibilityGates.map((gate) => gate.trim()))]
         .filter((gate) => gate.length > 0)
+        .filter((gate) => gate !== CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE)
         .sort((left, right) => left.localeCompare(right));
-    const providerImplementationOverrides = normalizeInternalProviderImplementationOverrides(snapshot.providerImplementationOverrides.join(','));
+    const providerImplementationOverrides = normalizeInternalProviderImplementationOverrides(snapshot.providerImplementationOverrides.join(',')).filter((assignment) => !assignment.startsWith('claude:'));
     return {
         schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
         compatibilityGates,
@@ -222,15 +223,45 @@ function buildManagedRuntimeSettingsEnv(baseEnv, snapshot) {
     return {
         ...baseEnv,
         [COMPATIBILITY_GATES_ENV]: snapshot.compatibilityGates.join(','),
+        [INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV]: resolveDisabledDefaultCompatibilityGates(snapshot.compatibilityGates).join(','),
         [INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]: snapshot.providerImplementationOverrides.join(','),
         [INTERNAL_POLICY_MODE_ENV]: snapshot.internalPolicyMode,
     };
 }
-function getManagedRuntimeFingerprintMismatch(status, desiredSettings) {
-    if (!desiredSettings.convergenceEnabled) {
-        return status.managedRuntimeFingerprint != null;
+function buildDesiredManagedRuntimeSettingsFromSnapshot(snapshot) {
+    return {
+        snapshot,
+        fingerprint: createManagedRuntimeSettingsFingerprint(snapshot),
+        convergenceEnabled: snapshot.compatibilityGates.includes(MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE),
+    };
+}
+async function getManagedRuntimeFingerprintMismatch(rootPath, status, desiredSettings) {
+    if (status.managedRuntimeFingerprint != null) {
+        return status.managedRuntimeFingerprint !== desiredSettings.fingerprint;
+    }
+    if (desiredSettings.convergenceEnabled) {
+        return true;
+    }
+    const persistedSettingsSnapshot = await loadManagedRuntimeSettingsSnapshot(rootPath);
+    if (!persistedSettingsSnapshot) {
+        return true;
+    }
+    return createManagedRuntimeSettingsFingerprint(persistedSettingsSnapshot) !== desiredSettings.fingerprint;
+}
+async function resolveAuthoritativeManagedRuntimeSettings(rootPath, effectiveProcessEnv) {
+    const persistedSettingsSnapshot = await loadManagedRuntimeSettingsSnapshot(rootPath);
+    if (!persistedSettingsSnapshot) {
+        return {
+            desiredSettings: resolveDesiredManagedRuntimeSettings(effectiveProcessEnv),
+            processEnv: effectiveProcessEnv,
+            persistedSettingsSnapshot: null,
+        };
     }
-    return status.managedRuntimeFingerprint !== desiredSettings.fingerprint;
+    return {
+        desiredSettings: buildDesiredManagedRuntimeSettingsFromSnapshot(persistedSettingsSnapshot),
+        processEnv: buildManagedRuntimeSettingsEnv(effectiveProcessEnv, persistedSettingsSnapshot),
+        persistedSettingsSnapshot,
+    };
 }
 function cloneLocalAgentConfig(agent) {
     return {
@@ -311,6 +342,70 @@ export function buildManagedLocalAgentConfig(options) {
         },
     };
 }
+function mergeManagedLocalAgentConfig(hostDefaults, existingAgent, generatedAgent, envOverrides) {
+    const overrides = envOverrides ?? {};
+    const hasOverride = (key) => Object.prototype.hasOwnProperty.call(overrides, key);
+    const effectiveExistingClaudeCommand = existingAgent.claudeCommand ?? hostDefaults?.claudeCommand;
+    const effectiveExistingClaudeArgs = existingAgent.claudeArgs ?? hostDefaults?.claudeArgs ?? [];
+    const hasLegacyClaudeDefaults = effectiveExistingClaudeCommand === 'claude' && hasLegacyClaudeOneShotArgs(effectiveExistingClaudeArgs);
+    const shouldRefreshLegacyClaudeDefaults = hasLegacyClaudeDefaults
+        && generatedAgent.claudeCommand === DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand
+        && JSON.stringify(generatedAgent.claudeArgs ?? []) === JSON.stringify(DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs);
+    const shouldResetLegacyClaudeArgsForCommandOverride = hasLegacyClaudeDefaults
+        && hasOverride('CLAUDE_COMMAND')
+        && !hasOverride('CLAUDE_ARGS');
+    return {
+        ...cloneLocalAgentConfig(existingAgent),
+        key: generatedAgent.key,
+        apiKey: generatedAgent.apiKey,
+        enabled: true,
+        name: hasOverride('BORGEE_AGENT_NAME') ? generatedAgent.name : existingAgent.name,
+        provider: hasOverride('RUNTIME_PROVIDER') ? generatedAgent.provider : existingAgent.provider,
+        claudeCommand: hasOverride('CLAUDE_COMMAND') || shouldRefreshLegacyClaudeDefaults
+            ? generatedAgent.claudeCommand
+            : existingAgent.claudeCommand,
+        claudeArgs: hasOverride('CLAUDE_ARGS')
+            || shouldRefreshLegacyClaudeDefaults
+            || shouldResetLegacyClaudeArgsForCommandOverride
+            ? [...(generatedAgent.claudeArgs ?? [])]
+            : [...(existingAgent.claudeArgs ?? [])],
+        codexCommand: hasOverride('CODEX_COMMAND') ? generatedAgent.codexCommand : existingAgent.codexCommand,
+        codexArgs: hasOverride('CODEX_ARGS')
+            ? [...(generatedAgent.codexArgs ?? [])]
+            : [...(existingAgent.codexArgs ?? [])],
+        copilotCommand: hasOverride('COPILOT_COMMAND')
+            ? generatedAgent.copilotCommand
+            : existingAgent.copilotCommand,
+        copilotArgs: hasOverride('COPILOT_ARGS')
+            ? [...(generatedAgent.copilotArgs ?? [])]
+            : [...(existingAgent.copilotArgs ?? [])],
+        copilotSessionTtlMinutes: hasOverride('COPILOT_SESSION_TTL_MINUTES')
+            ? generatedAgent.copilotSessionTtlMinutes
+            : existingAgent.copilotSessionTtlMinutes,
+    };
+}
+function collectExplicitManagedAgentEnvOverrides(processEnv, optionEnv) {
+    const explicitOverrides = {};
+    for (const key of [
+        'BORGEE_AGENT_NAME',
+        'RUNTIME_PROVIDER',
+        'CLAUDE_COMMAND',
+        'CLAUDE_ARGS',
+        'CODEX_COMMAND',
+        'CODEX_ARGS',
+        'COPILOT_COMMAND',
+        'COPILOT_ARGS',
+        'COPILOT_SESSION_TTL_MINUTES',
+    ]) {
+        if (processEnv[key] !== undefined) {
+            explicitOverrides[key] = processEnv[key];
+        }
+        if (optionEnv && Object.prototype.hasOwnProperty.call(optionEnv, key)) {
+            explicitOverrides[key] = optionEnv[key];
+        }
+    }
+    return explicitOverrides;
+}
 function resolveManagedRuntimeLayoutForServerUrl(serverUrl, processEnv = process.env) {
     const rootPath = resolveManagedRuntimeRoot(serverUrl, processEnv);
     return {
@@ -884,8 +979,6 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
         ...(options.processEnv ?? process.env),
         ...options.env,
     };
-    const loadSpec = deps.loadSpec
-        ?? ((hostConfigPath) => loadLocalConfigGenerateSpec(hostConfigPath, { env: effectiveProcessEnv }));
     const materialize = deps.materialize ?? materializeLocalConfig;
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const spawnDaemonProcess = deps.spawnDaemon ?? spawnManagedDaemonProcess;
@@ -895,19 +988,51 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
         ?? (async (rootPath) => {
             await waitForManagedDaemonShutdown(rootPath, canConnectToSocket);
         });
-    const desiredSettings = resolveDesiredManagedRuntimeSettings(effectiveProcessEnv);
-    const resolvedManagedAgent = options.apiKey === undefined ? null : buildManagedLocalAgentConfig(options);
-    const resolved = resolvedManagedAgent ??
-        resolveManagedRuntimeLayoutForServerUrl(options.serverUrl, options.processEnv);
+    const requestedSettings = resolveDesiredManagedRuntimeSettings(effectiveProcessEnv);
+    const resolved = resolveManagedRuntimeLayoutForServerUrl(options.serverUrl, options.processEnv);
     const releaseBootstrapLock = await acquireLock(resolved.rootPath);
     try {
+        const currentRuntimeSettings = await resolveAuthoritativeManagedRuntimeSettings(resolved.rootPath, effectiveProcessEnv);
+        const loadManagedSpecWithCurrentRuntimeEnv = (hostConfigPath) => deps.loadSpec
+            ? deps.loadSpec(hostConfigPath)
+            : loadLocalConfigGenerateSpec(hostConfigPath, {
+                env: currentRuntimeSettings.processEnv,
+            });
+        if (options.apiKey !== undefined
+            && currentRuntimeSettings.persistedSettingsSnapshot == null
+            && await fs.access(resolved.hostConfigPath).then(() => true).catch(() => false)) {
+            throw new Error(`Managed runtime root ${resolved.rootPath} predates managed-runtime-settings.json; run \`agents-host start-managed ${options.serverUrl}\` once to migrate it before updating an individual agent`);
+        }
+        const explicitManagedAgentOverrides = collectExplicitManagedAgentEnvOverrides(options.processEnv ?? process.env, options.env);
+        const currentManagedSpec = options.apiKey === undefined
+            ? undefined
+            : await loadManagedSpecOrUndefined(resolved.hostConfigPath, loadManagedSpecWithCurrentRuntimeEnv);
+        const resolvedManagedAgent = options.apiKey === undefined
+            ? null
+            : (() => {
+                const generatedManagedAgent = buildManagedLocalAgentConfig({
+                    ...options,
+                    processEnv: currentRuntimeSettings.processEnv,
+                    env: options.env,
+                });
+                const existingAgent = currentManagedSpec?.agents.find((agent) => agent.key === generatedManagedAgent.agent.key);
+                return existingAgent
+                    ? {
+                        ...generatedManagedAgent,
+                        agent: mergeManagedLocalAgentConfig(currentManagedSpec?.host.defaults, existingAgent, generatedManagedAgent.agent, explicitManagedAgentOverrides),
+                    }
+                    : generatedManagedAgent;
+            })();
+        const desiredBootstrapSettings = options.apiKey === undefined ? requestedSettings : currentRuntimeSettings.desiredSettings;
+        const desiredBootstrapProcessEnv = options.apiKey === undefined ? effectiveProcessEnv : currentRuntimeSettings.processEnv;
         let statusResponse = await readReadyManagedDaemonStatus(resolved.rootPath, sendRequest);
-        if (statusResponse && getManagedRuntimeFingerprintMismatch(statusResponse, desiredSettings)) {
+        if (statusResponse
+            && await getManagedRuntimeFingerprintMismatch(resolved.rootPath, statusResponse, desiredBootstrapSettings)) {
             await recycleManagedDaemonWithDesiredSettings({
                 rootPath: resolved.rootPath,
                 debug: options.debug === true,
-                processEnv: effectiveProcessEnv,
-                desiredSettings,
+                processEnv: desiredBootstrapProcessEnv,
+                desiredSettings: desiredBootstrapSettings,
                 sendRequest,
                 waitForShutdown,
                 spawnDaemonProcess,
@@ -917,11 +1042,17 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
         }
         if (!statusResponse) {
             if (options.apiKey === undefined) {
-                await ensurePersistedManagedAgentsExist(options.serverUrl, resolved.hostConfigPath, loadSpec);
+                await ensurePersistedManagedAgentsExist(options.serverUrl, resolved.hostConfigPath, (hostConfigPath) => options.apiKey === undefined
+                    ? (deps.loadSpec
+                        ? deps.loadSpec(hostConfigPath)
+                        : loadLocalConfigGenerateSpec(hostConfigPath, {
+                            env: desiredBootstrapProcessEnv,
+                        }))
+                    : loadManagedSpecWithCurrentRuntimeEnv(hostConfigPath));
             }
             else {
                 try {
-                    await loadSpec(resolved.hostConfigPath);
+                    await loadManagedSpecWithCurrentRuntimeEnv(resolved.hostConfigPath);
                 }
                 catch (error) {
                     if (isNotFoundError(error)) {
@@ -938,8 +1069,8 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
             await startManagedDaemonWithPersistedSettings({
                 rootPath: resolved.rootPath,
                 debug: options.debug === true,
-                processEnv: effectiveProcessEnv,
-                desiredSettings,
+                processEnv: desiredBootstrapProcessEnv,
+                desiredSettings: desiredBootstrapSettings,
                 spawnDaemonProcess,
                 waitForDaemon,
                 sendRequest,
@@ -948,7 +1079,11 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
         }
         if (options.apiKey === undefined) {
             if (!statusResponse) {
-                await ensurePersistedManagedAgentsExist(options.serverUrl, resolved.hostConfigPath, loadSpec);
+                await ensurePersistedManagedAgentsExist(options.serverUrl, resolved.hostConfigPath, (hostConfigPath) => deps.loadSpec
+                    ? deps.loadSpec(hostConfigPath)
+                    : loadLocalConfigGenerateSpec(hostConfigPath, {
+                        env: desiredBootstrapProcessEnv,
+                    }));
             }
             else {
                 assertManagedRuntimeBinding(statusResponse.borgeeBaseUrl, options.serverUrl);
@@ -1079,10 +1214,11 @@ async function terminateChildProcessAndWait(child) {
     }
     await waitForChildExit(child, DAEMON_FORCE_KILL_WAIT_MS);
 }
-async function rollbackManagedApplyFailure(rootPath, previousSpec, materialize, clearRuntimeImpl, applyError) {
+async function rollbackManagedApplyFailure(rootPath, previousSpec, previousSettingsSnapshot, materialize, clearRuntimeImpl, applyError) {
     const original = toManagedErrorPayload(applyError, 'MANAGED_RELOAD_FAILED');
     try {
         if (previousSpec) {
+            await restoreManagedRuntimeSettingsSnapshot(rootPath, previousSettingsSnapshot);
             await materialize(rootPath, cloneLocalConfigGenerateSpec(previousSpec));
         }
         else {
@@ -1139,8 +1275,6 @@ function validateDaemonUpsertAgentInput(currentSpec, serverUrl, agent, env = pro
 }
 export async function describeManagedSpec(options, deps = {}) {
     const effectiveProcessEnv = options.processEnv ?? process.env;
-    const loadSpec = deps.loadSpec
-        ?? ((hostConfigPath) => loadLocalConfigGenerateSpec(hostConfigPath, { env: effectiveProcessEnv }));
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const resolved = resolveManagedRuntimeLayoutForServerUrl(options.serverUrl, options.processEnv);
     try {
@@ -1167,7 +1301,12 @@ export async function describeManagedSpec(options, deps = {}) {
         }
     }
     try {
-        const persistedSpec = await loadManagedSpecOrUndefined(resolved.hostConfigPath, loadSpec);
+        const currentRuntimeSettings = await resolveAuthoritativeManagedRuntimeSettings(resolved.rootPath, effectiveProcessEnv);
+        const persistedSpec = await loadManagedSpecOrUndefined(resolved.hostConfigPath, (hostConfigPath) => deps.loadSpec
+            ? deps.loadSpec(hostConfigPath)
+            : loadLocalConfigGenerateSpec(hostConfigPath, {
+                env: currentRuntimeSettings.processEnv,
+            }));
         if (!persistedSpec) {
             return { ok: true, present: false };
         }
@@ -1207,27 +1346,13 @@ async function applySpecToRunningManagedDaemon(rootPath, borgeeBaseUrl, spec, se
 }
 export async function applyManagedSpec(options, deps = {}) {
     const effectiveProcessEnv = options.processEnv ?? process.env;
-    const loadSpec = deps.loadSpec
-        ?? ((hostConfigPath) => loadLocalConfigGenerateSpec(hostConfigPath, { env: effectiveProcessEnv }));
-    const materialize = deps.materialize
-        ?? ((rootPath, spec) => materializeLocalConfig(rootPath, spec, { env: effectiveProcessEnv }));
+    const desiredSettings = resolveDesiredManagedRuntimeSettings(effectiveProcessEnv);
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const spawnDaemonProcess = deps.spawnDaemon ?? spawnManagedDaemonProcess;
     const waitForDaemon = deps.waitForDaemonReady ?? waitForManagedDaemonReady;
     const acquireLock = deps.acquireBootstrapLock ?? acquireBootstrapLock;
     const clearManagedRuntimeImpl = deps.clearManagedRuntime ?? clearManagedRuntime;
     const resolved = resolveManagedRuntimeLayoutForServerUrl(options.serverUrl, options.processEnv);
-    let spec;
-    try {
-        spec = validateApplyManagedInput(options.spec, options.serverUrl, effectiveProcessEnv);
-    }
-    catch (error) {
-        if (isManagedOperationError(error)) {
-            return toManagedErrorResponse(error);
-        }
-        return toManagedErrorResponse(managedOperationError('MANAGED_SPEC_INVALID', `Invalid managed spec: ${toErrorMessage(error)}`));
-    }
-    const desiredSettings = resolveDesiredManagedRuntimeSettings(effectiveProcessEnv);
     const waitForShutdown = deps.waitForShutdown
         ?? (async (rootPath) => {
             await waitForManagedDaemonShutdown(rootPath, canConnectToSocket);
@@ -1240,6 +1365,32 @@ export async function applyManagedSpec(options, deps = {}) {
         return toApplyManagedColdStartErrorResponse(error);
     }
     try {
+        const currentRuntimeSettings = await resolveAuthoritativeManagedRuntimeSettings(resolved.rootPath, effectiveProcessEnv);
+        const loadSpecWithCurrentRuntimeEnv = (hostConfigPath) => deps.loadSpec
+            ? deps.loadSpec(hostConfigPath)
+            : loadLocalConfigGenerateSpec(hostConfigPath, {
+                env: currentRuntimeSettings.processEnv,
+            });
+        const materializeWithDesiredEnv = (rootPath, nextSpec) => deps.materialize
+            ? deps.materialize(rootPath, nextSpec)
+            : materializeLocalConfig(rootPath, nextSpec, {
+                env: effectiveProcessEnv,
+            });
+        const materializeWithCurrentRuntimeEnv = (rootPath, nextSpec) => deps.materialize
+            ? deps.materialize(rootPath, nextSpec)
+            : materializeLocalConfig(rootPath, nextSpec, {
+                env: currentRuntimeSettings.processEnv,
+            });
+        let spec;
+        try {
+            spec = validateApplyManagedInput(options.spec, options.serverUrl, effectiveProcessEnv);
+        }
+        catch (error) {
+            if (isManagedOperationError(error)) {
+                return toManagedErrorResponse(error);
+            }
+            return toManagedErrorResponse(managedOperationError('MANAGED_SPEC_INVALID', `Invalid managed spec: ${toErrorMessage(error)}`));
+        }
         let statusResponse;
         try {
             statusResponse = await readReadyManagedDaemonStatus(resolved.rootPath, sendRequest);
@@ -1250,7 +1401,8 @@ export async function applyManagedSpec(options, deps = {}) {
             }
             throw error;
         }
-        if (statusResponse && getManagedRuntimeFingerprintMismatch(statusResponse, desiredSettings)) {
+        if (statusResponse
+            && await getManagedRuntimeFingerprintMismatch(resolved.rootPath, statusResponse, desiredSettings)) {
             try {
                 await recycleManagedDaemonWithDesiredSettings({
                     rootPath: resolved.rootPath,
@@ -1273,7 +1425,7 @@ export async function applyManagedSpec(options, deps = {}) {
         }
         let previousSpec;
         try {
-            previousSpec = await loadManagedSpecOrUndefined(resolved.hostConfigPath, loadSpec);
+            previousSpec = await loadManagedSpecOrUndefined(resolved.hostConfigPath, loadSpecWithCurrentRuntimeEnv);
             if (previousSpec) {
                 assertManagedSpecBinding(previousSpec, options.serverUrl);
             }
@@ -1282,10 +1434,10 @@ export async function applyManagedSpec(options, deps = {}) {
             return toApplyManagedColdStartErrorResponse(error);
         }
         try {
-            await materialize(resolved.rootPath, cloneLocalConfigGenerateSpec(spec));
+            await materializeWithDesiredEnv(resolved.rootPath, cloneLocalConfigGenerateSpec(spec));
         }
         catch (error) {
-            return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, materialize, clearManagedRuntimeImpl, error);
+            return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, currentRuntimeSettings.persistedSettingsSnapshot ?? undefined, materializeWithCurrentRuntimeEnv, clearManagedRuntimeImpl, error);
         }
         try {
             await startManagedDaemonWithPersistedSettings({
@@ -1300,7 +1452,7 @@ export async function applyManagedSpec(options, deps = {}) {
             const status = await sendRequest(resolved.rootPath, { type: 'status' });
             if (!status.ok) {
                 const managedError = getManagedErrorPayload(status);
-                return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, materialize, clearManagedRuntimeImpl, managedOperationError(managedError.code, managedError.message));
+                return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, currentRuntimeSettings.persistedSettingsSnapshot ?? undefined, materializeWithCurrentRuntimeEnv, clearManagedRuntimeImpl, managedOperationError(managedError.code, managedError.message));
             }
             if (status.type !== 'status') {
                 throw new Error('Unexpected managed daemon response for status');
@@ -1314,7 +1466,7 @@ export async function applyManagedSpec(options, deps = {}) {
             };
         }
         catch (error) {
-            return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, materialize, clearManagedRuntimeImpl, error);
+            return rollbackManagedApplyFailure(resolved.rootPath, previousSpec, currentRuntimeSettings.persistedSettingsSnapshot ?? undefined, materializeWithCurrentRuntimeEnv, clearManagedRuntimeImpl, error);
         }
     }
     finally {
@@ -1350,9 +1502,7 @@ export class ManagedAgentsHostDaemon {
         this.loadSpec = deps.loadSpec ?? loadLocalConfigGenerateSpec;
         this.materialize = deps.materialize ?? materializeLocalConfig;
         const managedRuntimeSettings = resolveDesiredManagedRuntimeSettings(process.env);
-        this.managedRuntimeFingerprint = managedRuntimeSettings.convergenceEnabled
-            ? managedRuntimeSettings.fingerprint
-            : null;
+        this.managedRuntimeFingerprint = managedRuntimeSettings.fingerprint;
         this.logger = deps.logger ?? console;
         this.logPath = deps.logPath ?? null;
         this.server = createServer((socket) => {

package/dist/providers/claude/cli-client.d.ts

@@ -1,19 +1,25 @@
 import spawn from 'cross-spawn';
+import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
 import { type DebugLogger } from '../../debug.js';
 import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
-interface ClaudeCliRuntime {
+interface ClaudeAcpRuntime {
     spawn: typeof spawn;
+    client: typeof client;
+    ndJsonStream: typeof ndJsonStream;
+    methods: typeof methods;
+    protocolVersion: typeof PROTOCOL_VERSION;
     cwd: string;
+    shutdownGracePeriodMs: number;
+    shutdownForceKillWaitMs: number;
 }
 /**
- * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
- * native provider-session continuity.
+ * Persistent ACP-backed client for the Claude ACP adapter.
  *
- * Claude session memory remains entirely inside the Claude CLI. This client
- * only pins one native session id per routed provider session and serializes
- * turns per route so `--resume` is never called concurrently for the same
- * native session.
+ * The public caller surface intentionally stays stable: callers still create a
+ * `ClaudeCliClient`, then call `generateReply()` and `dispose()`. Internally,
+ * the shipped runtime now runs one Claude ACP adapter process and reuses one
+ * ACP session per routed Borgee channel.
  */
 export declare class ClaudeCliClient {
     private readonly command;
@@ -24,28 +30,61 @@ export declare class ClaudeCliClient {
     private readonly runtime;
     private readonly channels;
     private readonly persistedSessions;
+    private readonly closingSessions;
+    private readonly pendingSessionStarts;
+    private readonly pendingSessionCloses;
+    private readonly pendingSessionStoreOperations;
+    private readonly fatalPromise;
+    private rejectFatalPromise;
+    private child?;
+    private connection?;
+    private startPromise?;
+    private shutdownPromise?;
+    private childExitPromise?;
+    private resolveChildExit?;
+    private fatalError;
+    private disposing;
+    private backendClosed;
     private loadedSessionStoreAgentId;
-    private stopped;
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
-    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    private sessionCapabilities;
+    private childStderr;
+    constructor(command: string, args?: string[], runtimeOverrides?: Partial<ClaudeAcpRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
+    private ensureStarted;
+    private startBackend;
     private getOrCreateChannelState;
     private processChannelQueue;
+    private getOrCreateSession;
+    private startFreshSession;
+    private restoreOrCreateSession;
+    private restoreSession;
+    private clearBufferedSessionReplay;
+    private resolveSessionCwd;
+    private recycleSessionIfScopeChanged;
     private runTurn;
-    private runTurnAttempt;
+    private raceWithFatal;
+    private failAll;
+    private handlePermissionRequest;
+    private invalidateSession;
+    private closeSession;
+    private rejectQueuedTurnsAfterSessionTaint;
+    private findChannelIdBySessionId;
     private currentSessionStoreAgentId;
     private ensureSessionStoreLoaded;
-    private hydrateChannelState;
+    private readPersistedSessionId;
     private persistSession;
     private persistSessionBestEffort;
-    private resetPersistedSession;
-    private resolveTurnCwd;
-    private resetSessionIfCwdChanged;
-    private resetPersistedSessionBestEffort;
+    private clearPersistedSession;
+    private clearPersistedSessionBestEffort;
     private enqueueSessionStoreWrite;
-    private run;
+    private trackSessionStoreOperation;
+    private shutdownBackend;
+    private waitForPendingSessionStarts;
+    private waitForPendingSessionCloses;
+    private waitForChildExit;
 }
 export {};