@pellux/goodvibes-tui 0.19.48 → 0.19.50

package/CHANGELOG.md

@@ -4,6 +4,31 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [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
+- Updated `@pellux/goodvibes-sdk` to `0.26.4` for SDK-owned multipart/raw artifact uploads across artifact storage, knowledge ingest, and Home Assistant Home Graph ingest.
+- Exposed the SDK `storage.artifacts.maxBytes` setting through the normal storage configuration surface.
+- Regenerated foundation operator contract artifacts from the SDK 0.26.4 contract.
+
+### Fixed
+- Picked up SDK fixes for large multipart upload cap handling and oversized-upload rejection behavior.
+- Removed the temporary TUI upload-stream normalization shim after SDK 0.26.4 fixed Bun request-reader cleanup failures in raw artifact uploads.
+
+---
+
 ## [0.19.48] — 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.48-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.50-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.1"
+    "version": "0.26.5"
   },
   "auth": {
     "modes": [
@@ -2319,7 +2319,7 @@
       {
         "id": "artifacts.create",
         "title": "Create Artifact",
-        "description": "Store a file or attachment artifact for later delivery or analysis.",
+        "description": "Store a file or attachment artifact for later delivery, analysis, or knowledge ingest. JSON supports small inline bodies and daemon-local path/URI references; HTTP callers can also send multipart/form-data or a raw binary body for large uploads.",
         "category": "artifacts",
         "source": "builtin",
         "access": "authenticated",
@@ -2486,7 +2486,16 @@
           ],
           "additionalProperties": false
         },
-        "invokable": true
+        "invokable": true,
+        "metadata": {
+          "uploadModes": [
+            "json-inline",
+            "json-path-or-uri",
+            "multipart-file",
+            "raw-body"
+          ],
+          "largeUploadConfigKey": "storage.artifacts.maxBytes"
+        }
       },
       {
         "id": "artifacts.get",
@@ -26572,7 +26581,7 @@
       {
         "id": "homeassistant.homeGraph.ingestHomeGraphArtifact",
         "title": "Ingest Home Graph Artifact",
-        "description": "Index an artifact, document, receipt, warranty, manual, or photo into a Home Graph space.",
+        "description": "Index an existing artifact reference, JSON path/URI reference, multipart file upload, or raw binary upload as a Home Graph document, receipt, warranty, manual, or photo.",
         "category": "knowledge",
         "source": "builtin",
         "access": "admin",
@@ -27020,7 +27029,16 @@
           ],
           "additionalProperties": true
         },
-        "invokable": true
+        "invokable": true,
+        "metadata": {
+          "uploadModes": [
+            "json-artifact-reference",
+            "json-path-or-uri",
+            "multipart-file",
+            "raw-body"
+          ],
+          "largeUploadConfigKey": "storage.artifacts.maxBytes"
+        }
       },
       {
         "id": "homeassistant.homeGraph.ingestHomeGraphNote",
@@ -31622,7 +31640,7 @@
       {
         "id": "knowledge.ingest.artifact",
         "title": "Ingest Artifact Into Knowledge",
-        "description": "Snapshot a local path, remote URI, or existing artifact into the structured knowledge store and run structured extraction.",
+        "description": "Snapshot an existing artifact, daemon-local path, remote URI, multipart file upload, or raw binary upload into the structured knowledge store and run structured extraction.",
         "category": "knowledge",
         "source": "builtin",
         "access": "admin",
@@ -31925,7 +31943,16 @@
           ],
           "additionalProperties": true
         },
-        "invokable": true
+        "invokable": true,
+        "metadata": {
+          "uploadModes": [
+            "json-artifact-reference",
+            "json-path-or-uri",
+            "multipart-file",
+            "raw-body"
+          ],
+          "largeUploadConfigKey": "storage.artifacts.maxBytes"
+        }
       },
       {
         "id": "knowledge.ingest.bookmarks",

package/package.json

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

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';
@@ -295,80 +294,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 hostServiceIsActive = (status: HostServiceStatus): boolean => status.mode === 'embedded' || status.mode === 'external';
 
-  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 [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,
     };
   };
 
@@ -389,21 +353,12 @@ export async function bootstrapRuntime(
   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,8 +374,6 @@ 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(
@@ -432,7 +385,6 @@ export async function bootstrapRuntime(
       );
       externalServices = await externalServicesPromise;
       controlPlaneRecentEventsRef.value = (limit) => externalServices.listRecentControlPlaneEvents(limit);
-      externalServicePortState = await inspectExternalPorts([previousBindings, externalServiceBindings]);
       requestRender();
       return inspectExternalServices();
     },
@@ -487,7 +439,6 @@ 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,
@@ -497,7 +448,6 @@ export async function bootstrapRuntime(
       );
       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.48';
+let _version = '0.19.50';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;