@livedesk/hub 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",

package/src/agents/agent-manager.js

@@ -1,175 +1,123 @@
-import os from 'node:os';
-import path from 'node:path';
-import { AgentSettingsStore, AGENT_PROVIDER_CODEX, AGENT_PROVIDER_OPENCODE_GO } from './agent-settings.js';
-import { createOsSecretStore } from './secret-store.js';
-import { createOpenCodeGoProvider } from './opencode-go-provider.js';
-import { AgentProviderError } from './provider-errors.js';
-import { createCodexAgentRuntime } from './codex-agent-runtime.js';
-
-function maskApiKey(value) {
-  const key = String(value || '');
-  return key.length >= 4 ? `••••${key.slice(-4)}` : '';
-}
-
-function publicCodexStatus(status = {}) {
-  return {
-    installed: status.installed === true,
-    authenticated: ['signed-in', 'not-signed-in'].includes(status.authenticated) ? status.authenticated : 'unknown',
-    status: String(status.status || 'unknown').slice(0, 40),
-    codexPath: String(status.codexPath || '').slice(0, 500),
-    detail: String(status.detail || '').slice(0, 300)
-  };
-}
-
-export function createAgentManager({
-  dataDir = path.join(os.homedir(), '.livedesk'),
-  settingsStore,
-  secretStore,
-  provider,
-  codexRuntime
-} = {}) {
-  const settings = settingsStore || new AgentSettingsStore({ dataDir });
-  const secrets = secretStore || createOsSecretStore({ dataDir });
-  const legacyProvider = provider || createOpenCodeGoProvider();
-  const runtime = codexRuntime;
-  let statusCache = { expiresAt: 0, value: null };
-
-  async function getCodexStatus() {
-    if (!runtime) return { installed: false, authenticated: 'unknown', status: 'unavailable', codexPath: '' };
-    if (statusCache.value && statusCache.expiresAt > Date.now()) return statusCache.value;
-    let value;
-    try {
-      value = publicCodexStatus(await runtime.getStatus());
-    } catch (error) {
-      value = publicCodexStatus({ installed: true, authenticated: 'unknown', status: error?.code || 'security-unavailable', detail: error?.message || 'Codex security isolation is unavailable.' });
-    }
-    statusCache = { value, expiresAt: Date.now() + 10000 };
-    return value;
-  }
-
-  async function publicSettings() {
-    const current = await settings.get();
-    const { codexMaxTurns: _codexMaxTurns, ...exposedSettings } = current;
-    let hasApiKey = false;
-    let apiKeyPreview = '';
-    let secretStoreAvailable = true;
-    if (current.provider === AGENT_PROVIDER_OPENCODE_GO) {
-      try {
-        const key = await secrets.getApiKey(AGENT_PROVIDER_OPENCODE_GO);
-        hasApiKey = Boolean(key);
-        apiKeyPreview = maskApiKey(key);
-      } catch {
-        secretStoreAvailable = false;
-      }
-    }
-    const codex = await getCodexStatus();
-    const securityStatus = runtime?.getSecurityStatus?.() || {
-      isolatedCodexHome: false,
-      restrictedEnvironment: false,
-      livedeskMcpOnly: false,
-      selectedDeviceScopeEnforced: false,
-      failClosed: true,
-      verified: false,
-      state: 'unavailable'
-    };
-    return {
-      ...exposedSettings,
-      hasApiKey,
-      apiKeyPreview,
-      secretStoreAvailable,
-      codexInstallation: codex.installed ? 'installed' : 'not-installed',
-      codexAuth: codex.authenticated,
-      codexStatus: codex.status,
-      codexPath: codex.codexPath,
-      agentWorkspacePath: current.codexWorkingDirectory,
-      securityStatus
-    };
-  }
-
-  async function legacyApiKey() {
-    const key = await secrets.getApiKey(AGENT_PROVIDER_OPENCODE_GO);
-    if (!key) throw new AgentProviderError('agent-api-key-missing', 'OpenCode Go API key is not configured.', { status: 401 });
-    return key;
-  }
-
-  async function currentProvider() {
-    const current = await settings.get();
-    return { current, active: current.provider === AGENT_PROVIDER_CODEX ? runtime : legacyProvider };
-  }
-
-  return {
-    getSettings: publicSettings,
-    async updateSettings(patch = {}) {
-      const nextPatch = { ...patch };
-      const apiKey = typeof nextPatch.apiKey === 'string' ? nextPatch.apiKey.trim() : '';
-      delete nextPatch.apiKey;
-      const current = await settings.get();
-      const requestedProvider = String(nextPatch.provider || current.provider);
-      if (apiKey) {
-        if (requestedProvider !== AGENT_PROVIDER_OPENCODE_GO) {
-          throw new AgentProviderError('agent-codex-does-not-use-api-key', 'Codex authentication is owned by the installed Codex CLI.', { status: 400 });
-        }
-        await secrets.setApiKey(AGENT_PROVIDER_OPENCODE_GO, apiKey);
-      }
-      await settings.update(nextPatch);
-      statusCache = { expiresAt: 0, value: null };
-      return publicSettings();
-    },
-    async resetSettings() {
-      await settings.reset();
-      statusCache = { expiresAt: 0, value: null };
-      return publicSettings();
-    },
-    async deleteApiKey() {
-      await secrets.deleteApiKey(AGENT_PROVIDER_OPENCODE_GO);
-      return publicSettings();
-    },
-    async getModels() {
-      const { current, active } = await currentProvider();
-      if (current.provider === AGENT_PROVIDER_CODEX) {
-        return [{ id: '', name: 'Codex default', protocol: 'codex-sdk', available: true, capabilities: { supportsReasoningLevel: true, supportsStreaming: true, supportsTools: true } }];
-      }
-      return active.getModels(current, await legacyApiKey());
-    },
-    async testConnection() {
-      const { current, active } = await currentProvider();
-      if (current.provider === AGENT_PROVIDER_CODEX) {
-        if (!active) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
-        statusCache = { expiresAt: 0, value: null };
-        return active.testConnection();
-      }
-      return active.testConnection(current, await legacyApiKey());
-    },
-    async createPlan(input) {
-      const { current, active } = await currentProvider();
-      if (!current.enabled) throw new AgentProviderError('agent-ai-disabled', 'Agent AI is disabled in Settings.', { status: 409 });
-      if (current.provider === AGENT_PROVIDER_CODEX) {
-        throw new AgentProviderError('agent-codex-run-required', 'Codex runs use the LiveDesk tool loop.', { status: 409 });
-      }
-      return active.createPlan(input, current, await legacyApiKey());
-    },
-    async createSummary(input) {
-      const { current, active } = await currentProvider();
-      if (!current.enabled || !current.generateSummary) throw new AgentProviderError('agent-summary-disabled', 'Agent summaries are disabled in Settings.', { status: 409 });
-      if (current.provider === AGENT_PROVIDER_CODEX) {
-        const source = input && typeof input === 'object' ? input : {};
-        const results = Array.isArray(source.results) ? source.results : [];
-        return { summary: String(results.length ? `${source.completed || 0} completed, ${source.failed || 0} failed.` : 'LiveDesk Agent run completed.').slice(0, 1200), modelId: current.codexModelId || 'Codex default' };
-      }
-      const source = input && typeof input === 'object' ? input : {};
-      const results = Array.isArray(source.results) ? source.results : [];
-      const safeResults = current.includeRawDeviceDetails
-        ? results.map(result => ({ deviceName: String(result?.deviceName || '').slice(0, 120), status: String(result?.status || '').slice(0, 40), result: String(result?.result || '').slice(0, 1200), error: String(result?.error || '').slice(0, 500) }))
-        : results.map(result => ({ deviceName: String(result?.deviceName || '').slice(0, 120), status: String(result?.status || '').slice(0, 40), hasResult: Boolean(result?.result), hasError: Boolean(result?.error) }));
-      return active.createSummary({ instruction: String(source.instruction || '').slice(0, 500), operation: String(source.operation || '').slice(0, 80), summary: { total: Number(source.total || results.length), completed: Number(source.completed || 0), failed: Number(source.failed || 0), results: safeResults } }, current, await legacyApiKey());
-    },
-    async startRun(input) {
-      const current = await settings.get();
-      if (current.provider !== AGENT_PROVIDER_CODEX || !runtime) throw new AgentProviderError('agent-codex-not-active', 'Codex SDK is not the active Agent provider.', { status: 409 });
-      return runtime.start(input);
-    },
-    getRun(runId) { return runtime?.get(runId) || null; },
-    cancelRun(runId) { return runtime?.cancel(runId) || null; },
-    cancelAllRuns() { return runtime?.cancelAll?.() || 0; }
-  };
-}
+import os from 'node:os';
+import path from 'node:path';
+import { AgentSettingsStore, AGENT_PROVIDER_CODEX } from './agent-settings.js';
+import { AgentProviderError } from './provider-errors.js';
+
+function publicCodexStatus(status = {}) {
+  return {
+    installed: status.installed === true,
+    authenticated: ['signed-in', 'not-signed-in'].includes(status.authenticated) ? status.authenticated : 'unknown',
+    status: String(status.status || 'unknown').slice(0, 40),
+    codexPath: String(status.codexPath || '').slice(0, 500),
+    detail: String(status.detail || '').slice(0, 300)
+  };
+}
+
+export function createAgentManager({
+  dataDir = path.join(os.homedir(), '.livedesk'),
+  settingsStore,
+  codexRuntime
+} = {}) {
+  const settings = settingsStore || new AgentSettingsStore({ dataDir });
+  const runtime = codexRuntime;
+  let statusCache = { expiresAt: 0, value: null };
+
+  async function getCodexStatus() {
+    if (!runtime) return { installed: false, authenticated: 'unknown', status: 'unavailable', codexPath: '' };
+    if (statusCache.value && statusCache.expiresAt > Date.now()) return statusCache.value;
+    let value;
+    try {
+      value = publicCodexStatus(await runtime.getStatus());
+    } catch (error) {
+      value = publicCodexStatus({
+        installed: true,
+        authenticated: 'unknown',
+        status: error?.code || 'security-unavailable',
+        detail: error?.message || 'Codex security isolation is unavailable.'
+      });
+    }
+    statusCache = { value, expiresAt: Date.now() + 10000 };
+    return value;
+  }
+
+  async function publicSettings() {
+    const current = await settings.get();
+    const { codexMaxTurns: _codexMaxTurns, ...exposedSettings } = current;
+    const codex = await getCodexStatus();
+    const securityStatus = runtime?.getSecurityStatus?.() || {
+      isolatedCodexHome: false,
+      restrictedEnvironment: false,
+      livedeskMcpOnly: false,
+      selectedDeviceScopeEnforced: false,
+      failClosed: true,
+      verified: false,
+      state: 'unavailable'
+    };
+    return {
+      ...exposedSettings,
+      provider: AGENT_PROVIDER_CODEX,
+      codexInstallation: codex.installed ? 'installed' : 'not-installed',
+      codexAuth: codex.authenticated,
+      codexStatus: codex.status,
+      codexPath: codex.codexPath,
+      agentWorkspacePath: current.codexWorkingDirectory,
+      securityStatus
+    };
+  }
+
+  return {
+    getSettings: publicSettings,
+    async updateSettings(patch = {}) {
+      const nextPatch = { ...patch };
+      const requestedProvider = String(nextPatch.provider || AGENT_PROVIDER_CODEX).trim().toLowerCase();
+      const suppliedLegacyKey = typeof nextPatch.apiKey === 'string' && nextPatch.apiKey.trim().length > 0;
+      delete nextPatch.provider;
+      delete nextPatch.apiKey;
+      if (requestedProvider !== AGENT_PROVIDER_CODEX || suppliedLegacyKey) {
+        throw new AgentProviderError(
+          'agent-provider-retired',
+          'LiveDesk uses the Hub-hosted Codex Agent and does not configure alternate model providers.',
+          { status: 400 }
+        );
+      }
+      await settings.update({ ...nextPatch, provider: AGENT_PROVIDER_CODEX });
+      statusCache = { expiresAt: 0, value: null };
+      return publicSettings();
+    },
+    async resetSettings() {
+      await settings.reset();
+      statusCache = { expiresAt: 0, value: null };
+      return publicSettings();
+    },
+    // Kept as a harmless compatibility endpoint for an older cached web UI.
+    // No credential is read, written, or returned by the current Hub.
+    async deleteApiKey() {
+      return publicSettings();
+    },
+    async testConnection() {
+      if (!runtime) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
+      statusCache = { expiresAt: 0, value: null };
+      return runtime.testConnection();
+    },
+    async createPlan() {
+      throw new AgentProviderError('agent-codex-run-required', 'Codex Agent requests use the LiveDesk tool loop.', { status: 409 });
+    },
+    async createSummary(input) {
+      const source = input && typeof input === 'object' ? input : {};
+      const results = Array.isArray(source.results) ? source.results : [];
+      return {
+        summary: String(results.length ? `${source.completed || 0} completed, ${source.failed || 0} failed.` : 'LiveDesk Agent run completed.').slice(0, 1200)
+      };
+    },
+    async startRun(input) {
+      const current = await settings.get();
+      if (current.provider !== AGENT_PROVIDER_CODEX || !runtime) {
+        throw new AgentProviderError('agent-codex-not-active', 'Codex SDK is not the active Agent runtime.', { status: 409 });
+      }
+      return runtime.start(input);
+    },
+    getRun(runId) { return runtime?.get(runId) || null; },
+    cancelRun(runId) { return runtime?.cancel(runId) || null; },
+    cancelAllRuns() { return runtime?.cancelAll?.() || 0; }
+  };
+}

package/src/agents/agent-settings.js

@@ -3,17 +3,12 @@ import os from 'node:os';
 import path from 'node:path';
 
 export const AGENT_PROVIDER_CODEX = 'codex';
-export const AGENT_PROVIDER_OPENCODE_GO = 'opencode-go';
 export const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_CODEX;
-export const DEFAULT_AGENT_BASE_URL = 'https://opencode.ai/zen/go/v1';
-export const DEFAULT_CODEX_MODEL_ID = '';
 export const DEFAULT_AGENT_WORKSPACE = path.join(os.homedir(), '.livedesk', 'agent-workspace');
 export const DEFAULT_AGENT_SETTINGS = Object.freeze({
-  settingsVersion: 2,
+  settingsVersion: 4,
   enabled: true,
   provider: DEFAULT_AGENT_PROVIDER,
-  codexModelId: DEFAULT_CODEX_MODEL_ID,
-  codexReasoningEffort: 'medium',
   codexSandboxMode: 'read-only',
   codexApprovalPolicy: 'never',
   codexWorkingDirectory: DEFAULT_AGENT_WORKSPACE,
@@ -24,44 +19,9 @@ export const DEFAULT_AGENT_SETTINGS = Object.freeze({
   codexShowDetailedEvents: true,
   codexNetworkAccessEnabled: false,
   codexWebSearchMode: 'disabled',
-  deterministicParserFirst: true,
-  generateSummary: true,
-  fallbackSummary: true,
-  includeRawDeviceDetails: false,
-  maxConcurrentRequests: 2,
-  baseUrl: DEFAULT_AGENT_BASE_URL,
-  defaultModelId: 'deepseek-v4-flash',
-  planModelId: '',
-  summaryModelId: '',
-  reasoningLevel: 'auto',
-  planTemperature: 0.1,
-  summaryTemperature: 0.2,
-  topP: 1,
-  planMaxOutputTokens: 1024,
-  summaryMaxOutputTokens: 1024,
-  planTimeoutMs: 60000,
-  summaryTimeoutMs: 60000,
-  retryCount: 1,
-  retryDelayMs: 1000,
-  streamSummary: false
+  maxConcurrentRequests: 2
 });
 
-const PROVIDERS = new Set([AGENT_PROVIDER_CODEX, AGENT_PROVIDER_OPENCODE_GO]);
-const REASONING_EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
-const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
-const APPROVAL_POLICIES = new Set(['never', 'on-request', 'on-failure', 'untrusted']);
-const WEB_SEARCH_MODES = new Set(['disabled', 'cached', 'live']);
-const LEGACY_REASONING_LEVELS = new Set(['auto', 'low', 'medium', 'high']);
-
-export class AgentSettingsError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'AgentSettingsError';
-    this.code = code;
-    this.status = 400;
-  }
-}
-
 function booleanValue(value, fallback) {
   return typeof value === 'boolean' ? value : fallback;
 }
@@ -73,31 +33,7 @@ function numberValue(value, min, max, fallback, integer = false) {
   return integer ? Math.round(clamped) : clamped;
 }
 
-function stringValue(value, fallback, maxLength = 240) {
-  if (typeof value !== 'string') return fallback;
-  return value.trim().slice(0, maxLength);
-}
-
-function enumValue(value, allowed, fallback, code) {
-  const normalized = stringValue(value, fallback, 80).toLowerCase();
-  if (!allowed.has(normalized)) throw new AgentSettingsError(code, `Invalid agent setting: ${normalized}.`);
-  return normalized;
-}
-
-function normalizeBaseUrl(value) {
-  const candidate = stringValue(value, DEFAULT_AGENT_SETTINGS.baseUrl, 500).replace(/\/+$/, '');
-  try {
-    const parsed = new URL(candidate);
-    if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.hostname) throw new Error('invalid protocol');
-    parsed.hash = '';
-    parsed.search = '';
-    return parsed.toString().replace(/\/+$/, '');
-  } catch {
-    throw new AgentSettingsError('agent-invalid-base-url', 'Base URL must be a valid HTTP or HTTPS URL.');
-  }
-}
-
-function normalizeWorkingDirectory(value) {
+function normalizeWorkingDirectory() {
   // The agent runtime owns this directory. Do not allow a browser/API caller
   // to move Codex into a user project or an arbitrary filesystem root.
   return DEFAULT_AGENT_WORKSPACE;
@@ -105,25 +41,17 @@ function normalizeWorkingDirectory(value) {
 
 export function normalizeAgentSettings(value = {}) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-  // The pre-Codex settings file was written by LiveDesk itself and had no
-  // migration marker. Keep the legacy values but move that first-run config
-  // to the new Codex default.
-  const migratingLegacy = Number(source.settingsVersion || 0) < 2 && source.provider === AGENT_PROVIDER_OPENCODE_GO;
-  const provider = migratingLegacy
-    ? DEFAULT_AGENT_PROVIDER
-    : enumValue(source.provider, PROVIDERS, DEFAULT_AGENT_PROVIDER, 'agent-unsupported-provider');
-  const reasoningLevel = enumValue(source.reasoningLevel, LEGACY_REASONING_LEVELS, DEFAULT_AGENT_SETTINGS.reasoningLevel, 'agent-invalid-reasoning-level');
   return {
-    settingsVersion: 2,
+    settingsVersion: 4,
     enabled: booleanValue(source.enabled, DEFAULT_AGENT_SETTINGS.enabled),
-    provider,
-    codexModelId: stringValue(source.codexModelId, DEFAULT_AGENT_SETTINGS.codexModelId, 160),
-    codexReasoningEffort: enumValue(source.codexReasoningEffort, REASONING_EFFORTS, DEFAULT_AGENT_SETTINGS.codexReasoningEffort, 'agent-invalid-reasoning-effort'),
+    // LiveDesk has one Agent runtime. Old provider values are deliberately
+    // normalized to Codex so an upgrade cannot reactivate a retired provider.
+    provider: AGENT_PROVIDER_CODEX,
     // These are safety settings, not user-controlled execution toggles. They
     // are accepted for compatibility but always normalized to the safe floor.
     codexSandboxMode: 'read-only',
     codexApprovalPolicy: 'never',
-    codexWorkingDirectory: normalizeWorkingDirectory(source.codexWorkingDirectory),
+    codexWorkingDirectory: normalizeWorkingDirectory(),
     codexTaskTimeoutMs: numberValue(source.codexTaskTimeoutMs, 30000, 1800000, DEFAULT_AGENT_SETTINGS.codexTaskTimeoutMs, true),
     codexMaxTurns: numberValue(source.codexMaxTurns, 1, 40, DEFAULT_AGENT_SETTINGS.codexMaxTurns, true),
     codexMaxToolCalls: numberValue(source.codexMaxToolCalls, 1, 100, DEFAULT_AGENT_SETTINGS.codexMaxToolCalls, true),
@@ -131,26 +59,7 @@ export function normalizeAgentSettings(value = {}) {
     codexShowDetailedEvents: booleanValue(source.codexShowDetailedEvents, DEFAULT_AGENT_SETTINGS.codexShowDetailedEvents),
     codexNetworkAccessEnabled: false,
     codexWebSearchMode: 'disabled',
-    deterministicParserFirst: booleanValue(source.deterministicParserFirst, DEFAULT_AGENT_SETTINGS.deterministicParserFirst),
-    generateSummary: booleanValue(source.generateSummary, DEFAULT_AGENT_SETTINGS.generateSummary),
-    fallbackSummary: booleanValue(source.fallbackSummary, DEFAULT_AGENT_SETTINGS.fallbackSummary),
-    includeRawDeviceDetails: booleanValue(source.includeRawDeviceDetails, DEFAULT_AGENT_SETTINGS.includeRawDeviceDetails),
-    maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true),
-    baseUrl: normalizeBaseUrl(source.baseUrl ?? DEFAULT_AGENT_SETTINGS.baseUrl),
-    defaultModelId: stringValue(source.defaultModelId, DEFAULT_AGENT_SETTINGS.defaultModelId, 160),
-    planModelId: stringValue(source.planModelId, DEFAULT_AGENT_SETTINGS.planModelId, 160),
-    summaryModelId: stringValue(source.summaryModelId, DEFAULT_AGENT_SETTINGS.summaryModelId, 160),
-    reasoningLevel,
-    planTemperature: numberValue(source.planTemperature, 0, 2, DEFAULT_AGENT_SETTINGS.planTemperature),
-    summaryTemperature: numberValue(source.summaryTemperature, 0, 2, DEFAULT_AGENT_SETTINGS.summaryTemperature),
-    topP: numberValue(source.topP, 0, 1, DEFAULT_AGENT_SETTINGS.topP),
-    planMaxOutputTokens: numberValue(source.planMaxOutputTokens, 128, 16384, DEFAULT_AGENT_SETTINGS.planMaxOutputTokens, true),
-    summaryMaxOutputTokens: numberValue(source.summaryMaxOutputTokens, 128, 16384, DEFAULT_AGENT_SETTINGS.summaryMaxOutputTokens, true),
-    planTimeoutMs: numberValue(source.planTimeoutMs, 5000, 180000, DEFAULT_AGENT_SETTINGS.planTimeoutMs, true),
-    summaryTimeoutMs: numberValue(source.summaryTimeoutMs, 5000, 180000, DEFAULT_AGENT_SETTINGS.summaryTimeoutMs, true),
-    retryCount: numberValue(source.retryCount, 0, 4, DEFAULT_AGENT_SETTINGS.retryCount, true),
-    retryDelayMs: numberValue(source.retryDelayMs, 100, 10000, DEFAULT_AGENT_SETTINGS.retryDelayMs, true),
-    streamSummary: booleanValue(source.streamSummary, DEFAULT_AGENT_SETTINGS.streamSummary)
+    maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true)
   };
 }
 

package/src/agents/agent-tool-registry.js

@@ -79,7 +79,7 @@ export const AGENT_TOOL_DEFINITIONS = Object.freeze([
   },
   {
     name: 'livedesk.list_processes',
-    description: 'Read process status from the selected Clients. Use processName for a named process such as ComfyUI.',
+    description: 'Read process status from the selected Clients. Use processName when the request names a specific process.',
     category: 'read',
     readOnly: true,
     mutating: false,

package/src/agents/codex-agent-runtime.js

@@ -66,15 +66,13 @@ function normalizeCodexError(error) {
   return new AgentProviderError('codex-run-failed', message, { status: 502, retryable: true });
 }
 
-function codexThreadOptions(settings, workspace) {
-  return {
-    model: settings.codexModelId || undefined,
-    sandboxMode: 'read-only',
-    approvalPolicy: 'never',
-    workingDirectory: workspace,
-    skipGitRepoCheck: true,
-    modelReasoningEffort: settings.codexReasoningEffort,
-    networkAccessEnabled: false,
+function codexThreadOptions(workspace) {
+  return {
+    sandboxMode: 'read-only',
+    approvalPolicy: 'never',
+    workingDirectory: workspace,
+    skipGitRepoCheck: true,
+    networkAccessEnabled: false,
     webSearchMode: 'disabled',
     webSearchEnabled: false,
     additionalDirectories: []
@@ -417,10 +415,10 @@ export function createCodexAgentRuntime({
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.min(30000, settings.codexTaskTimeoutMs));
     try {
-      const thread = codex.startThread(codexThreadOptions(settings, workspace));
-      const turn = await thread.run('Reply with the single word READY. Do not use tools.', { signal: controller.signal });
-      if (!String(turn.finalResponse || '').trim()) throw new AgentProviderError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
-      return { ok: true, modelId: settings.codexModelId || 'Codex default', modelName: settings.codexModelId || 'Codex default', latencyMs: Date.now() - startedAt, threadId: thread.id || '' };
+      const thread = codex.startThread(codexThreadOptions(workspace));
+      const turn = await thread.run('Reply with the single word READY. Do not use tools.', { signal: controller.signal });
+      if (!String(turn.finalResponse || '').trim()) throw new AgentProviderError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
+      return { ok: true, latencyMs: Date.now() - startedAt, threadId: thread.id || '' };
     } catch (error) {
       throw normalizeCodexError(error);
     } finally {
@@ -472,7 +470,7 @@ export function createCodexAgentRuntime({
       'Never use arbitrary MCP servers, change permissions, forge approvals, request credentials, or invent a tool result.',
       `The Hub has fixed this run to permission mode ${permissionPolicy?.mode || 'ask'} and enforces the policy independently of your instructions.`,
       'Use only the selected connected device IDs below. If the Hub asks for user approval, wait for that approval result and do not work around it.',
-      'You may perform multiple safe read-only checks when the request requires a sequence. For example, find Clients without ComfyUI, then check the service status only on those Clients.',
+      'You may perform multiple safe read-only checks when the request requires a sequence. For example, find Clients missing a named process, then check a related service only on those Clients.',
       `Selected device IDs: ${JSON.stringify(deviceIds)}`,
       'Return a concise Korean or English summary grounded only in tool results. Do not invent results.',
       `User request: ${safeText(instruction, 4000)}`
@@ -531,7 +529,7 @@ export function createCodexAgentRuntime({
         if (run.abortReason === 'timeout') throw codexAbortError('codex-run-timeout', 'The Codex task exceeded its timeout.');
         throw Object.assign(new Error('The Codex task was cancelled.'), { name: 'AbortError' });
       }
-      const threadOptions = codexThreadOptions(settings, workspace);
+      const threadOptions = codexThreadOptions(workspace);
       run.status = 'running';
       run.updatedAt = new Date().toISOString();
       for (let attempt = 0; attempt < 2; attempt += 1) {
@@ -649,7 +647,7 @@ export function createCodexAgentRuntime({
     const deviceIds = safeAgentDeviceIds(input.deviceIds);
     if (deviceIds.length === 0) throw new AgentProviderError('agent-no-target-devices', 'Select at least one connected device.', { status: 400 });
     const settings = await settingsStore.get();
-    if (!settings.enabled) throw new AgentProviderError('agent-ai-disabled', 'Agent AI is disabled in Settings.', { status: 409 });
+    if (!settings.enabled) throw new AgentProviderError('agent-ai-disabled', 'Codex Agent is disabled in Settings.', { status: 409 });
     assertSecurityConfiguration();
     pruneRuns();
     if (runs.size >= MAX_RUNS) throw new AgentProviderError('agent-run-limit', 'The LiveDesk Agent run history is full.', { status: 429, retryable: true });