@pellux/goodvibes-tui 0.19.28 → 0.19.29

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.29] — 2026-04-24
+
+### Changes
+- 617b8860 feat: improve onboarding and surface setup
+- 5e39b0f8 docs: add onboarding wizard WIP notice to README top
+
 ## [0.19.28] — 2026-04-24
 
 ### Changes

package/README.md

@@ -1,8 +1,10 @@
+> **ATTENTION:** Currently updating the Onboarding Wizard - Expect problems with starting the TUI until this work is complete!
+
 # goodvibes-tui
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.19.28-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.29-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "0.25.2"
+    "version": "0.25.4"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.28",
+  "version": "0.19.29",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -91,7 +91,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "^0.25.2",
+    "@pellux/goodvibes-sdk": "^0.25.4",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/cli/surface-command.ts

@@ -1,4 +1,11 @@
 import type { ConfigKey } from '../config/index.ts';
+import {
+  GOODVIBES_NTFY_AGENT_TOPIC,
+  GOODVIBES_NTFY_CHAT_TOPIC,
+  GOODVIBES_NTFY_REMOTE_TOPIC,
+  resolveGoodVibesNtfyTopics,
+} from '@pellux/goodvibes-sdk/platform/integrations/ntfy';
+import { enableFeatureFlags, getMissingSurfaceFeatureFlags, getServerSurfaceFeatureFlags } from '../runtime/surface-feature-flags.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { classifyBindPosture, isNetworkFacing } from './network-posture.ts';
 import type { CliCommandRuntime } from './management.ts';
@@ -18,7 +25,7 @@ export const SURFACE_CONFIGS = [
   ['discord', 'Discord', ['surfaces.discord.publicKey', 'surfaces.discord.botToken', 'surfaces.discord.applicationId']],
   ['telegram', 'Telegram', ['surfaces.telegram.botToken']],
   ['webhook', 'Webhook', ['surfaces.webhook.secret']],
-  ['ntfy', 'ntfy', ['surfaces.ntfy.baseUrl', 'surfaces.ntfy.topic']],
+  ['ntfy', 'ntfy', ['surfaces.ntfy.baseUrl']],
   ['googleChat', 'Google Chat', ['surfaces.googleChat.webhookUrl']],
   ['signal', 'Signal', ['surfaces.signal.bridgeUrl', 'surfaces.signal.account']],
   ['whatsapp', 'WhatsApp', ['surfaces.whatsapp.accessToken', 'surfaces.whatsapp.phoneNumberId']],
@@ -39,6 +46,7 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
     if (target === 'web') {
       runtime.configManager.setDynamic('web.enabled', enabled);
       if (enabled) {
+        enableFeatureFlags(runtime.configManager, getServerSurfaceFeatureFlags({ serverBacked: true, web: true }));
         runtime.configManager.setDynamic('danger.daemon', true);
         runtime.configManager.setDynamic('controlPlane.enabled', true);
         const webError = applyTargetEndpointFlagsOrDefault(runtime, 'web');
@@ -71,6 +79,7 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
     else if (SURFACE_CONFIGS.some(([id]) => id === target)) {
       runtime.configManager.setDynamic(`surfaces.${target}.enabled` as ConfigKey, enabled);
       if (enabled) {
+        enableFeatureFlags(runtime.configManager, getServerSurfaceFeatureFlags({ serverBacked: true, externalSurfaces: [target] }));
         runtime.configManager.setDynamic('danger.httpListener', true);
         enableEndpointLanDefault(runtime.configManager, 'httpListener');
       }
@@ -88,34 +97,45 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
   const web = resolveRuntimeEndpointBinding(config, 'web');
   const httpListener = resolveRuntimeEndpointBinding(config, 'httpListener');
   const includeProbe = sub === 'check';
+  const targetExternalSurface = target && SURFACE_CONFIGS.some(([id]) => id === target);
+  const shouldProbeControlPlane = includeProbe && !target;
+  const shouldProbeWeb = includeProbe && !target;
+  const shouldProbeListener = includeProbe && (!target || targetExternalSurface);
   const [controlPlaneReachable, webReachable, listenerReachable] = includeProbe
     ? await Promise.all([
-      probeTcp(controlPlane.host, controlPlane.port),
-      probeTcp(web.host, web.port),
-      probeTcp(httpListener.host, httpListener.port),
+      shouldProbeControlPlane ? probeTcp(controlPlane.host, controlPlane.port) : Promise.resolve(undefined),
+      shouldProbeWeb ? probeTcp(web.host, web.port) : Promise.resolve(undefined),
+      shouldProbeListener ? probeTcp(httpListener.host, httpListener.port) : Promise.resolve(undefined),
     ])
     : [undefined, undefined, undefined];
   const externalSurfaces = SURFACE_CONFIGS.map(([id, label, requiredKeys]) => {
     const enabled = config.get(`surfaces.${id}.enabled` as ConfigKey);
     const missing = requiredKeys.filter((key) => !isPresentConfigValue(config.get(key as ConfigKey)));
+    const missingFeatureFlags = enabled === true ? getMissingSurfaceFeatureFlags(config, id) : [];
     return {
       id,
       label,
       enabled,
-      ready: !enabled || missing.length === 0,
+      ready: !enabled || (missing.length === 0 && missingFeatureFlags.length === 0),
       missing,
+      missingFeatureFlags,
     };
   });
   const filteredSurfaces = target ? externalSurfaces.filter((surface) => surface.id === target) : externalSurfaces;
   if (target && filteredSurfaces.length === 0) return { output: `Unknown surface: ${target}`, exitCode: 1 };
+  const ntfyTopics = resolveGoodVibesNtfyTopics({
+    chatTopic: String(config.get('surfaces.ntfy.chatTopic' as ConfigKey) || GOODVIBES_NTFY_CHAT_TOPIC),
+    agentTopic: String(config.get('surfaces.ntfy.agentTopic' as ConfigKey) || GOODVIBES_NTFY_AGENT_TOPIC),
+    remoteTopic: String(config.get('surfaces.ntfy.remoteTopic' as ConfigKey) || GOODVIBES_NTFY_REMOTE_TOPIC),
+  });
   const readinessIssues: string[] = [];
-  if (includeProbe && config.get('controlPlane.enabled') === true && !controlPlaneReachable) {
+  if (shouldProbeControlPlane && config.get('controlPlane.enabled') === true && !controlPlaneReachable) {
     readinessIssues.push(`Control plane is enabled but not reachable on ${controlPlane.host}:${controlPlane.port}.`);
   }
-  if (includeProbe && config.get('web.enabled') === true && !webReachable) {
+  if (shouldProbeWeb && config.get('web.enabled') === true && !webReachable) {
     readinessIssues.push(`Web surface is enabled but not reachable on ${web.host}:${web.port}.`);
   }
-  if (includeProbe && config.get('danger.httpListener') === true && !listenerReachable) {
+  if (shouldProbeListener && config.get('danger.httpListener') === true && !listenerReachable) {
     readinessIssues.push(`HTTP listener is enabled but not reachable on ${httpListener.host}:${httpListener.port}.`);
   }
   for (const surface of filteredSurfaces) {
@@ -126,6 +146,9 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
     if (surface.missing.length > 0) {
       readinessIssues.push(`${surface.label} is enabled but missing ${surface.missing.join(', ')}.`);
     }
+    if (surface.missingFeatureFlags.length > 0) {
+      readinessIssues.push(`${surface.label} is enabled but feature gates are disabled: ${surface.missingFeatureFlags.join(', ')}.`);
+    }
   }
   const value = {
     controlPlane: {
@@ -162,7 +185,15 @@ export async function handleSurfacesCommand(runtime: CliCommandRuntime): Promise
     `  http-listener: ${yesNo(value.httpListener.enabled)} (${value.httpListener.hostMode} ${value.httpListener.host}:${value.httpListener.port})${includeProbe ? ` reachable=${yesNo(value.httpListener.reachable)}` : ''}`,
     '',
     'External surfaces:',
-    ...value.surfaces.map((surface) => `  ${surface.label.padEnd(16)} enabled=${yesNo(surface.enabled)} ready=${yesNo(surface.ready)}${surface.enabled && surface.missing.length > 0 ? ` missing=${surface.missing.join(',')}` : ''}`),
+    ...value.surfaces.map((surface) => `  ${surface.label.padEnd(16)} enabled=${yesNo(surface.enabled)} ready=${yesNo(surface.ready)}${surface.enabled && surface.missing.length > 0 ? ` missing=${surface.missing.join(',')}` : ''}${surface.enabled && surface.missingFeatureFlags.length > 0 ? ` featureGates=${surface.missingFeatureFlags.join(',')}` : ''}`),
+    ...(filteredSurfaces.some((surface) => surface.id === 'ntfy') ? [
+      '',
+      'ntfy inbound topics:',
+      `  chat: ${ntfyTopics.chatTopic}`,
+      `  agent: ${ntfyTopics.agentTopic}`,
+      `  daemon-only remote: ${ntfyTopics.remoteTopic}`,
+      `  default delivery topic: ${String(config.get('surfaces.ntfy.topic') || '(none)')}`,
+    ] : []),
     ...(includeProbe ? [
       readinessIssues.length === 0 ? 'Readiness: ready' : 'Readiness: needs attention',
       ...readinessIssues.map((issue) => `  - ${issue}`),
@@ -191,6 +222,7 @@ export interface ListenerTestResult {
     readonly enabled: unknown;
     readonly ready: boolean;
     readonly missing: readonly string[];
+    readonly missingFeatureFlags: readonly string[];
   }[];
   readonly issues: readonly string[];
 }
@@ -209,12 +241,14 @@ export async function buildListenerTestResult(runtime: CliCommandRuntime): Promi
   const surfaces = SURFACE_CONFIGS.map(([id, label, requiredKeys]) => {
     const surfaceEnabled = runtime.configManager.get(`surfaces.${id}.enabled` as ConfigKey);
     const missing = requiredKeys.filter((key) => !isPresentConfigValue(runtime.configManager.get(key as ConfigKey)));
+    const missingFeatureFlags = surfaceEnabled === true ? getMissingSurfaceFeatureFlags(runtime.configManager, id) : [];
     return {
       id,
       label,
       enabled: surfaceEnabled,
-      ready: surfaceEnabled !== true || missing.length === 0,
+      ready: surfaceEnabled !== true || (missing.length === 0 && missingFeatureFlags.length === 0),
       missing,
+      missingFeatureFlags,
     };
   }).filter((surface) => surface.enabled === true);
   const issues: string[] = [];
@@ -226,6 +260,7 @@ export async function buildListenerTestResult(runtime: CliCommandRuntime): Promi
   if (isNetworkFacing(enabled, binding) && auth.bootstrapCredentialPresent) issues.push('Network-facing listener still has a bootstrap credential file.');
   for (const surface of surfaces) {
     if (surface.missing.length > 0) issues.push(`${surface.label} is enabled but missing ${surface.missing.join(', ')}.`);
+    if (surface.missingFeatureFlags.length > 0) issues.push(`${surface.label} is enabled but feature gates are disabled: ${surface.missingFeatureFlags.join(', ')}.`);
   }
   return { enabled, ...binding, posture, reachable, service, auth, surfaces, issues };
 }
@@ -241,7 +276,7 @@ export function formatListenerTestResult(runtime: CliCommandRuntime, value: List
     `  local auth users: ${value.auth.userStorePresent ? 'present' : 'missing'}`,
     `  bootstrap credential: ${value.auth.bootstrapCredentialPresent ? 'present' : 'missing'}`,
     value.surfaces.length === 0 ? '  enabled webhook surfaces: none' : '  enabled webhook surfaces:',
-    ...value.surfaces.map((surface) => `    ${surface.label}: ready=${yesNo(surface.ready)}${surface.missing.length > 0 ? ` missing=${surface.missing.join(',')}` : ''}`),
+    ...value.surfaces.map((surface) => `    ${surface.label}: ready=${yesNo(surface.ready)}${surface.missing.length > 0 ? ` missing=${surface.missing.join(',')}` : ''}${surface.missingFeatureFlags.length > 0 ? ` featureGates=${surface.missingFeatureFlags.join(',')}` : ''}`),
     value.issues.length === 0 ? '  readiness: ready' : '  readiness: needs attention',
     ...value.issues.map((issue) => `    - ${issue}`),
   ].join('\n'));

package/src/daemon/cli.ts

@@ -3,6 +3,8 @@ import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
 import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
 import { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
+import { createFeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
+import type { FlagState } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/types';
 import { createRuntimeStore } from '../runtime/store/index.ts';
 import { createRuntimeServices } from '../runtime/services.ts';
 import { DaemonServer } from '@pellux/goodvibes-sdk/platform/daemon/server';
@@ -155,8 +157,13 @@ async function main(): Promise<void> {
   }
   const runtimeBus = new RuntimeEventBus();
   const runtimeStore = createRuntimeStore();
+  const featureFlags = createFeatureFlagManager();
+  featureFlags.loadFromConfig({
+    flags: (config.getCategory('featureFlags') as Record<string, FlagState>) ?? {},
+  });
   const runtimeServices = createRuntimeServices({
     configManager: config,
+    featureFlags,
     runtimeBus,
     runtimeStore,
     getConversationTitle: () => 'goodvibes daemon',

package/src/input/handler-onboarding.ts

@@ -2,7 +2,7 @@ import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config/
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config/openai-codex-auth';
 import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils/open-external';
 import { buildProviderAccountSnapshot } from '@pellux/goodvibes-sdk/platform/runtime/provider-accounts/registry';
-import { OnboardingWizardController, type OnboardingWizardAction } from './onboarding/onboarding-wizard.ts';
+import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardApplyFeedback } from './onboarding/onboarding-wizard.ts';
 import { applyOnboardingRequest, collectOnboardingSnapshot, verifyOnboardingRequest } from '../runtime/onboarding/index.ts';
 import type { OnboardingApplyRequest, OnboardingVerificationItem } from '../runtime/onboarding/index.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
@@ -19,6 +19,15 @@ export interface OnboardingRuntimePosture {
   readonly remoteExposure: boolean;
 }
 
+interface OnboardingExternalServiceState {
+  readonly daemonRunning?: boolean;
+  readonly daemonPortInUse?: boolean;
+  readonly httpListenerRunning?: boolean;
+  readonly httpListenerPortInUse?: boolean;
+}
+
+type OnboardingRuntimeEndpoint = 'daemon' | 'httpListener';
+
 function extractAuthorizationCode(input: string): string | null {
   const trimmed = input.trim();
   if (!trimmed) return null;
@@ -41,6 +50,101 @@ function isLoopbackHostValue(value: string | null | undefined): boolean {
     || /^127(?:\.\d{1,3}){3}$/.test(normalized);
 }
 
+function onboardingVerificationStatusRank(item: OnboardingVerificationItem): number {
+  if (item.status === 'fail') return 3;
+  if (item.status === 'warn') return 2;
+  return 1;
+}
+
+function dedupeOnboardingVerificationItems(
+  items: readonly OnboardingVerificationItem[],
+): OnboardingVerificationItem[] {
+  const order: string[] = [];
+  const byId = new Map<string, OnboardingVerificationItem>();
+  for (const item of items) {
+    const existing = byId.get(item.id);
+    if (!existing) {
+      order.push(item.id);
+      byId.set(item.id, item);
+      continue;
+    }
+    if (onboardingVerificationStatusRank(item) > onboardingVerificationStatusRank(existing)) {
+      byId.set(item.id, item);
+    }
+  }
+  return order.map((id) => byId.get(id)).filter((item): item is OnboardingVerificationItem => Boolean(item));
+}
+
+function formatOnboardingApplyCompletionMessage(items: readonly OnboardingVerificationItem[]): string {
+  const warnings = items.filter((item) => item.status === 'warn');
+  if (warnings.length === 0) return `Onboarding applied and verified ${items.length} item(s).`;
+  const passed = items.filter((item) => item.status === 'pass').length;
+  return [
+    `Onboarding settings applied. ${passed} verification item(s) passed; ${warnings.length} warning(s) need attention.`,
+    ...warnings.map((warning) => `  warning ${warning.id}: ${warning.message}`),
+  ].join('\n');
+}
+
+function getRuntimeEndpointBinding(
+  handler: InputHandler,
+  request: OnboardingApplyRequest,
+  endpoint: OnboardingRuntimeEndpoint,
+): { readonly label: string; readonly host: string; readonly port: number } {
+  const hostKey = endpoint === 'daemon' ? 'controlPlane.host' : 'httpListener.host';
+  const portKey = endpoint === 'daemon' ? 'controlPlane.port' : 'httpListener.port';
+  const fallbackHost = '127.0.0.1';
+  const fallbackPort = endpoint === 'daemon' ? 3421 : 3422;
+  const rawHost = handler.getOnboardingConfigValue(request, hostKey);
+  const rawPort = handler.getOnboardingConfigValue(request, portKey);
+  const parsedPort = typeof rawPort === 'number' ? rawPort : Number(rawPort);
+  return {
+    label: endpoint === 'daemon' ? 'GoodVibes daemon' : 'HTTP listener',
+    host: String(rawHost ?? fallbackHost),
+    port: Number.isFinite(parsedPort) ? parsedPort : fallbackPort,
+  };
+}
+
+function runtimePortDiagnostic(
+  binding: { readonly label: string; readonly host: string; readonly port: number },
+  portInUse: boolean | undefined,
+): string {
+  if (portInUse) {
+    return `The configured port ${binding.host}:${binding.port} is occupied after restart; another GoodVibes process, an overlapping restart, or another service may still own it.`;
+  }
+  return `No process is listening on ${binding.host}:${binding.port} after restart.`;
+}
+
+function formatRuntimeActiveFailureMessage(
+  handler: InputHandler,
+  request: OnboardingApplyRequest,
+  endpoint: OnboardingRuntimeEndpoint,
+  state: OnboardingExternalServiceState | undefined,
+): string {
+  const binding = getRuntimeEndpointBinding(handler, request, endpoint);
+  const portInUse = endpoint === 'daemon' ? state?.daemonPortInUse : state?.httpListenerPortInUse;
+  const impact = endpoint === 'daemon'
+    ? 'browser, LAN, and service-backed GoodVibes surfaces may be unavailable until the daemon is running there.'
+    : 'incoming webhooks and event surfaces will not receive traffic until the listener is running there.';
+  return `${binding.label} is enabled for ${binding.host}:${binding.port}, but onboarding could not confirm it is running in this TUI instance after restart. ${runtimePortDiagnostic(binding, portInUse)} Settings were saved; ${impact}`;
+}
+
+function formatRuntimeStoppedFailureMessage(
+  handler: InputHandler,
+  request: OnboardingApplyRequest,
+  endpoint: OnboardingRuntimeEndpoint,
+): string {
+  const binding = getRuntimeEndpointBinding(handler, request, endpoint);
+  const disabledSurface = endpoint === 'daemon' ? 'server-backed surfaces' : 'incoming event surfaces';
+  return `${binding.label} was disabled for ${disabledSurface}, but ${binding.host}:${binding.port} is still occupied. Settings were saved; another GoodVibes process or external service may still be running on that port.`;
+}
+
+function showOnboardingApplyFeedbackForHandler(handler: InputHandler, feedback: OnboardingWizardApplyFeedback): void {
+    handler.onboardingWizard.setApplyFeedback(feedback);
+    const reviewIndex = handler.onboardingWizard.steps.findIndex((step) => step.id === 'review');
+    if (reviewIndex >= 0) handler.onboardingWizard.setStep(reviewIndex);
+    handler.requestRender();
+  }
+
 export function clearOnboardingPendingModelPickerTargetForHandler(handler: InputHandler): void {
     handler.onboardingWizard.clearPendingModelPickerTarget();
   }
@@ -115,15 +219,17 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
     if (handler.onboardingApplyPending) return;
     const blockers = handler.onboardingWizard.getBlockingFieldLabels();
     if (blockers.length > 0) {
-      handler.commandContext?.print?.([
-        'Onboarding needs these fields before applying.',
-        ...blockers.map((label) => `  ${label}`),
-      ].join('\n'));
-      handler.requestRender();
+      showOnboardingApplyFeedbackForHandler(handler, {
+        severity: 'error',
+        title: 'Cannot apply yet',
+        summary: 'Fix these required or invalid fields, then apply again.',
+        messages: blockers,
+      });
       return;
     }
 
     const request = handler.onboardingWizard.buildApplyRequest();
+    handler.onboardingWizard.clearApplyFeedback();
     const deps = {
       config: handler.uiServices.platform.configManager,
       secrets: handler.uiServices.platform.secretsManager,
@@ -133,43 +239,48 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
     };
     let appliedErrors: string[] = [];
     let verificationItems: readonly OnboardingVerificationItem[] = [];
+    let runtimeWarnings: readonly OnboardingVerificationItem[] = [];
     handler.onboardingApplyPending = true;
     try {
       const applied = await applyOnboardingRequest(deps, request);
-      const verification = await verifyOnboardingRequest(deps, request);
-      verificationItems = verification.items;
-      appliedErrors = [
-        ...applied.errors.map((error) => `apply ${error.kind}: ${error.message}`),
-        ...verification.items
-          .filter((item) => item.status !== 'pass')
-          .map((item) => `verify ${item.id}: ${item.message}`),
-      ];
+      if (applied.errors.length > 0) {
+        appliedErrors = applied.errors.map((error) => `apply ${error.kind}: ${error.message}`);
+      } else {
+        const verification = await verifyOnboardingRequest(deps, request);
+        verificationItems = verification.items;
+        appliedErrors = verification.items
+          .filter((item) => item.status === 'fail')
+          .map((item) => `verify ${item.id}: ${item.message}`);
+      }
 
       if (appliedErrors.length === 0) {
         const activationVerification = await handler.restartOnboardingExternalServicesIfNeeded(request);
-        const runtimeVerification = [...activationVerification, ...handler.verifyOnboardingRuntimePosture(request)];
-        verificationItems = [...verification.items, ...runtimeVerification];
-        appliedErrors = runtimeVerification
-          .filter((item) => item.status === 'fail')
-          .map((item) => `verify ${item.id}: ${item.message}`);
+        runtimeWarnings = dedupeOnboardingVerificationItems([...activationVerification, ...handler.verifyOnboardingRuntimePosture(request)]
+          .map((item): OnboardingVerificationItem => item.status === 'fail'
+            ? { ...item, status: 'warn' }
+            : item));
+        verificationItems = dedupeOnboardingVerificationItems([...verificationItems, ...runtimeWarnings]);
       }
     } catch (error) {
-      handler.commandContext?.print?.([
-        'Onboarding apply did not complete.',
-        `  ${error instanceof Error ? error.message : String(error)}`,
-      ].join('\n'));
-      handler.requestRender();
+      showOnboardingApplyFeedbackForHandler(handler, {
+        severity: 'error',
+        title: 'Apply failed',
+        summary: 'The wizard could not persist these settings. No service restart was attempted.',
+        messages: [error instanceof Error ? error.message : String(error)],
+      });
       return;
     } finally {
       handler.onboardingApplyPending = false;
+      handler.requestRender();
     }
 
     if (appliedErrors.length > 0) {
-      handler.commandContext?.print?.([
-        'Onboarding apply did not complete.',
-        ...appliedErrors.map((error) => `  ${error}`),
-      ].join('\n'));
-      handler.requestRender();
+      showOnboardingApplyFeedbackForHandler(handler, {
+        severity: 'error',
+        title: 'Apply did not complete',
+        summary: 'The settings were not fully applied. Review the messages below and try again.',
+        messages: appliedErrors,
+      });
       return;
     }
 
@@ -185,11 +296,7 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
       handler.indicatorFocused = returnFocus === 'indicator';
       handler.modalReturnFocus = 'prompt';
     }
-    const warnings = verificationItems.filter((item) => item.status === 'warn');
-    handler.commandContext?.print?.([
-      `Onboarding applied and verified ${verificationItems.length} item(s).`,
-      ...warnings.map((warning) => `  warning ${warning.id}: ${warning.message}`),
-    ].join('\n'));
+    handler.commandContext?.print?.(formatOnboardingApplyCompletionMessage(verificationItems));
     handler.requestRender();
   }
 
@@ -472,7 +579,7 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
         failures.push({
           id: 'runtime:daemon-active',
           status: 'fail',
-          message: 'The GoodVibes daemon did not start after applying onboarding settings.',
+          message: formatRuntimeActiveFailureMessage(handler, request, 'daemon', state),
           target: 'service',
         });
       }
@@ -480,7 +587,7 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
         failures.push({
           id: 'runtime:daemon-stopped',
           status: 'fail',
-          message: 'The GoodVibes daemon port is still occupied after onboarding disabled server-backed surfaces.',
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
           target: 'service',
         });
       }
@@ -488,7 +595,7 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
         failures.push({
           id: 'runtime:http-listener-active',
           status: 'fail',
-          message: 'The HTTP listener did not start after applying onboarding settings.',
+          message: formatRuntimeActiveFailureMessage(handler, request, 'httpListener', state),
           target: 'service',
         });
       }
@@ -496,7 +603,7 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
         failures.push({
           id: 'runtime:http-listener-stopped',
           status: 'fail',
-          message: 'The HTTP listener port is still occupied after onboarding disabled incoming event surfaces.',
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
           target: 'service',
         });
       }
@@ -537,7 +644,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
         stoppedItems.push({
           id: 'runtime:daemon-stopped',
           status: 'fail',
-          message: 'The GoodVibes daemon port is still occupied after onboarding disabled server-backed surfaces.',
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
           target: 'service',
         });
       }
@@ -545,7 +652,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
         stoppedItems.push({
           id: 'runtime:http-listener-stopped',
           status: 'fail',
-          message: 'The HTTP listener port is still occupied after onboarding disabled incoming event surfaces.',
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
           target: 'service',
         });
       }
@@ -597,7 +704,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
         status: externalState?.daemonRunning ? 'pass' : 'fail',
         message: externalState?.daemonRunning
           ? 'The GoodVibes daemon is running with the applied onboarding settings.'
-          : 'The GoodVibes daemon is not running after onboarding apply.',
+          : formatRuntimeActiveFailureMessage(handler, request, 'daemon', externalState),
         target: 'service',
       });
     }
@@ -605,7 +712,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
       items.push({
         id: 'runtime:daemon-stopped',
         status: 'fail',
-        message: 'The GoodVibes daemon port is still occupied after onboarding disabled server-backed surfaces.',
+        message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
         target: 'service',
       });
     }
@@ -615,7 +722,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
         status: externalState?.httpListenerRunning ? 'pass' : 'fail',
         message: externalState?.httpListenerRunning
           ? 'The HTTP listener is running with the applied onboarding settings.'
-          : 'The HTTP listener is not running after onboarding apply.',
+          : formatRuntimeActiveFailureMessage(handler, request, 'httpListener', externalState),
         target: 'service',
       });
     }
@@ -623,7 +730,7 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
       items.push({
         id: 'runtime:http-listener-stopped',
         status: 'fail',
-        message: 'The HTTP listener port is still occupied after onboarding disabled incoming event surfaces.',
+        message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
         target: 'service',
       });
     }

package/src/input/onboarding/handler-onboarding-routes.ts

@@ -64,6 +64,8 @@ export function handleOnboardingWizardToken(state: OnboardingRouteState, token:
     if (editing) {
       if (isEnterKey(token)) {
         state.onboardingWizard.commitEdit();
+      } else if ((token.ctrl && token.logicalName === 'u') || token.logicalName === 'delete') {
+        state.onboardingWizard.clearEditingValue();
       } else if (token.logicalName === 'backspace') {
         state.onboardingWizard.editBackspace();
       } else {
@@ -97,6 +99,8 @@ export function handleOnboardingWizardToken(state: OnboardingRouteState, token:
       }
       if (isEnterKey(token) || token.logicalName === 'space') {
         activateSelection(state);
+      } else if ((token.ctrl && token.logicalName === 'u') || token.logicalName === 'delete') {
+        state.onboardingWizard.clearSelectedTextField();
       } else if (token.logicalName === 'backspace') {
         state.onboardingWizard.editBackspace();
       }