@pellux/goodvibes-tui 0.19.49 → 0.19.51

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.51] — 2026-04-28
+
+### Changed
+- Updated `@pellux/goodvibes-sdk` to `0.26.6`.
+- Embedded and standalone daemon hosts now wrap Bun request handlers so unexpected daemon/listener route exceptions return bounded JSON errors and are logged instead of printing raw stack/source output into the TUI terminal.
+
+### Fixed
+- Picked up SDK Home Assistant Home Graph snapshot sync fixes for Home Assistant-native snake_case registry fields, incomplete registry objects, and JSON error responses from Home Graph admin routes.
+
+---
+
+## [0.19.50] — 2026-04-28
+
+### Changed
+- Updated `@pellux/goodvibes-sdk` to `0.26.5`.
+- TUI external-service inspection now uses SDK `daemonStatus` and `httpListenerStatus` startup modes to distinguish embedded services, verified external daemons, blocked ports, disabled services, and unavailable services.
+
+### Fixed
+- Treats a verified external GoodVibes daemon on the configured host/port as active instead of reporting daemon activation failure during onboarding.
+- Reports SDK-provided blocked/unavailable startup reasons in onboarding runtime verification warnings.
+
+---
+
 ## [0.19.49] — 2026-04-28
 
 ### Changed

package/README.md

@@ -2,7 +2,7 @@
 
 [![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.49-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.51-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.26.4"
+    "version": "0.26.6"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.49",
+  "version": "0.19.51",
   "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.26.4",
+    "@pellux/goodvibes-sdk": "0.26.6",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/daemon/cli.ts

@@ -26,6 +26,7 @@ import {
   loadPersistedProviders,
   persistProviders,
 } from '@pellux/goodvibes-sdk/platform/discovery/index';
+import { createSafeHostServeFactory } from './safe-serve.ts';
 
 import {
   parseGoodVibesCli,
@@ -195,11 +196,17 @@ async function main(): Promise<void> {
   });
 
   const userAuth = runtimeServices.localUserAuthManager;
-  const daemon = new DaemonServer({ runtimeBus, userAuth, runtimeServices });
+  const daemon = new DaemonServer({
+    runtimeBus,
+    userAuth,
+    runtimeServices,
+    serveFactory: createSafeHostServeFactory('Standalone daemon'),
+  });
   const listener = new HttpListener({
     hookDispatcher: runtimeServices.hookDispatcher,
     userAuth,
     configManager: config,
+    serveFactory: createSafeHostServeFactory('Standalone HTTP listener'),
   });
   const { daemonToken, httpToken } = readDaemonCliTokens(process.env);
 

package/src/daemon/safe-serve.ts

@@ -0,0 +1,61 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+
+type HostServeFetch = (
+  request: Request,
+  server: unknown,
+) => Response | undefined | Promise<Response | undefined>;
+
+type HostServeOptions = Parameters<typeof Bun.serve>[0] & {
+  fetch?: HostServeFetch;
+};
+
+function requestPath(request: Request): string {
+  try {
+    return new URL(request.url).pathname;
+  } catch {
+    return request.url;
+  }
+}
+
+export function createHostRequestFailureResponse(
+  surface: string,
+  request: Request,
+  error: unknown,
+): Response {
+  const message = summarizeError(error);
+  logger.error(`${surface}: request handler failed`, {
+    method: request.method,
+    path: requestPath(request),
+    error: message,
+  });
+  return Response.json({
+    error: message,
+    code: 'HOST_REQUEST_HANDLER_FAILED',
+  }, { status: 500 });
+}
+
+export function createSafeHostServeFactory(
+  surface: string,
+  baseServeFactory: typeof Bun.serve = Bun.serve,
+): typeof Bun.serve {
+  return ((options: HostServeOptions) => {
+    const originalFetch = options.fetch;
+    if (typeof originalFetch !== 'function') {
+      return baseServeFactory(options as Parameters<typeof Bun.serve>[0]);
+    }
+
+    const wrappedFetch: HostServeFetch = async (request, server) => {
+      try {
+        return await originalFetch(request, server);
+      } catch (error) {
+        return createHostRequestFailureResponse(surface, request, error);
+      }
+    };
+
+    return baseServeFactory({
+      ...options,
+      fetch: wrappedFetch,
+    } as Parameters<typeof Bun.serve>[0]);
+  }) as typeof Bun.serve;
+}

package/src/input/handler-onboarding.ts

@@ -9,6 +9,15 @@ import type { OnboardingApplyRequest, OnboardingVerificationItem } from '../runt
 import type { ModelPickerTarget } from './model-picker.ts';
 import { captureOnboardingWizardSnapshot, restoreOnboardingWizardSnapshot } from './handler-ui-state.ts';
 import type { InputHandler } from './handler.ts';
+import {
+  formatRuntimeActiveSuccessMessage,
+  getRuntimeEndpointStatus,
+  isRuntimeEndpointActive,
+  isRuntimeEndpointOccupyingConfiguredPort,
+  runtimePortDiagnostic,
+  type OnboardingExternalServiceState,
+  type OnboardingRuntimeEndpoint,
+} from './onboarding/onboarding-runtime-status.ts';
 
 export interface OnboardingRuntimePosture {
   readonly serviceEnabled: boolean;
@@ -20,15 +29,6 @@ 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;
@@ -105,16 +105,6 @@ function getRuntimeEndpointBinding(
   };
 }
 
-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,
@@ -123,20 +113,24 @@ function formatRuntimeActiveFailureMessage(
 ): string {
   const binding = getRuntimeEndpointBinding(handler, request, endpoint);
   const portInUse = endpoint === 'daemon' ? state?.daemonPortInUse : state?.httpListenerPortInUse;
+  const status = getRuntimeEndpointStatus(state, endpoint);
   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}`;
+  return `${binding.label} is enabled for ${binding.host}:${binding.port}, but onboarding could not confirm an embedded or verified external service after restart. ${runtimePortDiagnostic(binding, portInUse, status)} Settings were saved; ${impact}`;
 }
 
 function formatRuntimeStoppedFailureMessage(
   handler: InputHandler,
   request: OnboardingApplyRequest,
   endpoint: OnboardingRuntimeEndpoint,
+  state?: OnboardingExternalServiceState,
 ): string {
   const binding = getRuntimeEndpointBinding(handler, request, endpoint);
+  const status = getRuntimeEndpointStatus(state, 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.`;
+  const statusDetail = status ? ` ${runtimePortDiagnostic(binding, undefined, status)}` : '';
+  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.${statusDetail}`;
 }
 
 function showOnboardingApplyFeedbackForHandler(handler: InputHandler, feedback: OnboardingWizardApplyFeedback): void {
@@ -611,16 +605,14 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
     }
 
     const currentState = externalServices.inspect();
-    const hasLiveExternalServices = currentState.daemonRunning === true
-      || currentState.daemonPortInUse === true
-      || currentState.httpListenerRunning === true
-      || currentState.httpListenerPortInUse === true;
+    const hasLiveExternalServices = isRuntimeEndpointOccupyingConfiguredPort(currentState, 'daemon')
+      || isRuntimeEndpointOccupyingConfiguredPort(currentState, 'httpListener');
     if (!posture.serverBacked && !hasLiveExternalServices) return [];
 
     try {
       const state = await externalServices.restart();
       const failures: OnboardingVerificationItem[] = [];
-      if (posture.expectedDaemon && !state.daemonRunning) {
+      if (posture.expectedDaemon && !isRuntimeEndpointActive(state, 'daemon')) {
         failures.push({
           id: 'runtime:daemon-active',
           status: 'fail',
@@ -628,15 +620,15 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
           target: 'service',
         });
       }
-      if (!posture.expectedDaemon && (state.daemonRunning || state.daemonPortInUse)) {
+      if (!posture.expectedDaemon && isRuntimeEndpointOccupyingConfiguredPort(state, 'daemon')) {
         failures.push({
           id: 'runtime:daemon-stopped',
           status: 'fail',
-          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon', state),
           target: 'service',
         });
       }
-      if (posture.expectedHttpListener && !state.httpListenerRunning) {
+      if (posture.expectedHttpListener && !isRuntimeEndpointActive(state, 'httpListener')) {
         failures.push({
           id: 'runtime:http-listener-active',
           status: 'fail',
@@ -644,11 +636,11 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
           target: 'service',
         });
       }
-      if (!posture.expectedHttpListener && (state.httpListenerRunning || state.httpListenerPortInUse)) {
+      if (!posture.expectedHttpListener && isRuntimeEndpointOccupyingConfiguredPort(state, 'httpListener')) {
         failures.push({
           id: 'runtime:http-listener-stopped',
           status: 'fail',
-          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener', state),
           target: 'service',
         });
       }
@@ -685,19 +677,19 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
       }
 
       const stoppedItems: OnboardingVerificationItem[] = [];
-      if (externalState?.daemonRunning || externalState?.daemonPortInUse) {
+      if (isRuntimeEndpointOccupyingConfiguredPort(externalState, 'daemon')) {
         stoppedItems.push({
           id: 'runtime:daemon-stopped',
           status: 'fail',
-          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon', externalState),
           target: 'service',
         });
       }
-      if (externalState?.httpListenerRunning || externalState?.httpListenerPortInUse) {
+      if (isRuntimeEndpointOccupyingConfiguredPort(externalState, 'httpListener')) {
         stoppedItems.push({
           id: 'runtime:http-listener-stopped',
           status: 'fail',
-          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
+          message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener', externalState),
           target: 'service',
         });
       }
@@ -744,38 +736,40 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
     }
 
     if (posture.expectedDaemon) {
+      const daemonActive = isRuntimeEndpointActive(externalState, 'daemon');
       items.push({
         id: 'runtime:daemon-active',
-        status: externalState?.daemonRunning ? 'pass' : 'fail',
-        message: externalState?.daemonRunning
-          ? 'The GoodVibes daemon is running with the applied onboarding settings.'
+        status: daemonActive ? 'pass' : 'fail',
+        message: daemonActive
+          ? formatRuntimeActiveSuccessMessage('daemon', externalState)
           : formatRuntimeActiveFailureMessage(handler, request, 'daemon', externalState),
         target: 'service',
       });
     }
-    if (!posture.expectedDaemon && (externalState?.daemonRunning || externalState?.daemonPortInUse)) {
+    if (!posture.expectedDaemon && isRuntimeEndpointOccupyingConfiguredPort(externalState, 'daemon')) {
       items.push({
         id: 'runtime:daemon-stopped',
         status: 'fail',
-        message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon'),
+        message: formatRuntimeStoppedFailureMessage(handler, request, 'daemon', externalState),
         target: 'service',
       });
     }
     if (posture.expectedHttpListener) {
+      const httpListenerActive = isRuntimeEndpointActive(externalState, 'httpListener');
       items.push({
         id: 'runtime:http-listener-active',
-        status: externalState?.httpListenerRunning ? 'pass' : 'fail',
-        message: externalState?.httpListenerRunning
-          ? 'The HTTP listener is running with the applied onboarding settings.'
+        status: httpListenerActive ? 'pass' : 'fail',
+        message: httpListenerActive
+          ? formatRuntimeActiveSuccessMessage('httpListener', externalState)
           : formatRuntimeActiveFailureMessage(handler, request, 'httpListener', externalState),
         target: 'service',
       });
     }
-    if (!posture.expectedHttpListener && (externalState?.httpListenerRunning || externalState?.httpListenerPortInUse)) {
+    if (!posture.expectedHttpListener && isRuntimeEndpointOccupyingConfiguredPort(externalState, 'httpListener')) {
       items.push({
         id: 'runtime:http-listener-stopped',
         status: 'fail',
-        message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener'),
+        message: formatRuntimeStoppedFailureMessage(handler, request, 'httpListener', externalState),
         target: 'service',
       });
     }

package/src/input/onboarding/onboarding-runtime-status.ts

@@ -0,0 +1,87 @@
+import type { HostServiceStatus } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-services';
+
+export interface OnboardingExternalServiceState {
+  readonly daemonRunning?: boolean;
+  readonly daemonPortInUse?: boolean;
+  readonly httpListenerRunning?: boolean;
+  readonly httpListenerPortInUse?: boolean;
+  readonly daemonStatus?: HostServiceStatus;
+  readonly httpListenerStatus?: HostServiceStatus;
+}
+
+export type OnboardingRuntimeEndpoint = 'daemon' | 'httpListener';
+
+export function runtimePortDiagnostic(
+  binding: { readonly label: string; readonly host: string; readonly port: number },
+  portInUse: boolean | undefined,
+  status?: HostServiceStatus,
+): string {
+  if (status) {
+    const reason = status.reason ? ` ${status.reason}` : '';
+    if (status.mode === 'blocked') {
+      return `The configured endpoint ${status.baseUrl} is occupied but was not usable by this TUI instance.${reason}`;
+    }
+    if (status.mode === 'disabled') {
+      return `The configured endpoint ${status.baseUrl} is disabled in the runtime service configuration.${reason}`;
+    }
+    if (status.mode === 'unavailable') {
+      return `The configured endpoint ${status.baseUrl} is unavailable after startup or restart.${reason}`;
+    }
+    if (status.mode === 'external') {
+      const version = status.version ? ` version ${status.version}` : '';
+      return `An existing GoodVibes service was verified at ${status.baseUrl}${version}.`;
+    }
+    return `An embedded GoodVibes service is running at ${status.baseUrl}.`;
+  }
+  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.`;
+}
+
+export function getRuntimeEndpointStatus(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): HostServiceStatus | undefined {
+  return endpoint === 'daemon' ? state?.daemonStatus : state?.httpListenerStatus;
+}
+
+export function isRuntimeEndpointActive(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): boolean {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  if (status) return status.mode === 'embedded' || status.mode === 'external';
+  return endpoint === 'daemon'
+    ? state?.daemonRunning === true
+    : state?.httpListenerRunning === true;
+}
+
+export function isRuntimeEndpointOccupyingConfiguredPort(
+  state: OnboardingExternalServiceState | undefined,
+  endpoint: OnboardingRuntimeEndpoint,
+): boolean {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  if (status) return status.mode === 'embedded' || status.mode === 'external' || status.mode === 'blocked';
+  return endpoint === 'daemon'
+    ? state?.daemonRunning === true || state?.daemonPortInUse === true
+    : state?.httpListenerRunning === true || state?.httpListenerPortInUse === true;
+}
+
+export function formatRuntimeActiveSuccessMessage(
+  endpoint: OnboardingRuntimeEndpoint,
+  state: OnboardingExternalServiceState | undefined,
+): string {
+  const status = getRuntimeEndpointStatus(state, endpoint);
+  const label = endpoint === 'daemon' ? 'GoodVibes daemon' : 'HTTP listener';
+  if (status?.mode === 'external') {
+    const version = status.version ? ` version ${status.version}` : '';
+    return `${label} is already running as a verified external GoodVibes service at ${status.baseUrl}${version}.`;
+  }
+  if (status?.mode === 'embedded') {
+    return `${label} is running as an embedded service at ${status.baseUrl}.`;
+  }
+  return endpoint === 'daemon'
+    ? 'The GoodVibes daemon is running with the applied onboarding settings.'
+    : 'The HTTP listener is running with the applied onboarding settings.';
+}

package/src/runtime/bootstrap.ts

@@ -10,7 +10,6 @@
  *   - lifecycle.ts: save/shutdown helpers
  */
 import { join } from 'node:path';
-import net from 'node:net';
 import { Orchestrator, type OrchestratorUserInputOptions } from '../core/orchestrator.ts';
 import { AcpManager } from '@pellux/goodvibes-sdk/platform/acp/manager';
 import { getTierPromptSupplement, getTierForContextWindow } from '@pellux/goodvibes-sdk/platform/providers/tier-prompts';
@@ -36,7 +35,7 @@ import {
 } from '@pellux/goodvibes-sdk/platform/runtime/session-persistence';
 import { startBackgroundProviderRegistration } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-background';
 import { restoreSavedModel } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-helpers';
-import { startExternalServices, type ExternalServicesHandle } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-services';
+import { startExternalServices, type ExternalServicesHandle, type HostServiceStatus } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-services';
 import { getOrCreateCompanionToken, pruneStaleOperatorTokens } from '@pellux/goodvibes-sdk/platform/pairing/companion-token';
 import { workspaceOperatorTokenCandidates } from './operator-token-cleanup.ts';
 import type { UiRuntimeServices } from './ui-services.ts';
@@ -44,6 +43,11 @@ import { createDeferredStartupCoordinator } from '@pellux/goodvibes-sdk/platform
 import { initializeBootstrapCore } from './bootstrap-core.ts';
 import { createBootstrapShell } from './bootstrap-shell.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { DaemonServer } from '@pellux/goodvibes-sdk/platform/daemon/server';
+import { HttpListener } from '@pellux/goodvibes-sdk/platform/daemon/http-listener';
+import { createSafeHostServeFactory } from '../daemon/safe-serve.ts';
+
+type ExternalServiceFactories = NonNullable<Parameters<typeof startExternalServices>[3]>;
 
 // ── Bootstrap context type ──────────────────────────────────────────────────
 
@@ -295,80 +299,45 @@ export async function bootstrapRuntime(
 
   const deferredStartup = createDeferredStartupCoordinator();
 
-  interface ExternalServiceBindingSnapshot {
-    readonly daemon: {
-      readonly host: string;
-      readonly port: number;
-    };
-    readonly httpListener: {
-      readonly host: string;
-      readonly port: number;
-    };
-  }
-
-  interface ExternalServicePortState {
-    readonly daemonPortInUse: boolean;
-    readonly httpListenerPortInUse: boolean;
-  }
-
-  const readExternalServiceBindings = (): ExternalServiceBindingSnapshot => ({
-    daemon: {
-      host: String(configManager.get('controlPlane.host') ?? '127.0.0.1'),
-      port: Number(configManager.get('controlPlane.port') ?? 3421),
-    },
-    httpListener: {
-      host: String(configManager.get('httpListener.host') ?? '127.0.0.1'),
-      port: Number(configManager.get('httpListener.port') ?? 3422),
-    },
-  });
-
-  const getProbeHosts = (host: string): readonly string[] => {
+  const formatHostServiceBaseUrl = (host: string, port: number): string => {
     const normalized = host.trim().toLowerCase();
-    if (normalized === '0.0.0.0') return ['127.0.0.1'];
-    if (normalized === '::' || normalized === '[::]') return ['::1'];
-    if (normalized.length === 0) return ['127.0.0.1'];
-    return [host];
+    const probeHost = normalized === '0.0.0.0'
+      ? '127.0.0.1'
+      : normalized === '::' || normalized === '[::]'
+        ? '::1'
+        : host;
+    const urlHost = probeHost.includes(':') && !probeHost.startsWith('[') ? `[${probeHost}]` : probeHost;
+    return `http://${urlHost}:${port}`;
   };
 
-  const isTcpPortInUse = async (host: string, port: number): Promise<boolean> => new Promise((resolve) => {
-    const socket = new net.Socket();
-    let settled = false;
-    const finish = (result: boolean): void => {
-      if (settled) return;
-      settled = true;
-      socket.destroy();
-      resolve(result);
+  const createPendingServiceStatus = (
+    service: 'daemon' | 'httpListener',
+  ): HostServiceStatus => {
+    const host = String(configManager.get(service === 'daemon' ? 'controlPlane.host' : 'httpListener.host') ?? '127.0.0.1');
+    const port = Number(configManager.get(service === 'daemon' ? 'controlPlane.port' : 'httpListener.port') ?? (service === 'daemon' ? 3421 : 3422));
+    return {
+      mode: 'unavailable',
+      host,
+      port,
+      baseUrl: formatHostServiceBaseUrl(host, port),
+      reason: 'Background service startup has not completed yet',
     };
+  };
 
-    socket.setTimeout(250);
-    socket.once('connect', () => finish(true));
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-    socket.connect(port, host);
-  });
-
-  const inspectExternalPorts = async (
-    bindings: readonly ExternalServiceBindingSnapshot[],
-  ): Promise<ExternalServicePortState> => {
-    const daemonTargets = new Map<string, { readonly host: string; readonly port: number }>();
-    const listenerTargets = new Map<string, { readonly host: string; readonly port: number }>();
-    for (const binding of bindings) {
-      for (const host of getProbeHosts(binding.daemon.host)) {
-        daemonTargets.set(`${host}:${binding.daemon.port}`, { host, port: binding.daemon.port });
-      }
-      for (const host of getProbeHosts(binding.httpListener.host)) {
-        listenerTargets.set(`${host}:${binding.httpListener.port}`, { host, port: binding.httpListener.port });
-      }
-    }
+  const hostServiceIsActive = (status: HostServiceStatus): boolean => status.mode === 'embedded' || status.mode === 'external';
 
-    const [daemonResults, listenerResults] = await Promise.all([
-      Promise.all([...daemonTargets.values()].map((target) => isTcpPortInUse(target.host, target.port))),
-      Promise.all([...listenerTargets.values()].map((target) => isTcpPortInUse(target.host, target.port))),
-    ]);
+  const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked';
 
+  const inspectExternalServices = () => {
+    const daemonStatus = externalServices.daemonStatus;
+    const httpListenerStatus = externalServices.httpListenerStatus;
     return {
-      daemonPortInUse: daemonResults.some(Boolean),
-      httpListenerPortInUse: listenerResults.some(Boolean),
+      daemonRunning: hostServiceIsActive(daemonStatus),
+      daemonPortInUse: hostServiceIsBlocked(daemonStatus),
+      httpListenerRunning: hostServiceIsActive(httpListenerStatus),
+      httpListenerPortInUse: hostServiceIsBlocked(httpListenerStatus),
+      daemonStatus,
+      httpListenerStatus,
     };
   };
 
@@ -386,24 +355,31 @@ export async function bootstrapRuntime(
     ]);
   };
 
+  const createExternalServiceFactories = (sharedDaemonToken: string): ExternalServiceFactories => ({
+    sharedDaemonToken,
+    createDaemonServer: (bus, userAuth, runtimeServices) => new DaemonServer({
+      runtimeBus: bus,
+      userAuth,
+      runtimeServices,
+      serveFactory: createSafeHostServeFactory('Embedded daemon'),
+    }),
+    createHttpListener: (dispatcher, userAuth, configManager) => new HttpListener({
+      hookDispatcher: dispatcher,
+      userAuth,
+      configManager,
+      serveFactory: createSafeHostServeFactory('Embedded HTTP listener'),
+    }),
+  });
+
   let externalServices: ExternalServicesHandle = {
     daemonServer: null,
     httpListener: null,
+    daemonStatus: createPendingServiceStatus('daemon'),
+    httpListenerStatus: createPendingServiceStatus('httpListener'),
     listRecentControlPlaneEvents: () => [],
     async stop(): Promise<void> {},
   };
   let externalServicesPromise: Promise<ExternalServicesHandle> | null = null;
-  let externalServiceBindings = readExternalServiceBindings();
-  let externalServicePortState: ExternalServicePortState = {
-    daemonPortInUse: false,
-    httpListenerPortInUse: false,
-  };
-  const inspectExternalServices = () => ({
-    daemonRunning: externalServices.daemonServer !== null,
-    daemonPortInUse: externalServicePortState.daemonPortInUse,
-    httpListenerRunning: externalServices.httpListener !== null,
-    httpListenerPortInUse: externalServicePortState.httpListenerPortInUse,
-  });
   const platformExternalServices = uiServices.platform as typeof uiServices.platform & {
     externalServices: NonNullable<typeof uiServices.platform.externalServices>;
   };
@@ -419,20 +395,17 @@ export async function bootstrapRuntime(
       }
       await waitForConfigDrivenRestarts(externalServices);
       await externalServices.stop();
-      const previousBindings = externalServiceBindings;
-      externalServiceBindings = readExternalServiceBindings();
       const daemonHomeDir = join(services.homeDirectory, '.goodvibes', 'daemon');
       const companionTokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
       externalServicesPromise = startExternalServices(
         configManager,
         runtimeBus,
         hookDispatcher,
-        { sharedDaemonToken: companionTokenRecord.token },
+        createExternalServiceFactories(companionTokenRecord.token),
         services,
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
-      externalServicePortState = await inspectExternalPorts([previousBindings, externalServiceBindings]);
       requestRender();
       return inspectExternalServices();
     },
@@ -487,17 +460,15 @@ export async function bootstrapRuntime(
       if (prune.failedPaths.length > 0) {
         logger.warn(`[bootstrap] Failed to prune ${prune.failedPaths.length} stale operator-token file(s) (permission/race): ${prune.failedPaths.join(', ')}`);
       }
-      externalServiceBindings = readExternalServiceBindings();
       externalServicesPromise = startExternalServices(
         configManager,
         runtimeBus,
         hookDispatcher,
-        { sharedDaemonToken: companionTokenRecord.token },
+        createExternalServiceFactories(companionTokenRecord.token),
         services,
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
-      externalServicePortState = await inspectExternalPorts([externalServiceBindings]);
       requestRender();
     },
     onError: (error) => {

package/src/runtime/ui-services.ts

@@ -8,6 +8,7 @@ import type { ControlPlaneRecentEvent } from '@pellux/goodvibes-sdk/platform/con
 import type { ApprovalBroker } from '@pellux/goodvibes-sdk/platform/control-plane/approval-broker';
 import type { SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane/session-broker';
 import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+import type { HostServiceStatus } from '@pellux/goodvibes-sdk/platform/runtime/bootstrap-services';
 import type { SecretsManager } from '../config/secrets.ts';
 
 export interface UiEnvironmentServices {
@@ -61,12 +62,16 @@ export interface UiPlatformServices {
       readonly daemonPortInUse?: boolean;
       readonly httpListenerRunning: boolean;
       readonly httpListenerPortInUse?: boolean;
+      readonly daemonStatus?: HostServiceStatus;
+      readonly httpListenerStatus?: HostServiceStatus;
     };
     restart(): Promise<{
       readonly daemonRunning: boolean;
       readonly daemonPortInUse?: boolean;
       readonly httpListenerRunning: boolean;
       readonly httpListenerPortInUse?: boolean;
+      readonly daemonStatus?: HostServiceStatus;
+      readonly httpListenerStatus?: HostServiceStatus;
     }>;
   };
 }

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.19.49';
+let _version = '0.19.51';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;