@pellux/goodvibes-agent 0.1.77 → 0.1.79

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.79 - 2026-06-01
+
+- Expanded the Voice & Media workspace into a provider readiness matrix covering selected TTS readiness, missing secret key names, media understanding/generation posture, and browser-tool state.
+- Kept voice, browser, and generated media side effects explicit: the workspace renders setup state and next steps only, never secret values or hidden runtime actions.
+
+## 0.1.78 - 2026-06-01
+
+- Expanded the Agent channel workspace into a concrete readiness matrix with setup state, missing runtime config keys, default-target posture, and safe next steps for each externally owned channel.
+- Kept channel setup read-only inside Agent: no runtime lifecycle ownership, no hidden sends, and no secret values rendered.
+
 ## 0.1.77 - 2026-06-01
 
 - Added a first-class Agent profile creation form inside the fullscreen operator workspace instead of dispatching a placeholder command template.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/input/agent-workspace-channels.ts

@@ -7,11 +7,17 @@ export interface AgentWorkspaceChannelStatus {
   readonly label: string;
   readonly enabled: boolean;
   readonly ready: boolean;
+  readonly requiredKeys: readonly string[];
+  readonly missingRequiredKeys: readonly string[];
   readonly missingConfigCount: number;
+  readonly defaultTargetKeys: readonly string[];
+  readonly configuredDefaultTargetKeys: readonly string[];
   readonly defaultTarget: 'configured' | 'missing' | 'not-required';
   readonly delivery: 'disabled' | 'blocked' | 'explicit-target' | 'default-ready';
   readonly risk: AgentWorkspaceChannelRisk;
   readonly riskLabel: string;
+  readonly setupState: 'disabled' | 'needs-config' | 'needs-target' | 'ready';
+  readonly nextStep: string;
 }
 
 interface AgentWorkspaceConfigReader {
@@ -182,10 +188,12 @@ function hasConfigValue(context: CommandContext, key: string): boolean {
 
 function buildChannelStatus(context: CommandContext, spec: AgentWorkspaceChannelSpec): AgentWorkspaceChannelStatus {
   const enabled = readConfigBoolean(context, spec.enabledKey, false);
-  const missingConfigCount = spec.requiredKeys.filter((key) => !hasConfigValue(context, key)).length;
+  const missingRequiredKeys = spec.requiredKeys.filter((key) => !hasConfigValue(context, key));
+  const configuredDefaultTargetKeys = spec.defaultTargetKeys.filter((key) => hasConfigValue(context, key));
+  const missingConfigCount = missingRequiredKeys.length;
   const defaultTarget = spec.defaultTargetKeys.length === 0
     ? 'not-required'
-    : spec.defaultTargetKeys.some((key) => hasConfigValue(context, key))
+    : configuredDefaultTargetKeys.length > 0
       ? 'configured'
       : 'missing';
   const ready = enabled && missingConfigCount === 0;
@@ -196,16 +204,36 @@ function buildChannelStatus(context: CommandContext, spec: AgentWorkspaceChannel
       : defaultTarget === 'configured'
         ? 'default-ready'
         : 'explicit-target';
+  const setupState = !enabled
+    ? 'disabled'
+    : missingConfigCount > 0
+      ? 'needs-config'
+      : defaultTarget === 'missing'
+        ? 'needs-target'
+        : 'ready';
+  const nextStep = setupState === 'disabled'
+    ? `Enable ${spec.label} in the owning GoodVibes runtime before Agent can use it.`
+    : setupState === 'needs-config'
+      ? `Configure ${missingRequiredKeys.join(', ')} in the owning runtime or secret manager.`
+      : setupState === 'needs-target'
+        ? `Provide an explicit delivery target per send, or configure one of ${spec.defaultTargetKeys.join(', ')}.`
+        : `Use explicit user action or runtime policy to send through ${spec.label}.`;
   return {
     id: spec.id,
     label: spec.label,
     enabled,
     ready,
+    requiredKeys: spec.requiredKeys,
+    missingRequiredKeys,
     missingConfigCount,
+    defaultTargetKeys: spec.defaultTargetKeys,
+    configuredDefaultTargetKeys,
     defaultTarget,
     delivery,
     risk: spec.risk,
     riskLabel: spec.riskLabel,
+    setupState,
+    nextStep,
   };
 }
 

package/src/input/agent-workspace-snapshot.ts

@@ -6,6 +6,7 @@ import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-regist
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
+import { buildAgentWorkspaceVoiceMediaReadiness, type AgentWorkspaceVoiceMediaProviderDescriptor } from './agent-workspace-voice-media.ts';
 import type {
   AgentWorkspaceLocalLibraryItem,
   AgentWorkspaceRuntimeProfileItem,
@@ -217,6 +218,16 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return [];
     }
   })();
+  const voiceProviderDescriptors: readonly AgentWorkspaceVoiceMediaProviderDescriptor[] = voiceProviders.map((provider) => ({
+    id: provider.id,
+    label: provider.label,
+    capabilities: provider.capabilities,
+  }));
+  const mediaProviderDescriptors: readonly AgentWorkspaceVoiceMediaProviderDescriptor[] = mediaProviders.map((provider) => ({
+    id: provider.id,
+    label: provider.label,
+    capabilities: provider.capabilities,
+  }));
   const warnings: string[] = [];
   if (provider === 'unknown' || model === 'unknown') warnings.push('Provider/model unavailable in this runtime context.');
   if (!context.executeCommand) warnings.push('Command dispatch is unavailable; workspace actions will show guidance only.');
@@ -226,6 +237,11 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const ttsLlmModel = readConfigString(context, 'tts.llmModel', '');
   const daemonBaseUrl = `http://${host}:${port}`;
   const channels = buildAgentWorkspaceChannels(context);
+  const voiceMediaReadiness = buildAgentWorkspaceVoiceMediaReadiness({
+    context,
+    voiceProviders: voiceProviderDescriptors,
+    mediaProviders: mediaProviderDescriptors,
+  });
   const setupChecklist = buildAgentWorkspaceSetupChecklist({
     provider,
     model,
@@ -278,6 +294,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     mediaProviderCount: mediaProviders.length,
     mediaUnderstandingProviderCount: mediaProviders.filter((entry) => entry.capabilities.includes('understand')).length,
     mediaGenerationProviderCount: mediaProviders.filter((entry) => entry.capabilities.includes('generate')).length,
+    voiceMediaReadiness,
     browserSurfaceEnabled: readConfigBoolean(context, 'web.enabled', false),
     browserSurfacePublicBaseUrl: readConfigString(context, 'web.publicBaseUrl', '(not configured)'),
     activeRuntimeProfile: inferActiveRuntimeProfile(context.workspace?.shellPaths?.homeDirectory ?? ''),

package/src/input/agent-workspace-types.ts

@@ -1,5 +1,6 @@
 import type { AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
 import type { AgentWorkspaceSetupChecklistItem } from './agent-workspace-setup.ts';
+import type { AgentWorkspaceVoiceMediaReadiness } from './agent-workspace-voice-media.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -147,6 +148,7 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly mediaProviderCount: number;
   readonly mediaUnderstandingProviderCount: number;
   readonly mediaGenerationProviderCount: number;
+  readonly voiceMediaReadiness: AgentWorkspaceVoiceMediaReadiness;
   readonly browserSurfaceEnabled: boolean;
   readonly browserSurfacePublicBaseUrl: string;
   readonly activeRuntimeProfile: string;

package/src/input/agent-workspace-voice-media.ts

@@ -0,0 +1,216 @@
+import type { CommandContext } from './command-registry.ts';
+
+export type AgentWorkspaceVoiceMediaDomain = 'voice' | 'media';
+export type AgentWorkspaceVoiceMediaSetupState = 'ready' | 'registered' | 'needs-secret' | 'not-registered';
+
+export interface AgentWorkspaceVoiceMediaProviderDescriptor {
+  readonly id: string;
+  readonly label?: string;
+  readonly capabilities: readonly string[];
+}
+
+export interface AgentWorkspaceVoiceMediaProviderStatus {
+  readonly id: string;
+  readonly label: string;
+  readonly domain: AgentWorkspaceVoiceMediaDomain;
+  readonly features: readonly string[];
+  readonly setupState: AgentWorkspaceVoiceMediaSetupState;
+  readonly selected: boolean;
+  readonly secretKeyOptions: readonly string[];
+  readonly configuredSecretKeys: readonly string[];
+  readonly missingSecretKeyOptions: readonly string[];
+  readonly nextStep: string;
+}
+
+export interface AgentWorkspaceVoiceMediaReadiness {
+  readonly voiceProviders: readonly AgentWorkspaceVoiceMediaProviderStatus[];
+  readonly mediaProviders: readonly AgentWorkspaceVoiceMediaProviderStatus[];
+  readonly readyVoiceProviderCount: number;
+  readonly readyMediaProviderCount: number;
+  readonly selectedTtsProviderStatus: AgentWorkspaceVoiceMediaSetupState;
+  readonly selectedTtsProviderLabel: string;
+  readonly ttsVoiceConfigured: boolean;
+  readonly ttsResponseRouteConfigured: boolean;
+  readonly browserToolState: 'disabled' | 'local-only' | 'public-url';
+  readonly browserToolNextStep: string;
+  readonly nextSteps: readonly string[];
+}
+
+type AgentWorkspaceConfigReader = {
+  get(key: string): unknown;
+};
+
+type ProviderSecretSpec = {
+  readonly id: string;
+  readonly secretKeyOptions: readonly string[];
+  readonly noSecretRequired?: boolean;
+};
+
+const VOICE_SECRET_SPECS: readonly ProviderSecretSpec[] = [
+  { id: 'openai', secretKeyOptions: ['OPENAI_API_KEY', 'OPENAI_KEY'] },
+  { id: 'deepgram', secretKeyOptions: ['DEEPGRAM_API_KEY'] },
+  { id: 'google', secretKeyOptions: ['GEMINI_API_KEY', 'GOOGLE_API_KEY', 'GOOGLE_GEMINI_API_KEY'] },
+  { id: 'elevenlabs', secretKeyOptions: ['ELEVENLABS_API_KEY', 'XI_API_KEY'] },
+  { id: 'microsoft', secretKeyOptions: [], noSecretRequired: true },
+  { id: 'vydra', secretKeyOptions: ['VYDRA_API_KEY'] },
+];
+
+const MEDIA_SECRET_SPECS: readonly ProviderSecretSpec[] = [
+  { id: 'builtin:image-understanding', secretKeyOptions: [], noSecretRequired: true },
+  { id: 'byteplus', secretKeyOptions: ['BYTEPLUS_API_KEY'] },
+  { id: 'runway', secretKeyOptions: ['RUNWAY_API_KEY', 'RUNWAYML_API_SECRET'] },
+  { id: 'alibaba', secretKeyOptions: ['MODELSTUDIO_API_KEY', 'DASHSCOPE_API_KEY', 'QWEN_API_KEY'] },
+  { id: 'fal', secretKeyOptions: ['FAL_KEY', 'FAL_API_KEY'] },
+  { id: 'comfy', secretKeyOptions: ['COMFY_BASE_URL', 'COMFY_API_KEY'] },
+];
+
+function readConfigString(context: CommandContext, key: string, fallback: string): string {
+  try {
+    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
+    const value = configManager?.get(key);
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function readConfigBoolean(context: CommandContext, key: string, fallback: boolean): boolean {
+  try {
+    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
+    const value = configManager?.get(key);
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'string') {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === 'true') return true;
+      if (normalized === 'false') return false;
+    }
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function configuredSecretKeys(options: readonly string[]): readonly string[] {
+  return options.filter((key) => {
+    const value = process.env[key];
+    return typeof value === 'string' && value.trim().length > 0;
+  });
+}
+
+function specFor(domain: AgentWorkspaceVoiceMediaDomain, id: string): ProviderSecretSpec {
+  const specs = domain === 'voice' ? VOICE_SECRET_SPECS : MEDIA_SECRET_SPECS;
+  return specs.find((entry) => entry.id === id) ?? { id, secretKeyOptions: [] };
+}
+
+function providerLabel(provider: AgentWorkspaceVoiceMediaProviderDescriptor): string {
+  return typeof provider.label === 'string' && provider.label.trim().length > 0 ? provider.label.trim() : provider.id;
+}
+
+function buildProviderStatus(
+  domain: AgentWorkspaceVoiceMediaDomain,
+  provider: AgentWorkspaceVoiceMediaProviderDescriptor,
+  selectedProviderId: string,
+): AgentWorkspaceVoiceMediaProviderStatus {
+  const spec = specFor(domain, provider.id);
+  const configured = configuredSecretKeys(spec.secretKeyOptions);
+  const selected = selectedProviderId === provider.id;
+  const setupState: AgentWorkspaceVoiceMediaSetupState = spec.noSecretRequired || configured.length > 0
+    ? 'ready'
+    : spec.secretKeyOptions.length > 0
+      ? 'needs-secret'
+      : 'registered';
+  const label = providerLabel(provider);
+  const nextStep = setupState === 'ready'
+    ? `${label} is ready for explicit Agent voice/media use.`
+    : setupState === 'needs-secret'
+      ? `Configure one of ${spec.secretKeyOptions.join('|')} in the owning runtime environment.`
+      : `${label} is registered; confirm any provider-specific setup in the owning runtime.`;
+  return {
+    id: provider.id,
+    label,
+    domain,
+    features: provider.capabilities,
+    setupState,
+    selected,
+    secretKeyOptions: spec.secretKeyOptions,
+    configuredSecretKeys: configured,
+    missingSecretKeyOptions: configured.length > 0 || spec.noSecretRequired ? [] : spec.secretKeyOptions,
+    nextStep,
+  };
+}
+
+function missingSelectedProviderStatus(selectedProviderId: string): AgentWorkspaceVoiceMediaProviderStatus {
+  return {
+    id: selectedProviderId,
+    label: selectedProviderId,
+    domain: 'voice',
+    features: [],
+    setupState: 'not-registered',
+    selected: true,
+    secretKeyOptions: [],
+    configuredSecretKeys: [],
+    missingSecretKeyOptions: [],
+    nextStep: `Selected TTS provider ${selectedProviderId} is not registered in this runtime.`,
+  };
+}
+
+function selectedProviderStatus(
+  providers: readonly AgentWorkspaceVoiceMediaProviderStatus[],
+  selectedProviderId: string,
+): AgentWorkspaceVoiceMediaProviderStatus {
+  return providers.find((provider) => provider.id === selectedProviderId) ?? missingSelectedProviderStatus(selectedProviderId);
+}
+
+function browserToolState(context: CommandContext): AgentWorkspaceVoiceMediaReadiness['browserToolState'] {
+  if (!readConfigBoolean(context, 'web.enabled', false)) return 'disabled';
+  const publicBaseUrl = readConfigString(context, 'web.publicBaseUrl', '');
+  return publicBaseUrl ? 'public-url' : 'local-only';
+}
+
+function browserToolNextStep(state: AgentWorkspaceVoiceMediaReadiness['browserToolState']): string {
+  if (state === 'disabled') return 'Inspect MCP browser/automation tools; enable browser access in the owning runtime only when needed.';
+  if (state === 'local-only') return 'Browser tooling is local-only; keep external exposure off unless explicitly configured.';
+  return 'Public browser URL is configured; use explicit user action and runtime policy before browser-side effects.';
+}
+
+export function buildAgentWorkspaceVoiceMediaReadiness(options: {
+  readonly context: CommandContext;
+  readonly voiceProviders: readonly AgentWorkspaceVoiceMediaProviderDescriptor[];
+  readonly mediaProviders: readonly AgentWorkspaceVoiceMediaProviderDescriptor[];
+}): AgentWorkspaceVoiceMediaReadiness {
+  const selectedTtsProviderId = readConfigString(options.context, 'tts.provider', '');
+  const ttsVoice = readConfigString(options.context, 'tts.voice', '');
+  const ttsLlmProvider = readConfigString(options.context, 'tts.llmProvider', '');
+  const ttsLlmModel = readConfigString(options.context, 'tts.llmModel', '');
+  const voiceProviders = options.voiceProviders.map((provider) => buildProviderStatus('voice', provider, selectedTtsProviderId));
+  const mediaProviders = options.mediaProviders.map((provider) => buildProviderStatus('media', provider, ''));
+  const selectedStatus = selectedTtsProviderId
+    ? selectedProviderStatus(voiceProviders, selectedTtsProviderId)
+    : {
+        ...missingSelectedProviderStatus('(provider default)'),
+        setupState: 'registered' as const,
+        nextStep: 'Choose a TTS provider when live speech should be predictable.',
+      };
+  const browserState = browserToolState(options.context);
+  const nextSteps = [
+    selectedStatus.setupState === 'needs-secret' ? selectedStatus.nextStep : '',
+    !ttsVoice ? 'Choose a stable TTS voice for day-one spoken replies.' : '',
+    mediaProviders.some((provider) => provider.features.includes('generate') && provider.setupState === 'needs-secret')
+      ? 'Configure at least one media generation provider secret before image/video generation.'
+      : '',
+    browserToolNextStep(browserState),
+  ].filter((step) => step.length > 0);
+  return {
+    voiceProviders,
+    mediaProviders,
+    readyVoiceProviderCount: voiceProviders.filter((provider) => provider.setupState === 'ready').length,
+    readyMediaProviderCount: mediaProviders.filter((provider) => provider.setupState === 'ready').length,
+    selectedTtsProviderStatus: selectedStatus.setupState,
+    selectedTtsProviderLabel: selectedStatus.label,
+    ttsVoiceConfigured: ttsVoice.length > 0,
+    ttsResponseRouteConfigured: ttsLlmProvider.length > 0 && ttsLlmModel.length > 0,
+    browserToolState: browserState,
+    browserToolNextStep: browserToolNextStep(browserState),
+    nextSteps,
+  };
+}

package/src/renderer/agent-workspace.ts

@@ -205,23 +205,34 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     const enabledCount = snapshot.channels.filter((channel) => channel.enabled).length;
     const readyCount = snapshot.channels.filter((channel) => channel.ready).length;
     const configuredDefaults = snapshot.channels.filter((channel) => channel.defaultTarget === 'configured').length;
-    const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label).join(', ');
+    const readyChannels = snapshot.channels.filter((channel) => channel.ready).map((channel) => channel.label);
+    const needsTarget = snapshot.channels.filter((channel) => channel.setupState === 'needs-target');
+    const needsConfig = snapshot.channels.filter((channel) => channel.setupState === 'needs-config');
+    const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label);
+    const disabledPreview = disabledChannels.slice(0, 6).join(', ');
+    const disabledSuffix = disabledChannels.length > 6 ? `, +${disabledChannels.length - 6} more` : '';
+    const orderedChannels = [
+      ...snapshot.channels.filter((channel) => channel.enabled),
+      ...snapshot.channels.filter((channel) => !channel.enabled),
+    ].slice(0, 6);
     base.push(
       { text: `GoodVibes runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
       { text: `Readiness: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} default target(s) configured.`, fg: PALETTE.info },
-      { text: `Disabled channels: ${disabledChannels || 'none'}.`, fg: PALETTE.dim },
-      { text: 'Pairing: use /pair or /qrcode for companion setup.', fg: PALETTE.info },
-      { text: 'Channel posture: inspect via /communication and /setup review.', fg: PALETTE.muted },
-      { text: 'Safety: external delivery, unknown senders, and public exposure require explicit policy and user action.', fg: PALETTE.warn },
+      { text: `Ready channels: ${readyChannels.join(', ') || 'none'}.`, fg: readyChannels.length > 0 ? PALETTE.good : PALETTE.warn },
+      { text: `Needs default target: ${needsTarget.map((channel) => `${channel.label} -> ${channel.defaultTargetKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsTarget.length > 0 ? PALETTE.warn : PALETTE.muted },
+      { text: `Needs config: ${needsConfig.map((channel) => `${channel.label} -> ${channel.missingRequiredKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsConfig.length > 0 ? PALETTE.warn : PALETTE.muted },
+      { text: `Disabled channels: ${disabledPreview || 'none'}${disabledSuffix}.`, fg: PALETTE.dim },
+      { text: 'Safety: no secret values; sends and public exposure require explicit user action and runtime policy.', fg: PALETTE.warn },
     );
-    for (const channel of snapshot.channels) {
-      const enabled = channel.enabled ? 'enabled' : 'disabled';
+    for (const channel of orderedChannels) {
       const ready = channel.ready ? 'ready' : `${channel.missingConfigCount} missing`;
       base.push({
-        text: `${channel.label}: ${enabled}; ${ready}; default ${channel.defaultTarget}; delivery ${channel.delivery}; risk ${channel.riskLabel}.`,
+        text: `${channel.label}: ${channel.setupState}; ${ready}; target ${channel.defaultTarget}; delivery ${channel.delivery}; risk ${channel.risk}.`,
         fg: channel.ready ? PALETTE.good : channel.enabled ? PALETTE.warn : PALETTE.dim,
       });
     }
+    base.push({ text: 'Only config key names and readiness state are rendered here.', fg: PALETTE.muted });
+    base.push({ text: 'Pairing: use /pair or /qrcode; inspect routed activity with /communication and /setup review.', fg: PALETTE.info });
   } else if (category.id === 'knowledge') {
     base.push(
       { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },
@@ -231,13 +242,41 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: 'Agent-owned content appears here only after explicit Agent knowledge ingestion.', fg: PALETTE.muted },
     );
   } else if (category.id === 'voice-media') {
+    const readiness = snapshot.voiceMediaReadiness;
+    const voiceRows = readiness.voiceProviders.slice(0, 6);
+    const mediaRows = readiness.mediaProviders.slice(0, 6);
     base.push(
       { text: `Voice providers: ${snapshot.voiceProviderCount}; streaming TTS: ${snapshot.voiceStreamingProviderCount}; STT: ${snapshot.voiceSttProviderCount}; realtime: ${snapshot.voiceRealtimeProviderCount}.`, fg: PALETTE.info },
-      { text: `Voice interaction: ${snapshot.voiceSurfaceEnabled ? 'enabled' : 'disabled'}; use /voice review for portable voice posture.`, fg: snapshot.voiceSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
+      { text: `Voice interaction: ${snapshot.voiceSurfaceEnabled ? 'enabled' : 'disabled'}; ready providers ${readiness.readyVoiceProviderCount}/${snapshot.voiceProviderCount}.`, fg: snapshot.voiceSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
       { text: `TTS config: provider ${snapshot.ttsProvider}; voice ${snapshot.ttsVoice}; response model ${snapshot.ttsResponseModel}.`, fg: PALETTE.info },
+      { text: `Selected TTS readiness: ${readiness.selectedTtsProviderLabel} -> ${readiness.selectedTtsProviderStatus}; voice ${readiness.ttsVoiceConfigured ? 'configured' : 'default'}; response route ${readiness.ttsResponseRouteConfigured ? 'configured' : 'chat route'}.`, fg: readiness.selectedTtsProviderStatus === 'ready' ? PALETTE.good : PALETTE.warn },
       { text: `Media providers: ${snapshot.mediaProviderCount}; understanding: ${snapshot.mediaUnderstandingProviderCount}; generation: ${snapshot.mediaGenerationProviderCount}.`, fg: PALETTE.info },
-      { text: `Browser companion: ${snapshot.browserSurfaceEnabled ? 'available' : 'not advertised'}; public base URL ${snapshot.browserSurfacePublicBaseUrl}.`, fg: snapshot.browserSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
-      { text: 'Build dispatch stays out of setup; explicit delegation is handled from the Build Delegation workspace.', fg: PALETTE.good },
+      { text: `Ready media providers: ${readiness.readyMediaProviderCount}/${snapshot.mediaProviderCount}.`, fg: readiness.readyMediaProviderCount > 0 ? PALETTE.good : PALETTE.warn },
+      { text: `Browser tooling: ${readiness.browserToolState}; public base URL ${snapshot.browserSurfacePublicBaseUrl}.`, fg: snapshot.browserSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
+      { text: readiness.browserToolNextStep, fg: PALETTE.muted },
+      { text: 'Voice provider readiness', fg: PALETTE.title, bold: true },
+    );
+    for (const provider of voiceRows) {
+      const selected = provider.selected ? 'selected; ' : '';
+      const missing = provider.missingSecretKeyOptions.length > 0 ? `; needs ${provider.missingSecretKeyOptions.join('|')}` : '';
+      base.push({
+        text: `${provider.label}: ${selected}${provider.setupState}; ${provider.features.join(', ') || 'registered'}${missing}.`,
+        fg: provider.setupState === 'ready' ? PALETTE.good : provider.setupState === 'needs-secret' ? PALETTE.warn : PALETTE.muted,
+      });
+    }
+    if (snapshot.voiceProviderCount > voiceRows.length) base.push({ text: `${snapshot.voiceProviderCount - voiceRows.length} more voice provider(s).`, fg: PALETTE.dim });
+    base.push({ text: 'Media provider readiness', fg: PALETTE.title, bold: true });
+    for (const provider of mediaRows) {
+      const missing = provider.missingSecretKeyOptions.length > 0 ? `; needs ${provider.missingSecretKeyOptions.join('|')}` : '';
+      base.push({
+        text: `${provider.label}: ${provider.setupState}; ${provider.features.join(', ') || 'registered'}${missing}.`,
+        fg: provider.setupState === 'ready' ? PALETTE.good : provider.setupState === 'needs-secret' ? PALETTE.warn : PALETTE.muted,
+      });
+    }
+    if (snapshot.mediaProviderCount > mediaRows.length) base.push({ text: `${snapshot.mediaProviderCount - mediaRows.length} more media provider(s).`, fg: PALETTE.dim });
+    for (const step of readiness.nextSteps.slice(0, 4)) base.push({ text: `Next: ${step}`, fg: PALETTE.info });
+    base.push(
+      { text: 'No secret values are rendered. Voice, browser, and generated media side effects require explicit user action.', fg: PALETTE.warn },
       { text: 'Image input uses prompt attachments; media generation/provider setup stays behind explicit commands and configured providers.', fg: PALETTE.muted },
     );
   } else if (category.id === 'profiles') {

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.77';
+let _version = '0.1.79';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {