nova-audio-agent 0.2.2 → 0.2.3

package/README.md

@@ -37,16 +37,11 @@ npm install --global nova-audio-agent
 
 ## Configure
 
-Open the desktop settings, which downloads the app on first run:
+Run `novaaudio`. The first launch downloads the app and opens a setup window
+that asks for one key and tests it before you start:
 
-```bash
-novaaudio config
-```
-
-Then add the keys for the services you want:
-
-- **[DashScope](https://platform.qianwenai.com)** — the default Qwen realtime voice service. Required.
-- **[Tavily](https://docs.tavily.com)** — web search. Optional.
+- **[DashScope](https://platform.qianwenai.com)** — the default Qwen realtime voice service, plus memory, the camera and web search. Required.
+- **[Tavily](https://docs.tavily.com)** — web search through Tavily instead of Bailian. Optional.
 - **Codex** — a logged-in Codex executable, for coding tasks. Optional. See the [setup guide](https://deepnovacore.github.io/NovaAudioAgent/en/docs/getting-started).
 
 Allow microphone access when prompted.
@@ -72,7 +67,8 @@ Hover over the desktop orb to reach its controls.
 | --- | --- |
 | `novaaudio` or `novaaudio start` | Download the desktop app if needed, then launch it |
 | `novaaudio config` | Download the app if needed, then open its settings |
-| `novaaudio doctor` | Inspect platform support, local installation, and configuration status |
+| `novaaudio doctor` | Inspect platform support, local installation, and which keys the voice pipeline needs |
+| `novaaudio doctor --online` | Also test keys set in the environment against their provider |
 | `novaaudio --version` | Print the desktop release version used by the CLI |
 | `novaaudio --help` | Show command help |
 
@@ -84,8 +80,9 @@ The CLI downloads the matching desktop release from
 before launching it. It reuses the desktop client's encrypted settings store and
 never reads or prints secret values.
 
-Run `novaaudio doctor` to see which release is installed and whether your
-configuration is complete.
+Run `novaaudio doctor` to see which release is installed and which voice keys
+are still missing. `novaaudio config` opens the full settings for the other
+features.
 
 For headless Ubuntu 22.04+, install `nova-audio-agent-server` and use `novaaudio-server start`; `novaaudio-server pair wss://your-host.ts.net` shows a terminal pairing QR after configuring the service.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nova-audio-agent",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Install and launch the Nova Audio Agent desktop client from the command line.",
   "type": "module",
   "bin": {

package/release-assets.json

@@ -3,17 +3,17 @@
   "repository": "deepnovacore/NovaAudioAgent",
   "targets": {
     "darwin-arm64": {
-      "artifact": "nova-audio-agent-0.2.2-macos-arm64-app.zip",
+      "artifact": "nova-audio-agent-0.2.3-macos-arm64-app.zip",
       "executable": "Nova Audio Agent Desktop.app/Contents/MacOS/Nova Audio Agent Desktop",
       "archive": "zip"
     },
     "win32-x64": {
-      "artifact": "nova-audio-agent-0.2.2-windows-x64-portable.zip",
+      "artifact": "nova-audio-agent-0.2.3-windows-x64-portable.zip",
       "executable": "Nova Audio Agent Desktop.exe",
       "archive": "zip"
     },
     "linux-x64": {
-      "artifact": "nova-audio-agent-0.2.2-linux-x64.AppImage",
+      "artifact": "nova-audio-agent-0.2.3-linux-x64.AppImage",
       "executable": "nova-audio-agent.AppImage",
       "archive": "file"
     }

package/src/capability-registry.mjs

@@ -80,6 +80,15 @@ export function interpolateCapabilityValue(value, environment) {
         invalid('interpolated_value_too_large');
     return resolved;
 }
+function missingEnvironment(values, environment) {
+    for (const value of values) {
+        for (const [, name = ''] of value.matchAll(/\$\{([^}]+)\}/gu)) {
+            if (ENV_NAME.test(name) && !environment[name]?.trim())
+                return name;
+        }
+    }
+    return undefined;
+}
 function interpolateMap(value, environment) {
     return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, interpolateCapabilityValue(val, environment)]));
 }
@@ -110,39 +119,60 @@ export function parseCapabilityRegistry(input, environment = {}) {
     const camera = moduleConfig(modules.camera, 'modules.camera', []);
     const coding = moduleConfig(modules.coding, 'modules.coding', []);
     const knowledge = moduleConfig(modules.knowledge, 'modules.knowledge', ['exposeToCodex']);
-    const enabled = bool(search.enabled, true, 'modules.search.enabled');
+    const requestedEnabled = bool(search.enabled, true, 'modules.search.enabled');
     const configuredProvider = omittedDefault(search.provider, 'tavily');
     if (configuredProvider !== 'tavily' && configuredProvider !== 'mcp')
         invalid('modules.search.provider');
-    const provider = environmentOverride(environment, 'NOVA_AUDIO_AGENT_SEARCH_PROVIDER') ?? configuredProvider;
-    if (provider !== 'tavily' && provider !== 'mcp')
-        invalid('NOVA_AUDIO_AGENT_SEARCH_PROVIDER');
+    const requestedProvider = environmentOverride(environment, 'SEARCH_PROVIDER') ?? configuredProvider;
+    if (requestedProvider !== 'tavily' && requestedProvider !== 'mcp')
+        invalid('SEARCH_PROVIDER');
     const overrides = [];
-    if (environment.NOVA_AUDIO_AGENT_SEARCH_PROVIDER?.trim())
-        overrides.push('NOVA_AUDIO_AGENT_SEARCH_PROVIDER');
+    if (environment.SEARCH_PROVIDER?.trim())
+        overrides.push('SEARCH_PROVIDER');
     let cameraEnabled = bool(camera.enabled, true, 'modules.camera.enabled');
-    const cameraOverride = environment.NOVA_AUDIO_AGENT_CAMERA_MODULE_ENABLED?.trim().toLowerCase();
+    const cameraOverride = environment.CAMERA_MODULE_ENABLED?.trim().toLowerCase();
     if (cameraOverride) {
         if (!['true', 'false', '1', '0', 'yes', 'no', 'on', 'off'].includes(cameraOverride))
-            invalid('NOVA_AUDIO_AGENT_CAMERA_MODULE_ENABLED');
+            invalid('CAMERA_MODULE_ENABLED');
         cameraEnabled = ['true', '1', 'yes', 'on'].includes(cameraOverride);
-        overrides.push('NOVA_AUDIO_AGENT_CAMERA_MODULE_ENABLED');
+        overrides.push('CAMERA_MODULE_ENABLED');
+    }
+    let codingEnabled = bool(coding.enabled, true, 'modules.coding.enabled');
+    const codingOverride = environment.CODING_MODULE_ENABLED?.trim().toLowerCase();
+    if (codingOverride) {
+        if (!['true', 'false', '1', '0', 'yes', 'no', 'on', 'off'].includes(codingOverride))
+            invalid('CODING_MODULE_ENABLED');
+        codingEnabled = ['true', '1', 'yes', 'on'].includes(codingOverride);
+        overrides.push('CODING_MODULE_ENABLED');
     }
     const tavily = object(omittedDefault(search.tavily, {}), 'modules.search.tavily', ['apiKeyEnv']);
     const apiKeyEnv = string(omittedDefault(tavily.apiKeyEnv, 'TAVILY_API_KEY'), 'modules.search.tavily.apiKeyEnv', 128);
     if (!ENV_NAME.test(apiKeyEnv))
         invalid('modules.search.tavily.apiKeyEnv');
+    // Search is optional: a missing Tavily key reuses the DashScope key through the Bailian preset, or turns search off.
+    const tavilyUnavailable = requestedEnabled && requestedProvider === 'tavily' && !environment[apiKeyEnv]?.trim();
+    const fallback = tavilyUnavailable && search.mcp === undefined && !environmentOverride(environment, 'SEARCH_MCP_URL')
+        && Boolean(environment.DASHSCOPE_API_KEY?.trim()) ? 'bailian_mcp' : undefined;
+    let enabled = requestedEnabled && (!tavilyUnavailable || fallback !== undefined);
+    const provider = fallback === undefined ? requestedProvider : 'mcp';
+    let reason = tavilyUnavailable ? `missing_environment:${apiKeyEnv}` : undefined;
     let mcp;
     if (search.mcp !== undefined || (enabled && provider === 'mcp')) {
         const config = object(omittedDefault(search.mcp, {}), 'modules.search.mcp', ['url', 'tool', 'headers', 'timeoutMs', 'maxResultBytes']);
-        const urlOverride = environmentOverride(environment, 'NOVA_AUDIO_AGENT_SEARCH_MCP_URL');
-        const toolOverride = environmentOverride(environment, 'NOVA_AUDIO_AGENT_SEARCH_MCP_TOOL');
+        const urlOverride = environmentOverride(environment, 'SEARCH_MCP_URL');
+        const toolOverride = environmentOverride(environment, 'SEARCH_MCP_TOOL');
         const preset = !urlOverride && config.url === undefined;
         const configuredUrl = string(omittedDefault(config.url, BAILIAN_SEARCH_MCP_URL), 'modules.search.mcp.url');
         const rawUrl = string(urlOverride ?? configuredUrl, 'modules.search.mcp.url');
         const configuredTool = string(omittedDefault(config.tool, preset ? BAILIAN_SEARCH_MCP_TOOL : 'web_search'), 'modules.search.mcp.tool', 256);
         const tool = string(toolOverride ?? configuredTool, 'modules.search.mcp.tool', 256);
         const rawHeaders = stringMap(omittedDefault(config.headers, preset ? { authorization: 'Bearer ${DASHSCOPE_API_KEY}' } : {}), 'modules.search.mcp.headers');
+        // A search endpoint whose key is not set turns search off, like a missing Tavily key.
+        const missing = enabled && provider === 'mcp' ? missingEnvironment([rawUrl, ...Object.values(rawHeaders)], environment) : undefined;
+        if (missing !== undefined) {
+            enabled = false;
+            reason = `missing_environment:${missing}`;
+        }
         const headers = enabled && provider === 'mcp' ? interpolateMap(rawHeaders, environment) : rawHeaders;
         const url = enabled && provider === 'mcp' ? interpolateCapabilityValue(rawUrl, environment) : rawUrl;
         if (enabled && provider === 'mcp')
@@ -151,9 +181,9 @@ export function parseCapabilityRegistry(input, environment = {}) {
             timeoutMs: integer(config.timeoutMs, 8000, 60000, 'modules.search.mcp.timeoutMs'),
             maxResultBytes: integer(config.maxResultBytes, 262144, 1048576, 'modules.search.mcp.maxResultBytes') };
         if (urlOverride)
-            overrides.push('NOVA_AUDIO_AGENT_SEARCH_MCP_URL');
+            overrides.push('SEARCH_MCP_URL');
         if (toolOverride)
-            overrides.push('NOVA_AUDIO_AGENT_SEARCH_MCP_TOOL');
+            overrides.push('SEARCH_MCP_TOOL');
     }
     const servers = object(omittedDefault(document.mcpServers, {}), 'mcpServers');
     if (Object.keys(servers).length > 8)
@@ -176,8 +206,9 @@ export function parseCapabilityRegistry(input, environment = {}) {
         }
     }
     return { version: 1, modules: {
-            search: { enabled, provider, tavily: { apiKeyEnv, ...(environment[apiKeyEnv] === undefined ? {} : { apiKey: environment[apiKeyEnv] }) }, ...(mcp === undefined ? {} : { mcp }) },
-            camera: { enabled: cameraEnabled }, coding: { enabled: bool(coding.enabled, true, 'modules.coding.enabled') },
+            search: { enabled, provider, tavily: { apiKeyEnv, ...(environment[apiKeyEnv] === undefined ? {} : { apiKey: environment[apiKeyEnv] }) }, ...(mcp === undefined ? {} : { mcp }),
+                ...(fallback === undefined ? {} : { fallback }), ...(reason === undefined ? {} : { reason }) },
+            camera: { enabled: cameraEnabled }, coding: { enabled: codingEnabled },
             knowledge: { enabled: bool(knowledge.enabled, false, 'modules.knowledge.enabled'), exposeToCodex: bool(knowledge.exposeToCodex, false, 'modules.knowledge.exposeToCodex') },
         }, mcpServers, serverStatuses, overrides,
         frontbrainToolBudget: integer(document.frontbrainToolBudget, DEFAULT_FRONTBRAIN_TOOL_BUDGET, 256, 'frontbrainToolBudget') };
@@ -225,7 +256,7 @@ function parseServer(value, environment) {
 }
 export function loadCapabilityRegistry(options = {}) {
     const environment = options.environment ?? process.env;
-    const explicitPath = (options.path === '' ? undefined : options.path) ?? environmentOverride(environment, 'NOVA_AUDIO_AGENT_CAPABILITIES_CONFIG');
+    const explicitPath = (options.path === '' ? undefined : options.path) ?? environmentOverride(environment, 'CAPABILITIES_CONFIG');
     const path = explicitPath ?? DEFAULT_CAPABILITIES_PATH;
     const explicit = explicitPath !== undefined;
     const resolved = path.startsWith('~/') ? join(options.home ?? homedir(), path.slice(2)) : path;
@@ -246,19 +277,17 @@ export function loadCapabilityRegistry(options = {}) {
 }
 export function capabilityStatus(registry, toolCount = null) {
     return { modules: {
-            search: { enabled: registry.modules.search.enabled, provider: registry.modules.search.provider },
+            search: { enabled: registry.modules.search.enabled, provider: registry.modules.search.provider,
+                ...(registry.modules.search.fallback === undefined ? {} : { fallback: registry.modules.search.fallback }),
+                ...(registry.modules.search.reason === undefined ? {} : { reason: registry.modules.search.reason }) },
             camera: registry.modules.camera, coding: registry.modules.coding, knowledge: registry.modules.knowledge,
         }, servers: registry.serverStatuses, overrides: registry.overrides, toolCount, toolBudget: registry.frontbrainToolBudget };
 }
 export function inspectCapabilities(options = {}) {
     try {
         const registry = loadCapabilityRegistry(options);
-        const environment = options.environment ?? process.env;
-        const missingTavily = registry.modules.search.enabled && registry.modules.search.provider === 'tavily'
-            && !environment[registry.modules.search.tavily.apiKeyEnv]?.trim();
-        return { ok: !missingTavily && registry.serverStatuses.every(server => server.status !== 'failed'),
-            ...capabilityStatus(registry),
-            ...(missingTavily ? { reason: `missing_environment:${registry.modules.search.tavily.apiKeyEnv}` } : {}) };
+        // A switched or disabled search is a reported degradation, not a failed configuration.
+        return { ok: registry.serverStatuses.every(server => server.status !== 'failed'), ...capabilityStatus(registry) };
     }
     catch (error) {
         return { ok: false, reason: error instanceof CapabilityConfigurationError ? error.reason : 'invalid_configuration' };

package/src/command.mjs

@@ -6,7 +6,12 @@ export const HELP_TEXT = `Usage: novaaudio [start|config|doctor|--version|--help
   novaaudio          Install if needed and launch Nova Audio Agent
   novaaudio start    Install if needed and launch Nova Audio Agent
   novaaudio config   Open the desktop settings window
-  novaaudio doctor   Inspect local installation and configuration status`
+  novaaudio doctor   Inspect local installation and configuration status
+  novaaudio doctor --online
+                     Also test voice keys set in the environment against their provider`
+
+const VOICE_KEY_SOURCES = Object.freeze({settings: 'saved in settings', environment: 'set in environment', missing: 'missing'})
+const VOICE_KEY_PROBES = Object.freeze({ok: 'valid', rejected: 'rejected by provider', network: 'could not reach provider', deferred: 'checked on first connection'})
 
 export async function main(argv, {
   stdout = process.stdout,
@@ -15,7 +20,8 @@ export async function main(argv, {
   doctor = inspectDoctor,
 } = {}) {
   const command = argv[0] ?? 'start'
-  if (argv.length > 1) {
+  const online = command === 'doctor' && argv.length === 2 && argv[1] === '--online'
+  if (argv.length > 1 && !online) {
     stdout.write(`${HELP_TEXT}\n`)
     return 2
   }
@@ -28,7 +34,7 @@ export async function main(argv, {
     return 0
   }
   if (command === 'doctor') {
-    const report = await doctor()
+    const report = await doctor({online})
     stdout.write(`Nova Audio Agent ${PRODUCT_VERSION}\n`)
     stdout.write(`Platform: ${report.platform} (${report.supported ? 'supported' : 'unsupported'})\n`)
     if (report.supported) {
@@ -37,6 +43,16 @@ export async function main(argv, {
       stdout.write(`Configured keys: ${report.configuredSecretKeys.length === 0 ? 'none' : report.configuredSecretKeys.join(', ')}\n`)
       stdout.write(`Codex: ${report.codexPresent ? 'found' : 'missing'}\n`)
     }
+    const missingVoiceKeys = report.voice?.keys.filter(key => key.source === null) ?? []
+    const rejectedVoiceKeys = report.voice?.keys.filter(key => key.probe === 'rejected') ?? []
+    if (report.voice) {
+      stdout.write(`Voice pipeline: ${report.voice.pipeline}\n`)
+      for (const key of report.voice.keys) stdout.write(`  ${key.name}: ${VOICE_KEY_SOURCES[key.source ?? 'missing']}${key.probe ? ` (${VOICE_KEY_PROBES[key.probe] ?? key.probe})` : ''}\n`)
+      if (online && report.voice.keys.some(key => key.source === 'settings')) stdout.write('  Saved keys are encrypted; test them in the desktop setup window.\n')
+      if (missingVoiceKeys.length > 0) stdout.write(report.voice.pipeline === 'integrated'
+        ? 'First run: start `novaaudio` and paste a DashScope API Key into the setup window that opens.\n'
+        : 'First run: start `novaaudio` and fill in the missing keys in the setup window that opens.\n')
+    }
     if (report.capabilities !== undefined) {
       const status = report.capabilities
       stdout.write(`Capabilities: ${status.ok ? 'valid' : 'needs attention'}${status.reason ? ` (${status.reason})` : ''}\n`)
@@ -47,7 +63,7 @@ export async function main(argv, {
         for (const name of status.overrides) stdout.write(`  Override: ${name}\n`)
       }
     }
-    return report.supported && report.capabilities?.ok !== false ? 0 : 1
+    return report.supported && report.capabilities?.ok !== false && missingVoiceKeys.length === 0 && rejectedVoiceKeys.length === 0 ? 0 : 1
   }
   if (command !== 'start' && command !== 'config') {
     stdout.write(`${HELP_TEXT}\n`)

package/src/key-probe.mjs

@@ -0,0 +1,29 @@
+// Generated from clients/desktop/src/main/key-probe.mjs; run node runtime/scripts/check-capabilities.mjs --write.
+// Live check for the one or two keys a first run needs. Each probe is a cheap
+// authenticated model listing; the key never appears in the result.
+const PROBES = Object.freeze({
+  dashscopeApiKey: 'https://dashscope.aliyuncs.com/compatible-mode/v1/models',
+  deepseekApiKey: 'https://api.deepseek.com/models',
+  arkApiKey: 'https://ark.cn-beijing.volces.com/api/v3/models',
+})
+// The Volcengine speech key has no cheap authenticated read; it is checked by the first connection.
+const DEFERRED = new Set(['doubaoBigmodelApiKey'])
+const PROBE_TIMEOUT_MS = 8_000
+
+export async function probeApiKey(key, value, {fetch = globalThis.fetch, timeoutMs = PROBE_TIMEOUT_MS} = {}) {
+  if (typeof value !== 'string' || value.trim() === '' || /[\u0000-\u001f\u007f]/u.test(value)) return Object.freeze({status: 'missing'})
+  if (DEFERRED.has(key)) return Object.freeze({status: 'deferred'})
+  if (!Object.hasOwn(PROBES, key)) return Object.freeze({status: 'unsupported'})
+  try {
+    const response = await fetch(PROBES[key], {
+      headers: {authorization: `Bearer ${value.trim()}`},
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    await response.body?.cancel().catch(() => {})
+    if (response.ok) return Object.freeze({status: 'ok'})
+    if (response.status === 401 || response.status === 403) return Object.freeze({status: 'rejected', httpStatus: response.status})
+    return Object.freeze({status: 'network', httpStatus: response.status})
+  } catch {
+    return Object.freeze({status: 'network'})
+  }
+}

package/src/runtime.mjs

@@ -1,4 +1,5 @@
 import {inspectCapabilities} from './capability-registry.mjs'
+import {probeApiKey} from './key-probe.mjs'
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto'
 import { spawn, spawnSync } from 'node:child_process'
 import {
@@ -415,11 +416,60 @@ function findCodex(platform = process.platform) {
   return result.status === 0 && String(result.stdout).trim() !== ''
 }
 
+// Mirrors the desktop settings keys each voice pipeline cannot start without.
+const VOICE_KEYS = Object.freeze({
+  dashscopeApiKey: 'DASHSCOPE_API_KEY',
+  deepseekApiKey: 'DEEPSEEK_API_KEY',
+  arkApiKey: 'ARK_API_KEY',
+  doubaoBigmodelApiKey: 'DOUBAO_BIGMODEL_API_KEY',
+})
+const CASCADED_LLM_KEYS = Object.freeze({qwen: 'dashscopeApiKey', deepseek: 'deepseekApiKey', ark: 'arkApiKey'})
+
+function voiceRequirement(document) {
+  const pipeline = document?.pipelineMode === 'cascaded' ? 'cascaded' : 'integrated'
+  const llm = Object.hasOwn(CASCADED_LLM_KEYS, document?.cascadedLlmProvider) ? document.cascadedLlmProvider : 'deepseek'
+  return {pipeline, keys: pipeline === 'integrated' ? ['dashscopeApiKey'] : [CASCADED_LLM_KEYS[llm], 'doubaoBigmodelApiKey']}
+}
+
+const DASHSCOPE_COMPATIBLE_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1'
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/u
+
+// Matches settings-store's validSecretEntry: anything else is dropped by the desktop and does not count as saved.
+function savedSecret(document, key) {
+  const entry = document?.secrets?.[key]
+  return entry !== null && typeof entry === 'object' && ['safeStorage', 'none'].includes(entry.enc)
+    && typeof entry.data === 'string' && entry.data !== '' && entry.data.length % 4 === 0 && BASE64.test(entry.data)
+}
+
+// Saved keys win over the environment in the desktop, and stay encrypted, so only environment keys can be probed here.
+async function inspectVoiceKeys(document, environment, {online, fetchImpl}) {
+  const {pipeline, keys} = voiceRequirement(document)
+  const sourceOf = (key, name) => savedSecret(document, key) ? 'settings' : environment[name]?.trim() ? 'environment' : null
+  const entries = []
+  for (const key of keys) {
+    let name = VOICE_KEYS[key]
+    let source = sourceOf(key, name)
+    // Integrated voice also accepts the generic model key while the model gateway stays on DashScope.
+    const savedBaseUrl = typeof document?.modelBaseUrl === 'string' ? document.modelBaseUrl.trim() : ''
+    const modelBaseUrl = savedBaseUrl || environment.MODEL_BASE_URL?.trim() || DASHSCOPE_COMPATIBLE_BASE_URL
+    if (source === null && key === 'dashscopeApiKey' && pipeline === 'integrated'
+      && (modelBaseUrl === '' || modelBaseUrl === DASHSCOPE_COMPATIBLE_BASE_URL) && sourceOf('modelApiKey', 'MODEL_API_KEY') !== null) {
+      name = 'MODEL_API_KEY'
+      source = sourceOf('modelApiKey', name)
+    }
+    const probe = online && source === 'environment' ? (await probeApiKey(key, environment[name], {fetch: fetchImpl})).status : undefined
+    entries.push(Object.freeze({name, source, ...(probe === undefined ? {} : {probe})}))
+  }
+  return Object.freeze({pipeline, keys: Object.freeze(entries)})
+}
+
 export async function inspectDoctor({
   platform = process.platform,
   arch = process.arch,
   home,
   environment = process.env,
+  online = false,
+  fetchImpl = globalThis.fetch,
 } = {}) {
   let target
   try {
@@ -432,8 +482,9 @@ export async function inspectDoctor({
   const settings = desktopSettingsPath({platform, home, environment})
   let secretKeys = []
   let capabilitiesConfigPath
+  let document
   try {
-    const document = JSON.parse(await readFile(settings, 'utf8'))
+    document = JSON.parse(await readFile(settings, 'utf8'))
     // Match settings-store v4 migration/string validation, then backendLaunchSpec's nonempty saved-path override.
     const acceptsV4Fields = document?.version === undefined || (typeof document.version === 'number' && document.version >= 4)
     const candidate = document?.capabilitiesConfigPath
@@ -451,10 +502,11 @@ export async function inspectDoctor({
     desktopReady: await cachedInstallation({root, executable, target, platform}) !== null,
     settingsPresent: await access(settings).then(() => true, () => false),
     configuredSecretKeys: Object.freeze(secretKeys),
+    voice: await inspectVoiceKeys(document, environment, {online, fetchImpl}),
     codexPresent: findCodex(platform),
     capabilities: inspectCapabilities({
       environment: capabilitiesConfigPath === undefined ? environment : {
-        ...environment, NOVA_AUDIO_AGENT_CAPABILITIES_CONFIG: capabilitiesConfigPath,
+        ...environment, CAPABILITIES_CONFIG: capabilitiesConfigPath,
       },
       ...(home === undefined ? {} : {home}),
     }),

package/src/target.mjs

@@ -1,7 +1,7 @@
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-export const PRODUCT_VERSION = '0.2.2'
+export const PRODUCT_VERSION = '0.2.3'
 export const RELEASE_REPOSITORY = 'deepnovacore/NovaAudioAgent'
 
 const DEFINITIONS = Object.freeze({