@pellux/goodvibes-tui 1.7.0 → 1.9.1

package/src/input/handler-shortcuts.ts

@@ -75,6 +75,23 @@ export function handleGlobalShortcutToken(
     return true;
   }
 
+  // Bare F2 is also not in the keybinding table (hardcoded, like pageup/
+  // pagedown/escape above) — it must be handled here, GLOBALLY, rather than
+  // in handlePromptKeyToken (handler-feed-routes.ts) where it used to live.
+  // That location only ever runs when the panel workspace does NOT already
+  // own focus (handlePanelFocusToken, which runs before it, swallows every
+  // unclaimed key once panelFocused is true and reports it handled). The
+  // practical effect was that F2 could OPEN+focus the Fleet panel exactly
+  // once; every subsequent press while already focused vanished silently —
+  // "F2 pressed 4x never closed the panel" (UX-C evaluator finding). Routing
+  // it here, before handlePanelFocusToken ever sees the token, gives F2 the
+  // same toggle semantics as Ctrl+O below, matching how Ctrl+P/panel-picker
+  // was already reachable regardless of panelFocused.
+  if (token.logicalName === 'f2' && !token.ctrl && !token.meta) {
+    toggleFleetPanel(state);
+    return true;
+  }
+
   // O(1) lookup via inverted map.
   const kb = state.keybindingsManager;
   const action = kb.lookup(token);
@@ -108,6 +125,13 @@ export function handleGlobalShortcutToken(
       // in-panel action (FleetPanel session-tab detach) before it closes the
       // panel outright — see Panel.interceptPanelClose's doc comment.
       if (active?.interceptPanelClose?.()) {
+        // UX-C fix: a consumed Ctrl+X (the Fleet panel's session-tab detach)
+        // used to leave panelFocused untouched, so focus stayed on the panel
+        // — the evaluator's "Ctrl+X detach landed focus in the panel and a
+        // typed question became nav keys". Detach is a leave-taking action:
+        // like the ordinary close below, it hands control back to the
+        // composer rather than leaving the user stranded on the fleet tree.
+        state.panelFocused = false;
         state.requestRender();
         return true;
       }
@@ -160,27 +184,27 @@ export function handleGlobalShortcutToken(
       // Alt+1..9: jump directly to the Nth workspace tab. Routed globally (like
       // panel-tab-next/prev) so the jump works whether focus is on the prompt or
       // the workspace; gated on visibility, matching cyclePanelTab semantics.
+      // UX-C: a chord jump is "I'm going panel-driving" (focus rule 1a) — the
+      // jump now also grabs keyboard focus, matching F2/Ctrl+O/Ctrl+P, so j/k
+      // land in the newly-active tab immediately instead of the composer.
       const pm = state.panelManager;
       if (pm.isVisible()) {
         const index = Number(action.slice('panel-tab-'.length)) - 1;
         pm.activateWorkspaceIndex(index);
+        pm.focusPanels();
+        state.panelFocused = true;
         state.requestRender();
       }
       return true;
     }
 
     case 'panel-ops': {
-      // Ctrl+O: open AND focus the Fleet panel. The former Ops Control panel was
+      // Ctrl+O: TOGGLE the Fleet panel (UX-C — same semantics as F2 above; see
+      // toggleFleetPanel's doc comment). The former Ops Control panel was
       // retired to an 'ops-control' -> 'fleet' alias (W6.1); rather than route
       // through the now-aliased openOpsPanel callback (which opens without
-      // transferring focus), open 'fleet' directly and grab focus — mirroring
-      // the footer indicator's [Enter] -> openFleetPanel path so j/k/i/K land in
-      // the panel immediately instead of the composer.
-      const pm = state.panelManager;
-      pm.open('fleet');
-      pm.focusPanels();
-      state.panelFocused = true;
-      state.requestRender();
+      // transferring focus), this operates on 'fleet' directly.
+      toggleFleetPanel(state);
       return true;
     }
 
@@ -358,3 +382,29 @@ export function handleGlobalShortcutToken(
       return false;
   }
 }
+
+/**
+ * toggleFleetPanel — the shared F2 / Ctrl+O TOGGLE (UX-C item 2): if the
+ * Fleet panel is open AND the panel workspace currently owns keyboard focus
+ * with Fleet as the active tab, the chord CLOSES it and returns focus to the
+ * composer; if Fleet is open but not the focused/active tab, the chord brings
+ * it to front and focuses it; if Fleet isn't open at all, the chord opens and
+ * focuses it. Uses `state.panelFocused` (not a panelManager query) for the
+ * focus check, consistent with every other case in this file and with what
+ * the mocked PanelManager test doubles in global-shortcuts.test.ts actually
+ * implement.
+ */
+function toggleFleetPanel(state: GlobalShortcutRouteState): void {
+  const pm = state.panelManager;
+  const fleetOpen = pm.getAllOpen().some((p) => p.id === 'fleet');
+  const fleetIsFocusedActive = fleetOpen && state.panelFocused && pm.getActivePanel()?.id === 'fleet';
+  if (fleetIsFocusedActive) {
+    pm.close('fleet');
+    state.panelFocused = false;
+  } else {
+    pm.open('fleet');
+    pm.focusPanels();
+    state.panelFocused = true;
+  }
+  state.requestRender();
+}

package/src/input/handler.ts

@@ -27,6 +27,7 @@ import { McpWorkspace } from './mcp-workspace.ts';
 import { SessionPickerModal } from './session-picker-modal.ts';
 import { ConfigModal } from './config-modal.ts';
 import { ProfilePickerModal } from './profile-picker-modal.ts';
+import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
 import {
   applyOnboardingRequest,
@@ -185,6 +186,8 @@ export class InputHandler implements InputHandlerLike {
   public blockActionsMenu = new BlockActionsMenu();
   public settingsModal = new SettingsModal();
   public configModal = new ConfigModal();
+  /** DEBT-5 item 5 — paste-flood guard state, mutated in place across tokens (never reallocated). */
+  private panelBurstGuard: PanelBurstGuardState = { timestamps: [], suspended: false, hintShown: false };
   public mcpWorkspace = new McpWorkspace();
   public onboardingWizard = new OnboardingWizardController();
   public onboardingModelPickerCancelSnapshot: OnboardingWizardSnapshot | null = null;
@@ -269,7 +272,7 @@ export class InputHandler implements InputHandlerLike {
     // W6.1 retirement: ProcessModal/LiveTailModal/AgentDetailModal were removed
     // — F2 now opens the Fleet panel, which subsumes the live process tree.
     this.bookmarkModal = new BookmarkModal(uiServices.shell.bookmarkManager);
-    this.sessionPickerModal = new SessionPickerModal(uiServices.sessions.sessionManager);
+    this.sessionPickerModal = new SessionPickerModal(uiServices.sessions.sessionManager, uiServices.sessions.sessionBroker);
     this.profilePickerModal = new ProfilePickerModal(uiServices.shell.profileManager);
     this.initFeedContext();
   }
@@ -319,6 +322,7 @@ export class InputHandler implements InputHandlerLike {
         keybindingsManager: this.uiServices.shell.keybindingsManager,
         killRing: this.killRing,
         focusTracker: this.uiServices.platform.focusTracker,
+        panelBurstGuard: this.panelBurstGuard,
         getHistory: this.getHistory,
         getViewportHeight: this.getViewportHeight,
         getScrollTop: this.getScrollTop,
@@ -399,6 +403,7 @@ export class InputHandler implements InputHandlerLike {
       preSelectId?: string;
       allowSearch?: boolean;
       customActions?: Map<string, SelectionAction>;
+      primaryVerbLabel?: string;
     } | undefined,
     callback: SelectionModalCallback,
   ): void {

package/src/input/keybindings.ts

@@ -88,7 +88,7 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'panel-tab-7':           'Jump to workspace panel tab 7',
   'panel-tab-8':           'Jump to workspace panel tab 8',
   'panel-tab-9':           'Jump to workspace panel tab 9',
-  'panel-ops':             'Open and focus the Fleet panel',
+  'panel-ops':             'Open, focus, or close the Fleet panel (toggle)',
   'panel-focus-toggle':    'Switch keyboard focus between top and bottom pane',
   'history-search':        'Reverse input history search',
   'search':                'Toggle conversation search',
@@ -140,10 +140,11 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'panel-tab-7':           [{ key: '7', alt: true }],
   'panel-tab-8':           [{ key: '8', alt: true }],
   'panel-tab-9':           [{ key: '9', alt: true }],
-  // Ctrl+O: open and focus the Fleet panel. The former Ops Control panel was
-  // retired to an 'ops-control' -> 'fleet' alias (W6.1); the binding is KEPT
-  // (repointed, not removed) so the Ctrl+O muscle memory still lands somewhere
-  // useful. Routed globally in handleGlobalShortcutToken.
+  // Ctrl+O: TOGGLE the Fleet panel (open+focus / bring-to-front+focus / close
+  // — see toggleFleetPanel in handler-shortcuts.ts, UX-C). The former Ops
+  // Control panel was retired to an 'ops-control' -> 'fleet' alias (W6.1); the
+  // binding is KEPT (repointed, not removed) so the Ctrl+O muscle memory still
+  // lands somewhere useful. Routed globally in handleGlobalShortcutToken.
   'panel-ops':             [{ key: 'o', ctrl: true }],
   // Ctrl+G: toggle keyboard focus between the top and bottom panes. Ctrl+G is
   // otherwise unbound in the default table.

package/src/input/model-picker.ts

@@ -261,7 +261,22 @@ export class ModelPickerModal {
     }
   }
 
-  /** Open showing all models — entry point for /model */
+  /**
+   * Open showing all models — entry point for /model.
+   *
+   * W3-T2: search starts FOCUSED. Live tmux repro (cc-w3-t2) showed the actual
+   * friction wasn't the filter itself (it already works — fuzzy multi-word
+   * substring over id/displayName/provider) but that with search unfocused by
+   * default, typing a search term went character-by-character into single-key
+   * shortcuts instead (g=group, c=capability, a=available-only, b=benchmark) —
+   * e.g. typing "claude" silently cycled the capability filter (on 'c') and
+   * toggled available-only off (on 'a') while the visible list never
+   * filtered, with no error and no indication anything happened. Reaching
+   * search required already knowing to press '/' or Up at the top row.
+   * Starting focused makes "just start typing" work the way every other
+   * picker in this codebase (and everywhere else) already behaves; Down
+   * still blurs search into list navigation (see handleModelPickerToken).
+   */
   openAllModels(models: ModelDefinition[], currentModelId: string): void {
     this.models = models;
     this.mode = 'model';
@@ -269,6 +284,7 @@ export class ModelPickerModal {
     this.pendingModel = null;
     this.focusPane = 'items';
     this.searchFocused = false;
+    this.focusSearch();
     this.query = '';
     this.categoryFilter = 'all';
     this.capabilityFilter = 'none';
@@ -279,7 +295,7 @@ export class ModelPickerModal {
     this.scrollOffset = 0;
   }
 
-  /** Open showing providers first — entry point for /provider */
+  /** Open showing providers first — entry point for /provider. W3-T2: search starts focused — see openAllModels(). */
   openProviders(providers: string[], currentProvider: string): void {
     this.previousMode = null;
     this.providers = providers;
@@ -288,6 +304,7 @@ export class ModelPickerModal {
     this.pendingModel = null;
     this.focusPane = 'items';
     this.searchFocused = false;
+    this.focusSearch();
     this.query = '';
     this.categoryFilter = 'all';
     this.capabilityFilter = 'none';

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

@@ -27,6 +27,13 @@ export function runtimePortDiagnostic(
     if (status.mode === 'unavailable') {
       return `The configured endpoint ${status.baseUrl} is unavailable after startup or restart.${reason}`;
     }
+    if (status.mode === 'incompatible') {
+      // A GoodVibes daemon IS on the port, but it speaks an incompatible wire
+      // version, so this TUI neither adopted it nor started a competing daemon.
+      // status.reason already names the port and both versions (SDK side).
+      const version = status.version ? ` version ${status.version}` : '';
+      return `A GoodVibes service${version} is running at ${status.baseUrl} but is not wire-compatible with this TUI, so it was not adopted.${reason}`;
+    }
     if (status.mode === 'external') {
       const version = status.version ? ` version ${status.version}` : '';
       return `An existing GoodVibes service was verified at ${status.baseUrl}${version}.`;
@@ -62,7 +69,9 @@ export function isRuntimeEndpointOccupyingConfiguredPort(
   endpoint: OnboardingRuntimeEndpoint,
 ): boolean {
   const status = getRuntimeEndpointStatus(state, endpoint);
-  if (status) return status.mode === 'embedded' || status.mode === 'external' || status.mode === 'blocked';
+  // 'incompatible' means a GoodVibes daemon holds the configured port (we just
+  // did not adopt it) — the port IS occupied, so report it as such.
+  if (status) return status.mode === 'embedded' || status.mode === 'external' || status.mode === 'blocked' || status.mode === 'incompatible';
   return endpoint === 'daemon'
     ? state?.daemonRunning === true || state?.daemonPortInUse === true
     : state?.httpListenerRunning === true || state?.httpListenerPortInUse === true;

package/src/input/onboarding/onboarding-wizard-apply.ts

@@ -85,7 +85,14 @@ export function buildOnboardingApplyRequest(controller: OnboardingWizardControll
     setConfig('service.enabled', hasServers);
     setConfig('service.autostart', hasServers);
     setConfig('service.restartOnFailure', true);
-    setConfig('danger.daemon', hasServers);
+    // One-Platform daemon-by-default (SDK docs/decisions/2026-07-05-daemon-by-default.md):
+    // the loopback-only cross-surface session daemon is safe-by-design (Wave 1:
+    // loopback bind, auth-gated, rate-limited) and runs regardless of whether
+    // browser/LAN/webhook/external-app capabilities are selected here — it is no
+    // longer bundled with those network-exposing surfaces, so onboarding leaves
+    // daemon.enabled untouched and lets the SDK's own default-true (or an existing
+    // explicit user override) govern. (The deprecated danger.daemon alias this
+    // comment used to also name was removed in Wave 6.)
     setConfig('controlPlane.enabled', hasServers);
     setConfig('danger.httpListener', httpListener);
     setConfig('web.enabled', browserAccess);

package/src/input/onboarding/onboarding-wizard-constants.ts

@@ -18,7 +18,10 @@ export const DEFAULT_CAPABILITIES: readonly OnboardingStep1CapabilityItem[] = [
     id: 'local-tui-only',
     label: 'Local TUI Only (No Servers)',
     selected: true,
-    detail: 'Use GoodVibes only in this terminal. No browser access, background service, HTTP listener, external app surface, or network setup.',
+    // Honest wording (One-Platform daemon-by-default): this avoids browser/LAN/
+    // webhook/external-app exposure, but the loopback-only GoodVibes daemon
+    // still runs by default for cross-surface visibility on this machine.
+    detail: 'Use GoodVibes only in this terminal. No browser access, HTTP listener, external app surface, or network setup. A loopback-only background daemon still runs by default so sessions here stay visible to other GoodVibes surfaces on this machine — turn it off in Settings > daemon if you want none at all.',
   },
   {
     id: 'browser-access',

package/src/input/onboarding/onboarding-wizard-network-adopt.ts

@@ -0,0 +1,136 @@
+/**
+ * F1 (One-Platform Wave 2 friction fix): the Network step's daemon-source choice
+ * — start a new daemon owned by this TUI (default) vs connect to one that is
+ * already running elsewhere with a known token. Extracted from
+ * onboarding-wizard-steps.ts to keep that file under the architecture line cap.
+ */
+import { legacyUnitNote, MANAGED_SERVICE_NAME } from '../../runtime/legacy-daemon-migration.ts';
+import { normalizeText } from './onboarding-wizard-helpers.ts';
+import type { OnboardingWizardControllerLike } from './onboarding-wizard-types.ts';
+import type { OnboardingWizardFieldDefinition } from './onboarding-wizard-types.ts';
+
+export const DAEMON_SOURCE_FIELD_ID = 'network.daemon-source';
+
+/** Current daemon-source selection ('start' default, or 'adopt'). */
+export function getDaemonSource(controller: OnboardingWizardControllerLike): string {
+  return controller.getStringFieldValue(DAEMON_SOURCE_FIELD_ID, 'start');
+}
+
+/**
+ * Push the daemon-source radio, plus the host/port/token/connect fields when
+ * 'adopt' is selected, onto the Network step's field list. Independent of the
+ * local/custom network mode — adopting someone else's daemon is a client-side
+ * choice about which daemon THIS TUI talks to, not about how THIS TUI's own
+ * daemon binds to the network.
+ */
+export function pushDaemonAdoptionFields(
+  fields: OnboardingWizardFieldDefinition[],
+  controller: OnboardingWizardControllerLike,
+  daemonSource: string,
+  bindSettings: { readonly controlPlane: { readonly host?: string | undefined; readonly port?: number | undefined } } | undefined,
+): void {
+  fields.push({
+    kind: 'radio',
+    id: DAEMON_SOURCE_FIELD_ID,
+    label: 'GoodVibes daemon source',
+    hint: 'Start a new daemon owned by this TUI (default), or connect to one that is already running elsewhere with a known token.',
+    options: [
+      { id: 'start', label: 'Start a new daemon', hint: 'This TUI starts and owns its own daemon (default).' },
+      { id: 'adopt', label: 'Connect to an existing running daemon', hint: 'Point this TUI at a daemon someone already started, using its host, port, and token.' },
+    ],
+    defaultValue: 'start',
+  });
+  if (daemonSource !== 'adopt') return;
+  fields.push(
+    {
+      kind: 'text',
+      id: 'network.adopt-daemon-host',
+      label: 'Existing daemon host',
+      hint: 'Host or IP address of the already-running GoodVibes daemon.',
+      placeholder: '127.0.0.1',
+      defaultValue: controller.getStringFieldValue('network.adopt-daemon-host', normalizeText(bindSettings?.controlPlane.host) || '127.0.0.1'),
+    },
+    {
+      kind: 'text',
+      id: 'network.adopt-daemon-port',
+      label: 'Existing daemon port',
+      hint: 'Port the already-running GoodVibes daemon is bound to.',
+      placeholder: '3421',
+      defaultValue: controller.getStringFieldValue('network.adopt-daemon-port', String(bindSettings?.controlPlane.port ?? 3421)),
+    },
+    {
+      kind: 'masked',
+      id: 'network.adopt-daemon-token',
+      label: 'Existing daemon token',
+      hint: "Bearer token that daemon was started with. Connecting writes it into this home directory's operator-tokens.json so this TUI authenticates as that daemon instead of minting its own.",
+      placeholder: 'gv_...',
+      defaultValue: controller.getStringFieldValue('network.adopt-daemon-token', ''),
+    },
+    {
+      kind: 'action',
+      id: 'network.adopt-daemon-connect',
+      label: 'Connect to this daemon now',
+      hint: 'Apply the host/port above, install the token, and verify the connection immediately (before Apply at the end of the wizard). Result prints to the feed below.',
+      action: 'connect-existing-daemon',
+      defaultValue: 'Connect',
+    },
+  );
+}
+
+/**
+ * W4-D1: the guided, visible entry point for migrating a detected legacy
+ * `goodvibes-daemon.service` unit — closes the fast-follow-up flagged when
+ * `handleMigrateLegacyDaemonServiceForHandler` (handler-onboarding-daemon-adopt.ts)
+ * shipped fully built but not wired to any onboarding control. Independent of
+ * the daemon-source radio above: this offers to retire an old unmanaged unit
+ * regardless of whether the wizard is set to start a new daemon or adopt an
+ * existing one.
+ *
+ * Visible ONLY when the runtime snapshot's read-only `legacyDaemon` detection
+ * (collected via `detectLegacyUnit`, see `../../runtime/legacy-daemon-migration.ts`)
+ * found a unit file present — never rendered speculatively. Confirm-gated on
+ * top of the engine's own consent requirement: a checklist toggle must be
+ * checked before the action executes the real migration (`confirmMigration:
+ * true`); left unchecked, pressing the action still works but only prints the
+ * engine's dry-run plan (`confirmMigration: false`) — see
+ * `runLegacyDaemonMigration`'s honest dry-run branch. The action label and
+ * hint change to make which mode is armed unambiguous before it is pressed.
+ */
+export function pushLegacyDaemonMigrationFields(
+  fields: OnboardingWizardFieldDefinition[],
+  controller: OnboardingWizardControllerLike,
+): void {
+  const legacy = controller.runtimeSnapshot?.legacyDaemon;
+  if (!legacy || !legacy.present) return;
+
+  fields.push({
+    kind: 'status',
+    id: 'network.migrate-legacy-daemon-detected',
+    label: 'Legacy daemon service detected',
+    // F2 follow-up: name the unit this host actually resolves (carried on the
+    // snapshot from `resolveConfiguredServiceName` at collection time) — the
+    // MANAGED_SERVICE_NAME fallback only covers snapshots built without it.
+    hint: legacyUnitNote(legacy, legacy.trackedServiceName ?? MANAGED_SERVICE_NAME),
+    defaultValue: legacy.active ? 'Installed and running' : 'Installed (not active)',
+  });
+
+  const confirmFieldId = 'network.migrate-legacy-daemon-confirm';
+  const confirmed = controller.getBooleanFieldValue(confirmFieldId, false);
+  fields.push({
+    kind: 'checklist',
+    id: confirmFieldId,
+    label: 'Confirm migration execution',
+    hint: 'When checked, the action below performs the real migration: install and start the new managed service, verify it comes up healthy, and only then stop, disable, and remove the legacy unit. Leave unchecked to preview the plan without changing anything.',
+    defaultValue: false,
+  });
+  fields.push({
+    kind: 'action',
+    id: 'network.migrate-legacy-daemon',
+    label: confirmed ? 'Migrate legacy daemon service now' : 'Preview migration plan',
+    hint: confirmed
+      ? 'Executes the migration now: new-up-then-old-down, never touching the legacy unit until the new one is verified healthy. Result prints to the feed below.'
+      : 'Prints the migration plan without changing anything. Check "Confirm migration execution" above to arm the real migration.',
+    action: 'migrate-legacy-daemon-service',
+    defaultValue: confirmed ? 'Migrate' : 'Preview',
+  });
+}

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -9,6 +9,7 @@ import {
   type ExternalSurfaceSpec,
 } from './onboarding-wizard-external-surfaces.ts';
 import { countSelected, modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.ts';
+import { getDaemonSource, pushDaemonAdoptionFields, pushLegacyDaemonMigrationFields } from './onboarding-wizard-network-adopt.ts';
 import type { OnboardingWizardControllerLike } from './onboarding-wizard-types.ts';
 import type { OnboardingWizardAcknowledgementFieldDefinition, OnboardingWizardActionFieldDefinition, OnboardingWizardChecklistFieldDefinition, OnboardingWizardExternalSurfaceStepId, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
 
@@ -123,7 +124,7 @@ export function buildCapabilitiesStep(controller: OnboardingWizardControllerLike
         id: 'capabilities.clear',
         action: 'clear-capabilities',
         label: 'Use Local TUI Only (No Servers)',
-        hint: 'Clear all server-backed capabilities and keep GoodVibes in this terminal only.',
+        hint: 'Clear all server-backed capabilities: no browser access, LAN reachability, webhooks/events, or external app surfaces. The loopback-only background daemon still runs by default.',
         defaultValue: 'Action',
       },
     ];
@@ -518,11 +519,7 @@ export function buildNetworkStep(controller: OnboardingWizardControllerLike): On
     const listenerEnabled = controller.shouldExposeHttpListenerNetworkFields();
     const listenerWillApply = controller.shouldEnableHttpListener();
     const controlPlaneRemote = controller.shouldExposeControlPlaneNetwork();
-    const networkEnabled = {
-      controlPlane: controlPlaneRemote,
-      httpListener: listenerEnabled,
-      web: browserEnabled,
-    };
+    const networkEnabled = { controlPlane: controlPlaneRemote, httpListener: listenerEnabled, web: browserEnabled };
     const mode = controller.getStringFieldValue('network.mode', controller.runtimeDerived.step1_5NetworkMode);
     const custom = mode === 'custom';
     const fields: OnboardingWizardFieldDefinition[] = [
@@ -536,6 +533,11 @@ export function buildNetworkStep(controller: OnboardingWizardControllerLike): On
       },
     ];
 
+    // F1: recognize an adoptable already-running daemon (see onboarding-wizard-network-adopt.ts).
+    const daemonSource = getDaemonSource(controller);
+    pushDaemonAdoptionFields(fields, controller, daemonSource, bindSettings);
+    pushLegacyDaemonMigrationFields(fields, controller);
+
     if (custom) {
       const sharedIpField: OnboardingWizardChecklistFieldDefinition = {
         kind: 'checklist',
@@ -635,6 +637,7 @@ export function buildNetworkStep(controller: OnboardingWizardControllerLike): On
       summaryTitle: 'Bind posture',
       summaryLines: [
         `Mode: ${custom ? 'custom' : 'local network default'}`,
+        `Daemon source: ${daemonSource === 'adopt' ? 'connect to an existing running daemon' : 'start a new daemon'}`,
         `Browser surface: ${browserEnabled ? 'enabled' : 'not selected'}`,
         `HTTP listener: ${listenerWillApply ? 'enabled' : listenerEnabled ? 'available for selected external apps' : 'not selected'}`,
       ],

package/src/input/onboarding/onboarding-wizard-types.ts

@@ -53,7 +53,9 @@ export type OnboardingWizardAction =
   | 'cloudflare-verify'
   | 'cloudflare-disable'
   | 'start-openai-subscription'
-  | 'finish-openai-subscription';
+  | 'finish-openai-subscription'
+  | 'connect-existing-daemon'
+  | 'migrate-legacy-daemon-service';
 
 export type OnboardingWizardApplyFeedbackSeverity = 'info' | 'warning' | 'error';
 

package/src/input/panel-mouse-geometry.ts

@@ -0,0 +1,97 @@
+// ---------------------------------------------------------------------------
+// panel-mouse-geometry.ts
+//
+// Pure mouse-geometry helpers for the panel workspace, extracted from
+// handler-feed-routes.ts so that file stays under the 800-line architecture
+// cap once the UX-C focus verbs and the DEBT-5 paste-flood guard both live in
+// it. These map a terminal (row, col) onto the panel/pane/workspace-tab under
+// the cursor. No dependency on the feed-route state types, so no import cycle.
+// ---------------------------------------------------------------------------
+
+import type { PanelManager } from '../panels/panel-manager.ts';
+import { renderPanelWorkspaceBar } from '../renderer/panel-workspace-bar.ts';
+import type { TabHitRegion } from '../renderer/tab-strip.ts';
+
+/** Screen rectangle the panel workspace occupies, plus its vertical split. */
+export type PanelMouseLayout = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  hasBottomPane: boolean;
+  verticalSplitRatio: number;
+};
+
+function clampRatio(value: number): number {
+  return Math.max(0.2, Math.min(0.8, value));
+}
+
+export function getActivePanelInPane(panelManager: PanelManager, pane: 'top' | 'bottom') {
+  const target = pane === 'top' ? panelManager.getTopPane() : panelManager.getBottomPane();
+  return target.panels[target.activeIndex] ?? null;
+}
+
+export function getPanelUnderMouse(
+  panelManager: PanelManager,
+  layout: PanelMouseLayout | null,
+  row: number,
+  col: number,
+) {
+  if (
+    layout === null
+    || !panelManager.isVisible()
+    || panelManager.getAllOpen().length === 0
+    || col < layout.x
+    || col >= layout.x + layout.width
+    || row < layout.y
+    || row >= layout.y + layout.height
+  ) {
+    return null;
+  }
+
+  const panelRow = row - layout.y;
+  if (!layout.hasBottomPane) {
+    return getActivePanelInPane(panelManager, 'top');
+  }
+
+  // Single consolidated workspace bar (row 0) + h-separator; the rest splits
+  // between the two panes' content.
+  const panelAreaRows = Math.max(0, layout.height - 1);
+  const contentRows = Math.max(0, panelAreaRows - 1);
+  const topContentRows = contentRows <= 1
+    ? contentRows
+    : Math.max(1, Math.floor(contentRows * clampRatio(layout.verticalSplitRatio)));
+  // panelRow 0 = workspace bar; rows 1..topContentRows = top pane; rest = bottom.
+  return panelRow <= topContentRows
+    ? getActivePanelInPane(panelManager, 'top')
+    : getActivePanelInPane(panelManager, 'bottom');
+}
+
+/**
+ * If the mouse is over the consolidated workspace tab bar (the first panel
+ * row), return the index of the tab under the cursor, else null. Recomputes the
+ * tab hit regions by rendering the bar with a layout callback — cheap and keeps
+ * the click geometry in lockstep with what was drawn.
+ */
+export function workspaceTabAtMouse(
+  panelManager: PanelManager,
+  layout: PanelMouseLayout | null,
+  row: number,
+  col: number,
+): number | null {
+  if (
+    layout === null
+    || !panelManager.isVisible()
+    || panelManager.getAllOpen().length === 0
+    || row !== layout.y // workspace bar is the first panel row
+    || col < layout.x
+    || col >= layout.x + layout.width
+  ) {
+    return null;
+  }
+  let regions: readonly TabHitRegion[] = [];
+  renderPanelWorkspaceBar(panelManager.getWorkspaceTabs(), layout.width, true, (r) => { regions = r; });
+  const relCol = col - layout.x;
+  const hit = regions.find((rg) => relCol >= rg.startCol && relCol < rg.endCol);
+  return hit ? hit.index : null;
+}