@livedesk/client 0.1.203 → 0.1.205

package/bin/livedesk-client-node.js

@@ -19,15 +19,13 @@ const AGENT_VERSION = (() => {
 const PRODUCT_VERSION = String(process.env.LIVEDESK_NPM_LAUNCHER_VERSION || AGENT_VERSION).trim() || AGENT_VERSION;
 const DEFAULT_MANAGER = '127.0.0.1:5197';
 const DEFAULT_HEARTBEAT_MS = 5000;
-const DEFAULT_RECONNECT_MS = 5000;
-const EXIT_INVALID_PAIR_TOKEN = 23;
-const EXIT_CLIENT_UPDATE = 42;
-const DEFAULT_AI_MODEL = 'gpt-5.4-mini';
-const DEFAULT_LIVE_FPS = 30;
-const MAX_LIVE_FPS = 30;
-const MAX_FRAME_BASE64_CHARS = 3 * 1024 * 1024;
-const MAX_AI_OUTPUT_CHARS = 6000;
-const MAX_FILE_TRANSFER_FILES = 24;
+const DEFAULT_RECONNECT_MS = 5000;
+const EXIT_INVALID_PAIR_TOKEN = 23;
+const EXIT_CLIENT_UPDATE = 42;
+const DEFAULT_LIVE_FPS = 30;
+const MAX_LIVE_FPS = 30;
+const MAX_FRAME_BASE64_CHARS = 3 * 1024 * 1024;
+const MAX_FILE_TRANSFER_FILES = 24;
 const MAX_FILE_TRANSFER_BYTES = 24 * 1024 * 1024;
 const MAX_AGENT_OUTPUT_CHARS = 32000;
 const launchedProcessRegistry = new Map();
@@ -281,14 +279,10 @@ Options:
   --no-thumbnail         Disable thumbnail capture capability.
   --live                 Enable focused live screen streaming. Default on.
   --no-live              Disable focused live screen streaming.
-  --tasks                Enable safe remote task inbox. Default on.
-  --no-tasks             Disable remote task dispatch capability.
-  --files-dir <path>     Default folder for received files. Default: ~/Desktop/LiveDeskFiles.
-  --ai                   Enable OpenAI-backed remote AI assist tasks.
-  --no-ai                Disable OpenAI-backed remote AI assist tasks.
-  --ai-model <model>     OpenAI model for AI assist. Default: ${DEFAULT_AI_MODEL}
-  --fake-ai              Use deterministic AI assist responses for smoke tests.
-  --fake-thumbnail       Use generated thumbnail frames for smoke tests.
+  --tasks                Enable safe remote task inbox. Default on.
+  --no-tasks             Disable remote task dispatch capability.
+  --files-dir <path>     Default folder for received files. Default: ~/Desktop/LiveDeskFiles.
+  --fake-thumbnail       Use generated thumbnail frames for smoke tests.
   --exit-on-disconnect   Exit after Hub disconnect. Useful for tests.
   --exit-on-invalid-pair Exit when the Hub rejects the pair token.
   --once                 Connect, send one status packet, and exit after welcome.
@@ -328,14 +322,10 @@ function parseArgs(argv) {
         heartbeatMs: DEFAULT_HEARTBEAT_MS,
         deviceId: '',
         thumbnailEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_THUMBNAIL ?? process.env.MINDEXEC_REMOTE_THUMBNAIL),
-        liveEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_LIVE ?? process.env.MINDEXEC_REMOTE_LIVE),
-        taskEnabled: !isFalsy(process.env.LIVEDESK_CLIENT_TASKS ?? process.env.MINDEXEC_REMOTE_TASKS),
-        filesDir: process.env.LIVEDESK_CLIENT_FILES_DIR || process.env.MINDEXEC_REMOTE_FILES_DIR || '',
-        aiEnabled: isTruthy(process.env.LIVEDESK_CLIENT_AI || process.env.MINDEXEC_REMOTE_AI),
-        aiModel: process.env.LIVEDESK_CLIENT_AI_MODEL || process.env.MINDEXEC_REMOTE_AI_MODEL || process.env.OPENAI_MODEL || DEFAULT_AI_MODEL,
-        openAiApiKey: process.env.OPENAI_API_KEY || '',
-        fakeAi: isTruthy(process.env.LIVEDESK_CLIENT_FAKE_AI || process.env.MINDEXEC_REMOTE_FAKE_AI),
-        fakeThumbnail: isTruthy(process.env.LIVEDESK_CLIENT_FAKE_THUMBNAIL || process.env.MINDEXEC_REMOTE_FAKE_THUMBNAIL),
+        liveEnabled: defaultDesktopCaptureEnabled && !isFalsy(process.env.LIVEDESK_CLIENT_LIVE ?? process.env.MINDEXEC_REMOTE_LIVE),
+        taskEnabled: !isFalsy(process.env.LIVEDESK_CLIENT_TASKS ?? process.env.MINDEXEC_REMOTE_TASKS),
+        filesDir: process.env.LIVEDESK_CLIENT_FILES_DIR || process.env.MINDEXEC_REMOTE_FILES_DIR || '',
+        fakeThumbnail: isTruthy(process.env.LIVEDESK_CLIENT_FAKE_THUMBNAIL || process.env.MINDEXEC_REMOTE_FAKE_THUMBNAIL),
         exitOnDisconnect: false,
         exitOnInvalidPair: false,
         once: false,
@@ -387,26 +377,11 @@ function parseArgs(argv) {
             case '--no-tasks':
                 result.taskEnabled = false;
                 break;
-            case '--files-dir':
-                result.filesDir = args[++index] || result.filesDir;
-                break;
-            case '--ai':
-                result.aiEnabled = true;
-                result.taskEnabled = true;
-                break;
-            case '--no-ai':
-                result.aiEnabled = false;
-                break;
-            case '--ai-model':
-                result.aiModel = args[++index] || result.aiModel;
-                break;
-            case '--fake-ai':
-                result.fakeAi = true;
-                result.aiEnabled = true;
-                result.taskEnabled = true;
-                break;
-            case '--fake-thumbnail':
-                result.fakeThumbnail = true;
+            case '--files-dir':
+                result.filesDir = args[++index] || result.filesDir;
+                break;
+            case '--fake-thumbnail':
+                result.fakeThumbnail = true;
                 result.thumbnailEnabled = true;
                 break;
             case '--exit-on-disconnect':
@@ -586,7 +561,7 @@ function getStatus(options = {}) {
         usedMemRatio,
         platform: os.platform(),
         release: os.release(),
-        role: options.aiEnabled ? 'Agent worker' : options.taskEnabled ? 'Task worker' : 'Local machine',
+        role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
         cpu: {
             cores: cpuCores,
             model: cpus[0]?.model || '',
@@ -609,9 +584,9 @@ function getStatus(options = {}) {
         gpu: acceleratorStatus.gpu,
         npu: acceleratorStatus.npu,
         network: getNetworkStatus(),
-        workload: {
-            role: options.aiEnabled ? 'Agent worker' : options.taskEnabled ? 'Task worker' : 'Local machine',
-            status: 'idle',
+        workload: {
+            role: options.taskEnabled ? 'Command-ready Client' : 'Local machine',
+            status: 'idle',
             title: 'idle'
         },
         timestamp: new Date().toISOString()
@@ -941,95 +916,17 @@ async function captureThumbnailFrame(options, payload, frameSeq) {
     return await captureScreenFrame(options, payload, frameSeq, 'thumbnail');
 }
 
-function normalizeApprovalLevel(value) {
-    const level = String(value || 'task-only').trim().toLowerCase();
-    return level === 'ai-assist' ? 'ai-assist' : 'task-only';
-}
-
-function buildAiPrompt(options, payload, instruction) {
-    const title = String(payload?.title || 'Remote AI task').trim();
-    return [
-        'You are the LiveDesk client AI assistant running on a controlled remote computer.',
-        'Complete the LiveDesk Hub task as a text-only assistant.',
-        'Do not claim you used shell commands, file writes, browser automation, keyboard input, or mouse input.',
-        'If the task requires external side effects, explain what would be needed and stop.',
-        '',
-        `Device: ${options.name} (${os.hostname()}, ${os.platform()} ${os.release()}, ${os.arch()})`,
-        `Task title: ${title}`,
-        '',
-        'Hub instruction:',
-        instruction
-    ].join('\n');
-}
-
-function extractResponseText(response) {
-    if (typeof response?.output_text === 'string' && response.output_text.trim()) {
-        return response.output_text.trim();
-    }
-
-    const parts = [];
-    if (Array.isArray(response?.output)) {
-        for (const item of response.output) {
-            if (!Array.isArray(item?.content)) {
-                continue;
-            }
-
-            for (const content of item.content) {
-                if (typeof content?.text === 'string') {
-                    parts.push(content.text);
-                }
-                if (typeof content?.output_text === 'string') {
-                    parts.push(content.output_text);
-                }
-            }
-        }
-    }
-
-    return parts.join('\n').trim();
-}
-
-async function runAiAssistTask(options, payload, instruction) {
-    if (!options.aiEnabled) {
-        throw new Error('AI assist capability is disabled. Start the agent with --ai to enable it.');
-    }
-
-    if (options.fakeAi) {
-        return {
-            text: [
-                `Fake AI assist completed on ${options.name}.`,
-                '',
-                `Instruction: ${instruction.slice(0, 500)}`,
-                '',
-                'No shell, file, input, browser, or persistent side effects were performed.'
-            ].join('\n'),
-            model: 'fake-ai',
-            responseId: `fake-ai-${String(payload?.taskId || crypto.randomUUID()).slice(0, 96)}`
-        };
-    }
-
-    if (!options.openAiApiKey) {
-        throw new Error('OPENAI_API_KEY is required for --ai remote tasks.');
-    }
-
-    const openaiModule = await import('openai');
-    const OpenAI = openaiModule.default || openaiModule.OpenAI;
-    const client = new OpenAI({ apiKey: options.openAiApiKey });
-    const model = String(payload?.model || options.aiModel || DEFAULT_AI_MODEL).trim() || DEFAULT_AI_MODEL;
-    const response = await client.responses.create({
-        model,
-        input: buildAiPrompt(options, payload, instruction)
-    });
-    const text = extractResponseText(response);
-    if (!text) {
-        throw new Error('AI assist returned no text output.');
-    }
-
-    return {
-        text: text.slice(0, MAX_AI_OUTPUT_CHARS),
-        model,
-        responseId: response?.id || ''
-    };
-}
+const RETIRED_CLIENT_AGENT_TASK_ERROR = 'agent-ai-assist-retired';
+
+function getRetiredClientAgentTaskError(payload = {}) {
+    const source = payload && typeof payload === 'object' ? payload : {};
+    const approvalLevel = String(source.approvalLevel || '').trim().toLowerCase();
+    const hasModelSelection = ['model', 'aiModel', 'aiProvider', 'provider']
+        .some(key => Object.prototype.hasOwnProperty.call(source, key));
+    return approvalLevel === 'ai-assist' || hasModelSelection
+        ? RETIRED_CLIENT_AGENT_TASK_ERROR
+        : '';
+}
 
 function clampInteger(value, min, max, fallback) {
     const number = Number(value);
@@ -1846,10 +1743,25 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
                 error: 'remote task capability is disabled'
             });
             return;
-        }
-
-        const payload = message.payload || {};
-        const instruction = String(payload.instruction || '').replace(/\0/g, '').trim().slice(0, 4000);
+        }
+
+        const payload = message.payload || {};
+        const retiredTaskError = getRetiredClientAgentTaskError(payload);
+        if (retiredTaskError) {
+            writeJsonLine(socket, {
+                type: 'command.result',
+                commandId: message.commandId,
+                error: retiredTaskError,
+                result: {
+                    ok: false,
+                    status: 'failed',
+                    error: retiredTaskError,
+                    completedAt: new Date().toISOString()
+                }
+            });
+            return;
+        }
+        const instruction = String(payload.instruction || '').replace(/\0/g, '').trim().slice(0, 4000);
         if (!instruction) {
             writeJsonLine(socket, {
                 type: 'command.result',
@@ -1859,43 +1771,13 @@ async function handleRemoteCommand(socket, options, message, nextFrameSeq, activ
             return;
         }
 
-        const approvalLevel = normalizeApprovalLevel(payload.approvalLevel);
-        const completedAt = new Date().toISOString();
-        const title = String(payload.title || instruction.split(/\r?\n/)[0] || 'Remote task')
-            .replace(/[\r\n\t]/g, ' ')
-            .trim()
-            .slice(0, 120);
-        if (approvalLevel === 'ai-assist') {
-            try {
-                const aiResult = await runAiAssistTask(options, payload, instruction);
-                writeJsonLine(socket, {
-                    type: 'command.result',
-                    commandId: message.commandId,
-                    result: {
-                        kind: 'agent.task',
-                        mode: 'ai-assist',
-                        taskId: String(payload.taskId || '').slice(0, 128),
-                        title,
-                        status: 'completed',
-                        summary: aiResult.text,
-                        sideEffects: 'none',
-                        model: aiResult.model,
-                        responseId: aiResult.responseId,
-                        instructionPreview: instruction.slice(0, 320),
-                        completedAt: new Date().toISOString()
-                    }
-                });
-            } catch (error) {
-                writeJsonLine(socket, {
-                    type: 'command.result',
-                    commandId: message.commandId,
-                    error: error?.message || String(error)
-                });
-            }
-            return;
-        }
-
-        writeJsonLine(socket, {
+        const completedAt = new Date().toISOString();
+        const title = String(payload.title || instruction.split(/\r?\n/)[0] || 'Remote task')
+            .replace(/[\r\n\t]/g, ' ')
+            .trim()
+            .slice(0, 120);
+
+        writeJsonLine(socket, {
             type: 'command.result',
             commandId: message.commandId,
             result: {
@@ -2140,14 +2022,11 @@ function connectOnce(options, deviceId) {
                     taskDispatch: options.taskEnabled,
                     clientUpdate: true,
                     productVersion: PRODUCT_VERSION,
-                    agentApproval: options.taskEnabled,
-                    agentAudit: options.taskEnabled,
-                    agentTools: [...NODE_AGENT_OPERATIONS],
-                    elevation: typeof process.getuid === 'function' ? process.getuid() === 0 : false,
-                    aiAssist: options.taskEnabled && options.aiEnabled && (options.fakeAi || !!options.openAiApiKey),
-                    aiModel: options.aiModel,
-                    aiProvider: options.fakeAi ? 'fake' : (options.openAiApiKey ? 'openai' : ''),
-                    externalEffects: options.taskEnabled
+                    agentApproval: options.taskEnabled,
+                    agentAudit: options.taskEnabled,
+                    agentTools: [...NODE_AGENT_OPERATIONS],
+                    elevation: typeof process.getuid === 'function' ? process.getuid() === 0 : false,
+                    externalEffects: options.taskEnabled
                 }
             });
         });

package/bin/livedesk-client.js

@@ -39,6 +39,9 @@ const DEFAULT_RELAY_PORT = 5199;
 const DEFAULT_AUTH_CALLBACK_HOST = '127.0.0.1';
 const DEFAULT_AUTH_CALLBACK_PORT = 5179;
 const ENDPOINT_PROBE_TIMEOUT_MS = 900;
+const FRESH_REGISTRY_TIMEOUT_MS = 4000;
+const FRESH_REGISTRY_TIMEOUT_MIN_MS = 25;
+const FRESH_REGISTRY_TIMEOUT_MAX_MS = 10000;
 // Hub-online delivery is an optimization, not a correctness dependency. A
 // browser, proxy, or suspended network can miss the wake event, so registry
 // polling must stay interactive instead of backing off to multi-minute waits.
@@ -49,6 +52,7 @@ const EXIT_INVALID_PAIR_TOKEN = 23;
 const EXIT_CLIENT_UPDATE = 42;
 const SESSION_REFRESH_SKEW_SECONDS = 60;
 const HUB_TARGET_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+const HUB_TARGET_CACHE_FUTURE_SKEW_MS = 5 * 60 * 1000;
 const WINDOWS_STARTUP_SCRIPT_NAME = 'LiveDesk Desktop.vbs';
 const WINDOWS_STARTUP_LEGACY_SCRIPT_NAME = 'LiveDesk Client.vbs';
 const WINDOWS_STARTUP_LEGACY_CMD_NAME = 'LiveDesk Client.cmd';
@@ -67,6 +71,11 @@ const FAST_PREFLIGHT_CACHE_PATH = join(UNIFIED_CLIENT_STATE_DIR, 'fast-preflight
 const CLIENT_SLOT_PATH = join(UNIFIED_CLIENT_STATE_DIR, 'device-slot.json');
 const CLIENT_UPDATE_STATE_PATH = process.env.LIVEDESK_CLIENT_UPDATE_STATE_PATH
     || join(UNIFIED_CLIENT_STATE_DIR, 'client-update.json');
+// Migration-only compatibility: releases before 0.1.204 could persist these
+// Client-side model options in startup/update commands. Consume them without
+// forwarding so an upgrade starts normally, but never restores that feature.
+const RETIRED_CLIENT_MODEL_SINGLE_OPTIONS = new Set(['--ai', '--no-ai', '--fake-ai']);
+const RETIRED_CLIENT_MODEL_VALUE_OPTION = '--ai-model';
 let activeAgentProcess = null;
 let roleRestartRequest = null;
 let agentRestartRequest = null;
@@ -301,8 +310,8 @@ Options:
   --version                       Show the agent version.
   --help                          Show this help.
 
-Auto uses C# RemoteFast when supported and falls back to Node for AI assist or
-when a packaged RemoteFast runtime is unavailable.
+Auto uses C# RemoteFast when supported and falls back to Node only when a
+packaged RemoteFast runtime is unavailable.
 Enable Windows auto-start from the connection page when this client signs in.
 `.trimStart());
 }
@@ -394,15 +403,30 @@ export function parseLauncherArgs(argv) {
     let slot = process.env.LIVEDESK_CLIENT_SLOT || process.env.MINDEXEC_REMOTE_SLOT || '';
     let authPort = normalizePort(process.env.LIVEDESK_CLIENT_RUNTIME_PORT || process.env.LIVEDESK_CLIENT_AUTH_PORT) || DEFAULT_AUTH_CALLBACK_PORT;
     let command = 'connect';
-    let nodeOnlyFeature = false;
-    let fakeThumbnail = false;
+    let fakeThumbnail = false;
     let startupRun = isTruthy(process.env.LIVEDESK_ROLE_TRANSITION);
-    let openBrowserOnStart = !isTruthy(process.env.LIVEDESK_SKIP_BROWSER_OPEN);
-    let updateWaitPid = 0;
-
-    for (let index = 0; index < argv.length; index += 1) {
-        const arg = argv[index];
-        if (arg && !arg.startsWith('-')) {
+    let openBrowserOnStart = !isTruthy(process.env.LIVEDESK_SKIP_BROWSER_OPEN);
+    let updateWaitPid = 0;
+    let retiredModelOptionsDiscarded = 0;
+
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (RETIRED_CLIENT_MODEL_SINGLE_OPTIONS.has(arg)) {
+            retiredModelOptionsDiscarded += 1;
+            continue;
+        }
+        if (arg === RETIRED_CLIENT_MODEL_VALUE_OPTION) {
+            retiredModelOptionsDiscarded += 1;
+            if (index + 1 < argv.length && !String(argv[index + 1] || '').startsWith('-')) {
+                index += 1;
+            }
+            continue;
+        }
+        if (String(arg || '').startsWith(`${RETIRED_CLIENT_MODEL_VALUE_OPTION}=`)) {
+            retiredModelOptionsDiscarded += 1;
+            continue;
+        }
+        if (arg && !arg.startsWith('-')) {
             const lowerArg = arg.toLowerCase();
             const shortcutSlot = normalizeSlotNumber(arg);
             if (lowerArg === 'connect') {
@@ -512,11 +536,8 @@ export function parseLauncherArgs(argv) {
         if (arg === '--version') {
             version = true;
         }
-        if (arg === '--ai' || arg === '--fake-ai' || arg === '--ai-model' || arg === '--no-ai') {
-            nodeOnlyFeature = true;
-        }
-        if (arg === '--fake-thumbnail') {
-            fakeThumbnail = true;
+        if (arg === '--fake-thumbnail') {
+            fakeThumbnail = true;
         }
         forwarded.push(arg);
     }
@@ -539,13 +560,13 @@ export function parseLauncherArgs(argv) {
         deviceId,
         slot,
         authPort,
-        nodeOnlyFeature,
-        fakeThumbnail,
-        startupRun,
-        openBrowserOnStart,
-        updateWaitPid
-    };
-}
+        fakeThumbnail,
+        startupRun,
+        openBrowserOnStart,
+        updateWaitPid,
+        retiredModelOptionsDiscarded
+    };
+}
 
 function normalizePort(value) {
     const port = Number(String(value || '').trim());
@@ -854,13 +875,15 @@ const CLIENT_UPDATE_SINGLE_FLAGS = new Set([
     '--no-open',
     '--exit-on-disconnect',
     '--exit-on-invalid-pair',
-    '--once'
+    '--once',
+    ...RETIRED_CLIENT_MODEL_SINGLE_OPTIONS
 ]);
 const CLIENT_UPDATE_VALUE_FLAGS = new Set([
     '--update-wait-pid',
     // Pairing credentials stay in the inherited private environment and must
     // never be copied onto a replacement process command line.
-    '--pair'
+    '--pair',
+    RETIRED_CLIENT_MODEL_VALUE_OPTION
 ]);
 
 export function buildClientUpdateRestartArgs(prepared = {}) {
@@ -874,6 +897,9 @@ export function buildClientUpdateRestartArgs(prepared = {}) {
         if (arg.startsWith('--pair=')) {
             continue;
         }
+        if (arg.startsWith(`${RETIRED_CLIENT_MODEL_VALUE_OPTION}=`)) {
+            continue;
+        }
         if (CLIENT_UPDATE_VALUE_FLAGS.has(arg)) {
             index += 1;
             continue;
@@ -945,7 +971,9 @@ export function normalizeCachedHubTarget(value, expectedOwnerKey, now = Date.now
         return null;
     }
     const updatedAt = Date.parse(String(cached.updatedAt || ''));
-    if (!Number.isFinite(updatedAt) || now - updatedAt > HUB_TARGET_CACHE_MAX_AGE_MS) {
+    if (!Number.isFinite(updatedAt)
+        || updatedAt > now + HUB_TARGET_CACHE_FUTURE_SKEW_MS
+        || now - updatedAt > HUB_TARGET_CACHE_MAX_AGE_MS) {
         return null;
     }
     const pair = String(cached.pair || '').trim();
@@ -1109,13 +1137,63 @@ function isTransientNetworkError(error) {
     return /fetch failed|network|dns|socket|connection|timeout|getaddrinfo/i.test(getNestedErrorMessage(error));
 }
 
-function formatDiscoveryError(error) {
-    if (isTransientNetworkError(error)) {
-        const code = getNestedErrorCode(error);
-        return `Network is not ready yet${code ? ` (${code})` : ''}. Waiting for DNS/Wi-Fi after sleep.`;
-    }
-    return error instanceof Error ? error.message : String(error);
-}
+function formatDiscoveryError(error) {
+    if (isTransientNetworkError(error)) {
+        const code = getNestedErrorCode(error);
+        return `Network is not ready yet${code ? ` (${code})` : ''}. Waiting for DNS/Wi-Fi after sleep.`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+
+function createHubDiscoveryError(code, message, cause = null) {
+    const error = new Error(message);
+    error.code = String(code || '').trim();
+    if (cause) {
+        error.cause = cause;
+    }
+    return error;
+}
+
+export function canUseCachedRelayAfterRegistryError(error) {
+    const code = getNestedErrorCode(error).toLowerCase();
+    if ([
+        'hub-registry-missing',
+        'hub-registry-expired',
+        'hub-registry-timeout',
+        'pin-not-found',
+        'pin-expired',
+        'resolver-unavailable'
+    ].includes(code)) {
+        return true;
+    }
+    // Semantic registry failures must never be reclassified as network errors
+    // merely because their message mentions a "connection token".
+    if (code.startsWith('hub-registry-')
+        || code.startsWith('pin-registry-')
+        || ['invalid-pin', 'rate-limited', 'request-too-large'].includes(code)) {
+        return false;
+    }
+    return isTransientNetworkError(error);
+}
+
+async function normalizePinResolverInvocationError(error) {
+    if (isTransientNetworkError(error)) {
+        return error;
+    }
+    const response = error?.context;
+    const status = Number(response?.status || 0);
+    let reason = '';
+    try {
+        const payload = await response?.clone?.().json?.();
+        reason = String(payload?.reason || '').trim().toLowerCase();
+    } catch {
+        // HTTP status still gives a conservative semantic classification below.
+    }
+    if (!reason && status === 404) reason = 'pin-not-found';
+    if (!reason && status === 503) reason = 'resolver-unavailable';
+    if (!reason) return error;
+    return createHubDiscoveryError(reason, reason, error);
+}
 
 async function recoverRotatedSession(supabase, previousSession) {
     for (const delayMs of [100, 250, 500]) {
@@ -2618,54 +2696,72 @@ function readRequestBody(req, maxBytes = 4096) {
     });
 }
 
-async function resolveManagerFromPin(supabase, pin, options = {}) {
+export async function resolveManagerFromPin(supabase, pin, options = {}) {
     const normalizedPin = normalizePairingPin(pin);
     if (!normalizedPin) {
         throw new Error('Enter a 6-digit LiveDesk PIN.');
     }
     const cacheOwnerKey = hubCacheOwnerForPin(normalizedPin);
-    const cachedTarget = await resolveManagerFromCachedTarget(cacheOwnerKey);
-    if (cachedTarget) {
-        console.log(`Found cached LiveDesk Hub at ${cachedTarget.manager}.`);
-        return cachedTarget;
-    }
-
-    const { data, error } = await supabase.functions.invoke('livedesk-resolve-remote-host', {
-        body: { pin: normalizedPin }
-    });
-    if (error) {
-        throw error;
-    }
-    const result = Array.isArray(data) ? data[0] : data;
-    if (!result?.ok) {
-        throw new Error(result?.reason || 'pin-not-found');
-    }
-    if (!result.pair_token) {
-        throw new Error('The PIN matched a Hub record without a private connection token.');
-    }
-    const endpointCandidates = normalizeEndpointCandidates(result);
-    if (endpointCandidates.length === 0) {
-        throw new Error('The PIN matched a Hub record without a reachable address.');
-    }
-    const target = await chooseManagerConnectionTarget(endpointCandidates, {
-        allowRelayFallback: options.allowRelayFallback === true
+    const resolved = await resolveManagerWithCachedRecovery(cacheOwnerKey, {
+        allowRelayFallback: options.allowRelayFallback === true,
+        relayEndpoint: options.relayEndpoint,
+        probeEndpoint: options.probeEndpoint,
+        resolveFreshTarget: async () => {
+            const { data, error } = await supabase.functions.invoke('livedesk-resolve-remote-host', {
+                body: { pin: normalizedPin }
+            });
+            if (error) {
+                throw await normalizePinResolverInvocationError(error);
+            }
+            const result = Array.isArray(data) ? data[0] : data;
+            if (!result?.ok) {
+                const reason = String(result?.reason || 'pin-not-found').trim().toLowerCase();
+                throw createHubDiscoveryError(reason, reason);
+            }
+            if (!result.pair_token) {
+                throw createHubDiscoveryError(
+                    'pin-registry-pair-token-missing',
+                    'The PIN matched a Hub record without a private connection token.'
+                );
+            }
+            const endpointCandidates = normalizeEndpointCandidates(result);
+            if (endpointCandidates.length === 0) {
+                throw createHubDiscoveryError(
+                    'pin-registry-endpoints-missing',
+                    'The PIN matched a Hub record without a reachable address.'
+                );
+            }
+            const target = await chooseManagerConnectionTarget(endpointCandidates, {
+                allowRelayFallback: options.allowRelayFallback === true,
+                probeEndpoint: options.probeEndpoint
+            });
+            if (!target) {
+                throw createHubDiscoveryError(
+                    'pin-direct-unreachable',
+                    `No reachable LiveDesk Hub endpoint yet. Checked ${endpointCandidates.join(', ')}.`
+                );
+            }
+            return {
+                manager: target.manager,
+                pair: result.pair_token,
+                hubDeviceId: String(result.node_id || '').trim(),
+                endpointCandidates,
+                directReachable: target.directReachable,
+                connectionTransport: target.connectionTransport,
+                discoverySource: 'supabase'
+            };
+        }
     });
-    if (!target) {
-        throw new Error(`No reachable LiveDesk Hub endpoint yet. Checked ${endpointCandidates.join(', ')}.`);
+    if (resolved.discoverySource === 'supabase') {
+        writeCachedHubTarget(cacheOwnerKey, resolved);
     }
-
-    const resolved = {
-        manager: target.manager,
-        pair: result.pair_token,
-        hubDeviceId: String(result.node_id || '').trim(),
-        endpointCandidates,
-        directReachable: target.directReachable,
-        connectionTransport: target.connectionTransport,
-        discoverySource: 'supabase'
-    };
-    writeCachedHubTarget(cacheOwnerKey, resolved);
+    console.log(resolved.connectionTransport === 'relay-fallback' && resolved.discoverySource === 'cache'
+        ? 'Fresh PIN registry lookup was unavailable; using the saved PIN-bound identity for the bounded encrypted relay path.'
+        : resolved.discoverySource === 'cache'
+            ? `Fresh PIN registry lookup was unavailable; using the responding saved direct Hub endpoint ${resolved.manager}.`
+            : `Found current PIN-bound LiveDesk Hub at ${resolved.manager}.`);
     return resolved;
-}
+}
 
 async function waitForManagerFromSavedPin(supabase, pin, options = {}) {
     const configuredIntervalMs = Number(options.intervalMs || 0);
@@ -2680,7 +2776,8 @@ async function waitForManagerFromSavedPin(supabase, pin, options = {}) {
         attempts += 1;
         try {
             return await resolveManagerFromPin(supabase, pin, {
-                allowRelayFallback: options.allowRelayFallback === true
+                allowRelayFallback: options.allowRelayFallback === true,
+                relayEndpoint: options.relayEndpoint
             });
         } catch (err) {
             if (shouldStop()) {
@@ -2834,9 +2931,11 @@ async function startConnectionChoiceServer(supabase, options = {}) {
         }
         dashboardState.message = 'Saved LiveDesk PIN found. Waiting for the Hub to become reachable.';
         try {
-            const resolved = await waitForManagerFromSavedPin(supabase, savedPin, {
-                shouldStop: () => completed || dashboardState.loggedOut
-            });
+            const resolved = await waitForManagerFromSavedPin(supabase, savedPin, {
+                allowRelayFallback: options.allowRelayFallback === true,
+                relayEndpoint: options.relayEndpoint,
+                shouldStop: () => completed || dashboardState.loggedOut
+            });
             if (!resolved) {
                 return;
             }
@@ -3066,7 +3165,8 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                 pin = normalizePairingPin(pin);
                 try {
                     const resolved = await resolveManagerFromPin(supabase, pin, {
-                        allowRelayFallback: options.allowRelayFallback === true
+                        allowRelayFallback: options.allowRelayFallback === true,
+                        relayEndpoint: options.relayEndpoint
                     });
                     writeSavedPin(pin);
                     applyStartupPreference(pendingStartup, startupArgs);
@@ -3229,7 +3329,8 @@ async function chooseClientConnection(supabase, options = {}) {
             resolvePin: pin => {
                 if (!supabase) throw new Error('supabase-session-required');
                 return resolveManagerFromPin(supabase, pin, {
-                    allowRelayFallback: options.allowRelayFallback === true
+                    allowRelayFallback: options.allowRelayFallback === true,
+                    relayEndpoint: options.relayEndpoint
                 });
             },
             changeRole: async (role, snapshot) => {
@@ -3328,7 +3429,8 @@ async function chooseClientConnection(supabase, options = {}) {
         startupArgs: options.startupArgs,
         savedSession: options.savedSession,
         savedPin: options.savedPin,
-        allowRelayFallback: options.allowRelayFallback === true
+        allowRelayFallback: options.allowRelayFallback === true,
+        relayEndpoint: options.relayEndpoint
     });
     if (options.openBrowser !== false) {
         console.log('Opening LiveDesk connection page...');
@@ -3506,10 +3608,16 @@ export async function chooseManagerConnectionTarget(candidates, options = {}) {
 }
 
 export async function resolveManagerFromCachedTarget(ownerKey, options = {}) {
-    const cached = options.cachedTarget || readCachedHubTarget(ownerKey);
+    const cached = Object.prototype.hasOwnProperty.call(options, 'cachedTarget')
+        ? normalizeCachedHubTarget(options.cachedTarget, ownerKey, options.now)
+        : readCachedHubTarget(ownerKey);
     if (!cached) return null;
-    const manager = await chooseReachableEndpoint(cached.endpointCandidates, { requireReachable: true });
-    if (!manager) return null;
+    const target = await chooseManagerConnectionTarget(cached.endpointCandidates, {
+        allowRelayFallback: false,
+        probeEndpoint: options.probeEndpoint
+    });
+    if (!target) return null;
+    const manager = target.manager;
     const resolved = {
         manager,
         pair: cached.pair,
@@ -3518,6 +3626,8 @@ export async function resolveManagerFromCachedTarget(ownerKey, options = {}) {
             manager,
             ...cached.endpointCandidates.filter(endpoint => endpoint !== manager)
         ],
+        directReachable: target.directReachable,
+        connectionTransport: target.connectionTransport,
         discoverySource: 'cache'
     };
     if (options.persist !== false) {
@@ -3526,6 +3636,86 @@ export async function resolveManagerFromCachedTarget(ownerKey, options = {}) {
     return resolved;
 }
 
+export function resolveManagerFromCachedRelayFallback(ownerKey, options = {}) {
+    if (options.allowRelayFallback !== true) return null;
+    const cached = Object.prototype.hasOwnProperty.call(options, 'cachedTarget')
+        ? normalizeCachedHubTarget(options.cachedTarget, ownerKey, options.now)
+        : readCachedHubTarget(ownerKey);
+    if (!cached) return null;
+    const normalizedOwner = String(cached.ownerKey || '');
+    const accountIdentityComplete = normalizedOwner.startsWith('user:')
+        && normalizedOwner.length > 'user:'.length
+        && Boolean(cached.hubDeviceId);
+    // The public PIN resolver intentionally does not expose node_id. Its
+    // previous signed pair/endpoints remain bound to the exact saved six-digit
+    // PIN owner in the private, finite-lifetime cache.
+    const pinIdentityComplete = /^pin:[0-9]{6}$/.test(normalizedOwner);
+    const relayEndpoint = String(options.relayEndpoint || '').trim().replace(/^tcp:\/\//i, '');
+    if ((!accountIdentityComplete && !pinIdentityComplete) || !parseManagerEndpoint(relayEndpoint)) {
+        return null;
+    }
+    return {
+        manager: cached.endpointCandidates[0],
+        pair: cached.pair,
+        hubDeviceId: cached.hubDeviceId,
+        endpointCandidates: [...cached.endpointCandidates],
+        directReachable: false,
+        connectionTransport: 'relay-fallback',
+        discoverySource: 'cache'
+    };
+}
+
+export async function resolveManagerWithCachedRecovery(ownerKey, options = {}) {
+    const cached = Object.prototype.hasOwnProperty.call(options, 'cachedTarget')
+        ? normalizeCachedHubTarget(options.cachedTarget, ownerKey, options.now)
+        : readCachedHubTarget(ownerKey);
+    try {
+        if (typeof options.resolveFreshTarget !== 'function') {
+            throw createHubDiscoveryError('fresh-registry-resolver-required', 'Fresh Hub registry resolver is required.');
+        }
+        const configuredFreshTimeoutMs = Number(options.freshTimeoutMs);
+        const freshTimeoutMs = Number.isFinite(configuredFreshTimeoutMs)
+            ? Math.max(FRESH_REGISTRY_TIMEOUT_MIN_MS, Math.min(FRESH_REGISTRY_TIMEOUT_MAX_MS, configuredFreshTimeoutMs))
+            : FRESH_REGISTRY_TIMEOUT_MS;
+        let timeoutHandle = null;
+        const fresh = await Promise.race([
+            Promise.resolve().then(() => options.resolveFreshTarget()),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(createHubDiscoveryError(
+                    'hub-registry-timeout',
+                    `Fresh LiveDesk Hub registry lookup exceeded ${freshTimeoutMs}ms.`
+                )), freshTimeoutMs);
+            })
+        ]).finally(() => clearTimeout(timeoutHandle));
+        if (!fresh?.manager || !fresh?.pair) {
+            throw createHubDiscoveryError('fresh-registry-target-invalid', 'Fresh Hub registry target is incomplete.');
+        }
+        return {
+            ...fresh,
+            discoverySource: fresh.discoverySource || 'supabase'
+        };
+    } catch (error) {
+        if (canUseCachedRelayAfterRegistryError(error)) {
+            const direct = await resolveManagerFromCachedTarget(ownerKey, {
+                cachedTarget: cached,
+                probeEndpoint: options.probeEndpoint,
+                // A TCP listener is not pair-token authentication. Only a
+                // fresh signed registry result may extend cache trust.
+                persist: false
+            });
+            if (direct) return direct;
+            const relay = resolveManagerFromCachedRelayFallback(ownerKey, {
+                cachedTarget: cached,
+                allowRelayFallback: options.allowRelayFallback === true,
+                relayEndpoint: options.relayEndpoint,
+                now: options.now
+            });
+            if (relay) return relay;
+        }
+        throw error;
+    }
+}
+
 export function getDiscoveryRetryDelay(attempt, configuredIntervalMs = 0, random = Math.random) {
     const configured = Number(configuredIntervalMs);
     if (Number.isFinite(configured) && configured > 0) {
@@ -3577,34 +3767,50 @@ function normalizeEndpointCandidates(target) {
     return [...new Set(rawCandidates.map(value => String(value || '').trim()).filter(Boolean))];
 }
 
-async function resolveManagerFromSupabase(supabase, options = {}) {
+export async function resolveManagerFromSupabase(supabase, options = {}) {
     await refreshSessionIfNeeded(supabase);
     const { data, error } = await supabase
         .from('livedesk_remote_host_targets')
         .select('node_id, endpoint, endpoint_candidates, pair_token, active, expires_at, updated_at, manager_version')
         .eq('product_key', 'livedesk')
         .maybeSingle();
-    if (error) {
-        throw error;
-    }
-    if (!data?.active) {
-        throw new Error('No active LiveDesk Hub was found for this Google account. Start LiveDesk Hub on the screen wall computer and sign in there first.');
-    }
-    if (data.expires_at && Date.parse(data.expires_at) <= Date.now()) {
-        throw new Error('The LiveDesk Hub record is expired. Open the Hub screen again while signed in.');
-    }
-    if (!data.pair_token) {
-        throw new Error('The LiveDesk Hub record is missing its private connection token.');
-    }
-    const endpointCandidates = normalizeEndpointCandidates(data);
-    if (endpointCandidates.length === 0) {
-        throw new Error('The LiveDesk Hub record does not contain a reachable local address.');
-    }
+    if (error) {
+        throw error;
+    }
+    if (!data?.active) {
+        throw createHubDiscoveryError(
+            'hub-registry-missing',
+            'No active LiveDesk Hub was found for this Google account. Start LiveDesk Hub on the screen wall computer and sign in there first.'
+        );
+    }
+    if (data.expires_at && Date.parse(data.expires_at) <= Date.now()) {
+        throw createHubDiscoveryError(
+            'hub-registry-expired',
+            'The LiveDesk Hub record is expired. Open the Hub screen again while signed in.'
+        );
+    }
+    if (!data.pair_token) {
+        throw createHubDiscoveryError(
+            'hub-registry-pair-token-missing',
+            'The LiveDesk Hub record is missing its private connection token.'
+        );
+    }
+    const endpointCandidates = normalizeEndpointCandidates(data);
+    if (endpointCandidates.length === 0) {
+        throw createHubDiscoveryError(
+            'hub-registry-endpoints-missing',
+            'The LiveDesk Hub record does not contain a reachable local address.'
+        );
+    }
     const target = await chooseManagerConnectionTarget(endpointCandidates, {
-        allowRelayFallback: options.allowRelayFallback === true
+        allowRelayFallback: options.allowRelayFallback === true,
+        probeEndpoint: options.probeEndpoint
     });
     if (!target) {
-        throw new Error(`No reachable LiveDesk Hub endpoint yet. Checked ${endpointCandidates.join(', ')}.`);
+        throw createHubDiscoveryError(
+            'hub-direct-unreachable',
+            `No reachable LiveDesk Hub endpoint yet. Checked ${endpointCandidates.join(', ')}.`
+        );
     }
     return {
         manager: target.manager,
@@ -3647,6 +3853,7 @@ async function waitForManagerFromSupabase(supabase, options = {}) {
     let attempts = 0;
     let lastMessage = '';
     let wakeListener = null;
+    let initialError = options.initialError || null;
     console.log('Waiting for a LiveDesk Hub. LiveDesk is listening for Hub-online events with adaptive registry retries as a fallback.');
     try {
         while (true) {
@@ -3655,6 +3862,11 @@ async function waitForManagerFromSupabase(supabase, options = {}) {
             }
             attempts += 1;
             try {
+                if (initialError) {
+                    const error = initialError;
+                    initialError = null;
+                    throw error;
+                }
                 return await resolveManagerFromSupabase(supabase, {
                     allowRelayFallback: options.allowRelayFallback === true
                 });
@@ -3730,7 +3942,8 @@ async function prepareLoginConnection(parsed, existingConnectionPage = null) {
             choice = { type: 'google', session: savedSession };
         } else if ((parsed.startupRun || existingConnectionPage) && savedPin) {
             const resolved = await waitForManagerFromSavedPin(supabase, savedPin, {
-                allowRelayFallback
+                allowRelayFallback,
+                relayEndpoint: parsed.relay
             });
             choice = { type: 'pin', ...resolved };
         } else if (existingConnectionPage && previousChoice) {
@@ -3747,8 +3960,9 @@ async function prepareLoginConnection(parsed, existingConnectionPage = null) {
                 savedSession,
                 savedPin,
                 allowRelayFallback,
+                relayEndpoint: parsed.relay,
                 openBrowser: parsed.openBrowserOnStart
-            });
+            });
         }
         connectionPage = existingConnectionPage || choice.connectionPage || null;
         if (choice.type === 'pin') {
@@ -3770,26 +3984,39 @@ async function prepareLoginConnection(parsed, existingConnectionPage = null) {
                 : 'Connected by LiveDesk PIN.');
         } else {
             const cacheOwnerKey = hubCacheOwnerForSession(choice.session);
-            let resolved = await resolveManagerFromCachedTarget(cacheOwnerKey);
             let session = choice.session;
-            discoverySource = resolved ? 'cache' : 'supabase';
-            if (resolved) {
-                connectionTransport = resolved.connectionTransport || 'direct-tcp';
-                directReachable = resolved.directReachable !== false;
+            let initialDiscoveryError = null;
+            let resolved = null;
+            try {
+                resolved = await resolveManagerWithCachedRecovery(cacheOwnerKey, {
+                    allowRelayFallback,
+                    relayEndpoint: parsed.relay,
+                    resolveFreshTarget: async () => {
+                        // The signed registry is authoritative for Hub replacement
+                        // and pair-token rotation. Cache direct/relay recovery is
+                        // considered only after this one current lookup reports
+                        // an explicitly recoverable availability failure.
+                        try {
+                            session = await activateSupabaseSession(supabase, choice.session);
+                        } catch (error) {
+                            if (!isRefreshTokenAlreadyUsedError(error)) throw error;
+                            session = readSavedSessionFromFile() || choice.session;
+                            console.warn('[LiveDesk Client] Another auth owner rotated the refresh token. Keeping the runtime alive while the saved session catches up.');
+                        }
+                        return await resolveManagerFromSupabase(supabase, {
+                            allowRelayFallback
+                        });
+                    }
+                });
+            } catch (error) {
+                initialDiscoveryError = error;
+            }
+            discoverySource = resolved?.discoverySource || 'supabase';
+            if (resolved?.discoverySource === 'cache') {
                 writeSavedSessionToFile(session);
-                console.log(`Found cached LiveDesk Hub at ${resolved.manager}; skipped registry discovery.`);
-            } else {
-                // The browser and local runtime are separate auth owners.
-                // Activate the accepted browser session only when registry
-                // discovery is needed; a reachable account-bound cache can
-                // start the Agent without a Supabase round trip.
-                try {
-                    session = await activateSupabaseSession(supabase, choice.session);
-                } catch (error) {
-                    if (!isRefreshTokenAlreadyUsedError(error)) throw error;
-                    session = readSavedSessionFromFile() || choice.session;
-                    console.warn('[LiveDesk Client] Another auth owner rotated the refresh token. Keeping the runtime alive while the saved session catches up.');
-                }
+                console.log(resolved.connectionTransport === 'relay-fallback'
+                    ? `Fresh Hub registry lookup was unavailable; using saved account-bound Hub identity ${resolved.hubDeviceId} for the bounded encrypted relay path.`
+                    : `Fresh Hub registry lookup was unavailable; using the responding saved direct Hub endpoint ${resolved.manager}.`);
             }
             choice.session = session;
             const email = session?.user?.email ? ` as ${session.user.email}` : '';
@@ -3797,18 +4024,20 @@ async function prepareLoginConnection(parsed, existingConnectionPage = null) {
             if (!resolved) {
                 resolved = await waitForManagerFromSupabase(supabase, {
                     allowRelayFallback,
+                    initialError: initialDiscoveryError,
                     shouldStop: () => Boolean(roleRestartRequest?.role)
                 });
+                discoverySource = 'supabase';
             }
             if (!resolved && roleRestartRequest?.role) {
-                return {
-                    ...parsed,
-                    manager,
-                    pair,
-                    slot: normalizeSlotNumber(parsed.slot),
-                    connectionPage,
-                    forwarded,
-                    rediscoverOnDisconnect: shouldLogin,
+                return {
+                    ...parsed,
+                    manager,
+                    pair,
+                    slot: normalizeSlotNumber(parsed.slot),
+                    connectionPage,
+                    forwarded,
+                    rediscoverOnDisconnect: shouldLogin,
                     rediscoverOnInvalidPair: shouldLogin
                 };
             }
@@ -4233,6 +4462,18 @@ export function buildFastArgs(args, fakeThumbnail, transport = 'auto', relay = '
     const forwarded = [];
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
+        if (RETIRED_CLIENT_MODEL_SINGLE_OPTIONS.has(arg)) {
+            continue;
+        }
+        if (arg === RETIRED_CLIENT_MODEL_VALUE_OPTION) {
+            if (index + 1 < args.length && !String(args[index + 1] || '').startsWith('-')) {
+                index += 1;
+            }
+            continue;
+        }
+        if (String(arg || '').startsWith(`${RETIRED_CLIENT_MODEL_VALUE_OPTION}=`)) {
+            continue;
+        }
         if (arg === '--transport' || arg === '--relay') {
             index += 1;
             continue;
@@ -4241,8 +4482,8 @@ export function buildFastArgs(args, fakeThumbnail, transport = 'auto', relay = '
             forwarded.push('--fake-frame');
             continue;
         }
-        if (arg === '--tasks' || arg === '--no-tasks' || arg === '--no-ai') {
-            continue;
+        if (arg === '--tasks' || arg === '--no-tasks') {
+            continue;
         }
         forwarded.push(arg);
     }
@@ -4446,15 +4687,15 @@ function spawnAgent(command, args, env = process.env, onStart = null) {
     });
 }
 
-function shouldUseFast(parsed) {
-    if (parsed.engine === 'node') {
-        return false;
+function shouldUseFast(parsed) {
+    if (parsed.engine === 'node') {
+        return false;
     }
     if (parsed.engine === 'fast') {
         return true;
     }
-    return !parsed.nodeOnlyFeature;
-}
+    return true;
+}
 
 function shouldTryFast(parsed, runtime) {
     if (parsed.engine === 'fast') {
@@ -4480,6 +4721,12 @@ export async function runClientRuntime(argv = process.argv.slice(2)) {
         console.warn('[LiveDesk] @livedesk/client is deprecated. Use the unified livedesk package or LiveDesk Desktop.');
     }
     const parsed = parseLauncherArgs(argv);
+    if (parsed.retiredModelOptionsDiscarded > 0) {
+        console.warn(
+            '[LiveDesk Client] Ignored retired Client model-runtime options. '
+            + 'Approved AI computer commands are handled by the Hub Codex Agent.'
+        );
+    }
     if (parsed.updateWaitPid) {
         await waitForProcessExit(parsed.updateWaitPid);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.203",
+  "version": "0.1.205",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -37,14 +37,13 @@
     "@livedesk/runtime-core": "0.1.0",
     "@supabase/supabase-js": "^2.110.0",
     "node-screenshots": "^0.2.8",
-    "openai": "^6.42.0",
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.411",
-    "@livedesk/fast-osx-arm64": "0.1.411",
-    "@livedesk/fast-osx-x64": "0.1.411",
-    "@livedesk/fast-win-x64": "0.1.411"
+    "@livedesk/fast-linux-x64": "0.1.412",
+    "@livedesk/fast-osx-arm64": "0.1.412",
+    "@livedesk/fast-osx-x64": "0.1.412",
+    "@livedesk/fast-win-x64": "0.1.412"
   },
   "publishConfig": {
     "access": "public"