@pellux/goodvibes-agent 0.1.78 → 0.1.80

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.80 - 2026-06-01
+
+- Added an Agent day-one readiness checklist to the onboarding review step covering runtime connection, default model route, profile setup, isolated Agent Knowledge, local behavior, channels, routines/schedules, and explicit build delegation.
+- Kept the first-run review focused on Agent setup outcomes instead of copied runtime lifecycle or non-Agent knowledge behavior.
+
+## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "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-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/input/onboarding/onboarding-wizard-steps.ts

@@ -3,6 +3,7 @@ import { modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.
 import { listAgentRuntimeProfileTemplates } from '../../agent/runtime-profile.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
+import type { OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
 
 function buildStarterTemplateOptions(): readonly OnboardingWizardRadioOption[] {
   return [
@@ -58,6 +59,98 @@ function addApplyAndContinueAction(step: OnboardingWizardStepDefinition): Onboar
   };
 }
 
+function findRuntimeCapability(
+  controller: OnboardingWizardController,
+  id: OnboardingStep1CapabilityId,
+): OnboardingStep1CapabilityItem | null {
+  return controller.runtimeDerived.step1Capabilities.find((capability) => capability.id === id) ?? null;
+}
+
+function currentMainModelLabel(controller: OnboardingWizardController): string {
+  const routing = controller.runtimeSnapshot?.providerRouting;
+  return modelSelectionLabel(controller.modelSelectionState.get('main') ?? {
+    providerId: normalizeText(routing?.primaryProviderId),
+    modelId: normalizeText(routing?.primaryModelId),
+    enabled: true,
+  });
+}
+
+function profileSetupLabel(controller: OnboardingWizardController): string {
+  const profileName = normalizeText(controller.getStringFieldValue('agent-setup.profile-name', ''));
+  const templateId = controller.getStringFieldValue('agent-setup.profile-template', 'none');
+  if (profileName.length === 0) return 'Current home';
+  return templateId === 'none' ? `Create ${profileName}` : `Create ${profileName} from ${templateId}`;
+}
+
+function buildReviewReadinessFields(controller: OnboardingWizardController): readonly OnboardingWizardFieldDefinition[] {
+  const localBehavior = findRuntimeCapability(controller, 'local-behavior');
+  const channels = findRuntimeCapability(controller, 'communication-channels');
+  const automation = findRuntimeCapability(controller, 'automation-review');
+  const collectionIssues = controller.runtimeSnapshot?.collectionIssues.length ?? 0;
+
+  return [
+    {
+      kind: 'status',
+      id: 'review.readiness.connection',
+      label: 'Runtime connection snapshot',
+      hint: collectionIssues > 0
+        ? `${collectionIssues} setup snapshot issue(s) need attention before this Agent is day-one ready.`
+        : 'The setup snapshot loaded cleanly from the external GoodVibes runtime.',
+      defaultValue: collectionIssues > 0 ? 'Needs attention' : 'Ready',
+      spacerBeforeRows: 1,
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.model',
+      label: 'Default model route',
+      hint: 'Normal assistant turns use this selected provider/model route unless changed later from the model picker.',
+      defaultValue: currentMainModelLabel(controller),
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.profile',
+      label: 'Agent profile',
+      hint: 'Profiles isolate Agent-local config, sessions, memory, personas, skills, routines, and setup state.',
+      defaultValue: profileSetupLabel(controller),
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.knowledge',
+      label: 'Agent Knowledge segment',
+      hint: 'Ask, search, status, and ingest stay on /api/goodvibes-agent/knowledge/* with no default wiki or non-Agent fallback.',
+      defaultValue: 'Isolated',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.local-behavior',
+      label: 'Local behavior library',
+      hint: localBehavior?.detail ?? 'Agent-local memory, routines, skills, and personas remain local until a stable shared registry exists.',
+      defaultValue: localBehavior?.selected ? 'Customized' : 'Starter ready',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.channels',
+      label: 'Channels and notifications',
+      hint: channels?.detail ?? 'Connect only the channels the Agent should use, and keep outbound delivery explicit.',
+      defaultValue: channels?.selected ? 'Review configured' : 'Optional setup',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.automation',
+      label: 'Routines and schedules',
+      hint: automation?.detail ?? 'Local routines run in the main conversation; external schedules require explicit promotion and confirmation.',
+      defaultValue: automation?.selected ? 'Review configured' : 'Local first',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.delegation',
+      label: 'Build delegation',
+      hint: 'Build, fix, implementation, and review work is handed to GoodVibes TUI only when explicitly requested.',
+      defaultValue: 'Explicit only',
+    },
+  ];
+}
+
 export function buildCommunicationStep(): OnboardingWizardStepDefinition {
   return {
     id: 'agent-communication',
@@ -636,14 +729,17 @@ export function buildReviewStep(controller: OnboardingWizardController): Onboard
   const unsavedLabel = controller.dirtyStepCount === 1
     ? '1 screen has unapplied changes'
     : `${controller.dirtyStepCount} screens have unapplied changes`;
+  const collectionIssues = controller.runtimeSnapshot?.collectionIssues.length ?? 0;
+  const dayOneReadiness = collectionIssues > 0 ? `${collectionIssues} connection issue(s) before day-one ready` : 'operator checklist ready';
 
   return {
     id: 'review',
     title: 'Review and apply',
     shortLabel: 'Review',
-    description: 'Review Agent-owned settings and apply them directly from the wizard.',
-    summaryTitle: 'Review posture',
+    description: 'Review the Agent day-one checklist and apply setup directly from the wizard.',
+    summaryTitle: 'Agent day-one readiness',
     summaryLines: [
+      `Day-one readiness: ${dayOneReadiness}`,
       unsavedLabel,
       `${controller.buildApplyRequest().operations.length} Agent setting change(s) ready to apply`,
       feedback ? `Last apply: ${feedback.title}` : 'No apply errors reported',
@@ -651,6 +747,7 @@ export function buildReviewStep(controller: OnboardingWizardController): Onboard
     ],
     fields: [
       ...feedbackFields,
+      ...buildReviewReadinessFields(controller),
       {
         kind: 'status',
         id: 'review.global-marker',

package/src/renderer/agent-workspace.ts

@@ -242,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.78';
+let _version = '0.1.80';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {