@pellux/goodvibes-tui 0.19.64 → 0.19.66

package/CHANGELOG.md

@@ -8,6 +8,46 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.66] — 2026-05-06
+
+### Fixed
+- Changed `/config` to open with focus on the category rail at the first category instead of dropping users directly into the selected setting list.
+- Reorganized the `/config` category rail into logical groups so related settings are easier to scan.
+- Corrected `goodvibes service status` / service posture reporting for systemd-managed daemons by reconciling status against `systemctl --user show`, so running/enabled OS services are no longer reported as stopped because of stale pid-file state.
+
+### Verified
+- `bun test src/test/input/settings-modal.test.ts src/test/renderer/settings-modal.test.ts`
+- `bun test src/test/input/modal-space-actions.test.ts`
+- `bun test src/test/cli/service-posture.test.ts`
+- `bun run test`
+- `bunx tsc --noEmit`
+- `bun run build:prod`
+- `bun run smoke:tui`
+- `bun run smoke:daemon`
+- `git diff --check`
+
+---
+
+## [0.19.65] — 2026-05-05
+
+### Fixed
+- Made `/config service` changes apply to the OS service layer instead of only writing `~/.goodvibes/tui/settings.json`.
+- Enabling `service.autostart` now enables service mode if needed, writes the platform service definition, reloads systemd user units when applicable, and starts/enables the service.
+- Disabling `service.autostart` or `service.enabled` now disables/removes the platform service definition instead of leaving stale OS autostart state behind.
+- Service definition changes such as restart-on-failure, platform, service name, or log path now rewrite and restart the OS service when service mode and autostart are active.
+- Added a visible `/config` status notice for service install/start/disable/update results after a setting change.
+
+### Verified
+- `bun test src/test/shell/service-settings-sync.test.ts src/test/input/settings-modal-network.test.ts`
+- `bun run test`
+- `bunx tsc --noEmit`
+- `bun run build:prod`
+- `bun run smoke:tui`
+- `bun run smoke:daemon`
+- `git diff --check`
+
+---
+
 ## [0.19.64] — 2026-05-05
 
 ### Fixed

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.64-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.66-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.64",
+  "version": "0.19.66",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/cli/service-posture.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from 'node:child_process';
 import { accessSync, closeSync, constants, existsSync, openSync, readSync, realpathSync, statSync } from 'node:fs';
 import net from 'node:net';
 import { basename, delimiter, dirname, isAbsolute, join, resolve } from 'node:path';
@@ -82,6 +83,23 @@ interface ServiceDefinitionOverride {
   readonly restartOnFailure: boolean;
 }
 
+interface CliServiceStatusCommandResult {
+  readonly status: number | null;
+  readonly stdout?: string;
+  readonly stderr?: string;
+}
+
+interface CliServiceStatusManager {
+  status(): ManagedServiceStatus;
+}
+
+interface CliServicePostureOptions {
+  readonly probe?: boolean;
+  readonly logTailBytes?: number;
+  readonly manager?: CliServiceStatusManager;
+  readonly runCommand?: (command: string, args: readonly string[]) => CliServiceStatusCommandResult;
+}
+
 function connectHostForBindHost(host: string): string {
   if (host === '0.0.0.0' || host === '::') return '127.0.0.1';
   return host || '127.0.0.1';
@@ -227,6 +245,58 @@ function pidFilePath(runtime: CliServiceRuntime, platform: ManagedServiceStatus[
   return join(getServiceStateRoot(runtime), 'service', `${platform}.pid`);
 }
 
+function runStatusCommand(
+  command: string,
+  args: readonly string[],
+  options: CliServicePostureOptions,
+): CliServiceStatusCommandResult {
+  if (options.runCommand) return options.runCommand(command, args);
+  return spawnSync(command, [...args], {
+    stdio: 'pipe',
+    encoding: 'utf-8',
+    timeout: 1500,
+  });
+}
+
+function parseSystemdShowValue(lines: readonly string[], key: string): string | null {
+  const prefix = `${key}=`;
+  const match = lines.find((line) => line.startsWith(prefix));
+  return match ? match.slice(prefix.length).trim() : null;
+}
+
+function reconcileSystemdServiceStatus(
+  runtime: CliServiceRuntime,
+  status: ManagedServiceStatus,
+  options: CliServicePostureOptions,
+): ManagedServiceStatus {
+  if (status.platform !== 'systemd') return status;
+
+  const name = String(runtime.configManager.get('service.serviceName') ?? 'goodvibes').trim() || 'goodvibes';
+  const result = runStatusCommand('systemctl', [
+    '--user',
+    'show',
+    `${name}.service`,
+    '--property=LoadState,ActiveState,UnitFileState,MainPID',
+    '--no-page',
+  ], options);
+  if ((result.status ?? 1) !== 0) return status;
+
+  const lines = (result.stdout ?? '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const loadState = parseSystemdShowValue(lines, 'LoadState');
+  const activeState = parseSystemdShowValue(lines, 'ActiveState');
+  const unitFileState = parseSystemdShowValue(lines, 'UnitFileState');
+  const rawPid = Number.parseInt(parseSystemdShowValue(lines, 'MainPID') ?? '', 10);
+  const pid = Number.isFinite(rawPid) && rawPid > 0 ? rawPid : undefined;
+
+  return {
+    ...status,
+    installed: loadState === 'loaded' || status.installed,
+    autostart: unitFileState === 'enabled' || unitFileState === 'linked' || status.autostart,
+    running: activeState === 'active',
+    ...(pid === undefined ? {} : { pid }),
+  };
+}
+
 function readLogPosture(path: string | undefined, tailBytes: number): CliServiceLogPosture {
   if (!path) return { path: null, exists: false, size: 0, modifiedAt: null };
   if (!existsSync(path)) return { path, exists: false, size: 0, modifiedAt: null };
@@ -298,10 +368,10 @@ export function createPlatformServiceManager(runtime: CliServiceRuntime): Platfo
 
 export async function buildCliServicePosture(
   runtime: CliServiceRuntime,
-  options: { readonly probe?: boolean; readonly logTailBytes?: number } = {},
+  options: CliServicePostureOptions = {},
 ): Promise<CliServicePosture> {
-  const manager = createPlatformServiceManager(runtime);
-  const status = manager.status();
+  const manager = options.manager ?? createPlatformServiceManager(runtime);
+  const status = reconcileSystemdServiceStatus(runtime, manager.status(), options);
   const endpoints = await Promise.all(ENDPOINTS.map(async (endpoint): Promise<CliServiceEndpointPosture> => {
     const enabled = runtime.configManager.get(endpoint.enabledKey as never) === true;
     const binding = resolveRuntimeEndpointBinding(runtime.configManager, endpoint.id);

package/src/input/settings-modal-types.ts

@@ -36,39 +36,21 @@ export type SettingsCategory =
 
 export type SettingsFocusPane = 'categories' | 'settings';
 
-export const SETTINGS_CATEGORIES: SettingsCategory[] = [
-  'display',
-  'ui',
-  'provider',
-  'subscriptions',
-  'behavior',
-  'storage',
-  'permissions',
-  'orchestration',
-  'wrfc',
-  'tools',
-  'helper',
-  'tts',
-  'service',
-  'controlPlane',
-  'httpListener',
-  'web',
-  'network',
-  'mcp',
-  'sandbox',
-  'surfaces',
-  'cloudflare',
-  'batch',
-  'automation',
-  'watchers',
-  'runtime',
-  'telemetry',
-  'cache',
-  'danger',
-  'flags',
-  'release',
+export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
+  readonly label: string;
+  readonly categories: readonly SettingsCategory[];
+}> = [
+  { label: 'Interface', categories: ['display', 'ui', 'behavior', 'permissions'] },
+  { label: 'AI Routing', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
+  { label: 'Service & Network', categories: ['service', 'network', 'controlPlane', 'httpListener', 'web'] },
+  { label: 'Surfaces & Cloud', categories: ['surfaces', 'mcp', 'cloudflare'] },
+  { label: 'Automation', categories: ['batch', 'automation', 'watchers', 'orchestration', 'wrfc'] },
+  { label: 'Runtime & Data', categories: ['storage', 'sandbox', 'runtime', 'cache', 'telemetry'] },
+  { label: 'Advanced', categories: ['flags', 'release', 'danger'] },
 ];
 
+export const SETTINGS_CATEGORIES: SettingsCategory[] = SETTINGS_CATEGORY_GROUPS.flatMap(group => group.categories);
+
 export interface SettingEntry {
   setting: ConfigSetting;
   currentValue: unknown;

package/src/input/settings-modal.ts

@@ -34,6 +34,7 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   SETTINGS_CATEGORIES,
+  SETTINGS_CATEGORY_GROUPS,
   type FlagEntry,
   type McpEntry,
   type SettingEntry,
@@ -42,8 +43,25 @@ import {
   type SubscriptionEntry,
 } from './settings-modal-types.ts';
 
+export interface SettingsModalChange {
+  readonly key: ConfigKey;
+  readonly previousValue: unknown;
+  readonly value: unknown;
+}
+
+export interface SettingsModalChangeResult {
+  readonly message?: string;
+}
+
+export type SettingsModalChangeHandler = (change: SettingsModalChange) => SettingsModalChangeResult | void;
+
+export interface SettingsModalOpenOptions {
+  readonly onSettingApplied?: SettingsModalChangeHandler;
+}
+
 export {
   SETTINGS_CATEGORIES,
+  SETTINGS_CATEGORY_GROUPS,
   type FlagEntry,
   type McpEntry,
   type SettingEntry,
@@ -104,6 +122,7 @@ export class SettingsModal {
    * Cleared on next open() or close().
    */
   public lastSaveTriggeredRestart: 'control-plane' | 'http-listener' | 'web' | null = null;
+  public lastSettingEffectMessage: string | null = null;
 
   private configManager: ConfigManager | null = null;
   private secretsManager: SettingsSecretsManager | null = null;
@@ -111,6 +130,7 @@ export class SettingsModal {
   private mcpRegistry: McpRegistry | null = null;
   private subscriptionManager: SubscriptionManager | null = null;
   private serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'> | null = null;
+  private onSettingApplied: SettingsModalChangeHandler | null = null;
 
   /**
    * Open the modal, loading current config values from configManager.
@@ -125,6 +145,7 @@ export class SettingsModal {
     serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'>,
     mcpRegistry?: McpRegistry,
     secretsManager?: SettingsSecretsManager,
+    options?: SettingsModalOpenOptions,
   ): void {
     this.configManager = configManager;
     this.secretsManager = secretsManager ?? null;
@@ -132,13 +153,14 @@ export class SettingsModal {
     this.subscriptionManager = subscriptionManager;
     this.serviceRegistry = serviceRegistry;
     this.mcpRegistry = mcpRegistry ?? null;
+    this.onSettingApplied = options?.onSettingApplied ?? null;
     this._loadGroups(configManager);
     this._loadFlagEntries();
     this._loadMcpEntries();
     this._loadSubscriptionEntries();
     this.categoryIndex = 0;
     this.selectedIndex = 0;
-    this.focusPane = 'settings';
+    this.focusPane = 'categories';
     this.editingMode = false;
     this.editBuffer = '';
     this.pendingModelPickerTarget = null;
@@ -147,6 +169,7 @@ export class SettingsModal {
     this.mcpAllowAllConfirmationTarget = null;
     this.subscriptionLogoutConfirmationTarget = null;
     this.lastSaveTriggeredRestart = null;
+    this.lastSettingEffectMessage = null;
     this.active = true;
   }
 
@@ -160,8 +183,10 @@ export class SettingsModal {
     this.mcpAllowAllConfirmationTarget = null;
     this.subscriptionLogoutConfirmationTarget = null;
     this.lastSaveTriggeredRestart = null;
+    this.lastSettingEffectMessage = null;
     this.serviceRegistry = null;
     this.secretsManager = null;
+    this.onSettingApplied = null;
     this.focusPane = 'settings';
   }
 
@@ -715,6 +740,16 @@ export class SettingsModal {
     return items;
   }
 
+  private _refreshAllEntries(): void {
+    if (!this.configManager) return;
+    for (const entries of this.groups.values()) {
+      for (const entry of entries) {
+        entry.currentValue = this.configManager.get(entry.setting.key as ConfigKey);
+        entry.isDefault = entry.currentValue === entry.setting.default;
+      }
+    }
+  }
+
   private _setValue(key: ConfigKey, value: unknown): void {
     if (!this.configManager) return;
     // Diff previous value before writing — avoids false restart notices on no-op saves
@@ -744,8 +779,14 @@ export class SettingsModal {
           entry.isDefault = entry.currentValue === entry.setting.default;
         }
       }
+      if (previousValue !== value && this.onSettingApplied) {
+        const result = this.onSettingApplied({ key, previousValue, value });
+        this.lastSettingEffectMessage = result?.message ?? null;
+        this._refreshAllEntries();
+      }
     } catch (e) {
       logger.error('SettingsModal: failed to set config value', { key, error: summarizeError(e) });
+      this.lastSettingEffectMessage = `Save failed: ${summarizeError(e)}`;
     }
   }
 

package/src/main.ts

@@ -678,6 +678,8 @@ async function main() {
     subscriptionManager,
     secretsManager,
     serviceRegistry: ctx.services.serviceRegistry,
+    workingDirectory: workingDir,
+    homeDirectory,
     getConfiguredProviderIds: ctx._getConfiguredProviderIds,
     getPinned: ctx._getPinned,
     render,

package/src/renderer/settings-modal.ts

@@ -8,7 +8,7 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import type { SettingsModal, SettingEntry, FlagEntry, McpEntry, SubscriptionEntry, SettingsCategory } from '../input/settings-modal.ts';
-import { SETTINGS_CATEGORIES } from '../input/settings-modal.ts';
+import { SETTINGS_CATEGORIES, SETTINGS_CATEGORY_GROUPS } from '../input/settings-modal.ts';
 import { getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
 import { CATEGORY_LABELS, describeUiRouting, formatValue, getSettingLabel, inferSubscriptionRouteReason, valueColor } from './settings-modal-helpers.ts';
 import { isSecretConfigKey } from '../config/secret-config.ts';
@@ -413,18 +413,46 @@ function categoryItemCount(modal: SettingsModal, category: SettingsCategory): nu
   return modal.groups.get(category)?.length ?? 0;
 }
 
+type CategoryRailEntry =
+  | { readonly type: 'group'; readonly label: string }
+  | { readonly type: 'category'; readonly category: SettingsCategory; readonly index: number };
+
+function buildCategoryRailEntries(): CategoryRailEntry[] {
+  const entries: CategoryRailEntry[] = [];
+  for (const group of SETTINGS_CATEGORY_GROUPS) {
+    const categories = group.categories.filter(category => SETTINGS_CATEGORIES.includes(category));
+    if (categories.length === 0) continue;
+    entries.push({ type: 'group', label: group.label });
+    for (const category of categories) {
+      entries.push({
+        type: 'category',
+        category,
+        index: SETTINGS_CATEGORIES.indexOf(category),
+      });
+    }
+  }
+  return entries;
+}
+
 function renderCategories(modal: SettingsModal, width: number, height: number): string[] {
   const rows: string[] = [];
-  const window = stableWindow(SETTINGS_CATEGORIES.length, modal.categoryIndex, height);
-  if (window.start > 0) rows.push(`${GLYPHS.navigation.moreAbove} ${window.start} more categor${window.start === 1 ? 'y' : 'ies'} above`);
-  for (let index = window.start; index < window.end; index += 1) {
-    const category = SETTINGS_CATEGORIES[index]!;
-    const active = index === modal.categoryIndex;
+  const entries = buildCategoryRailEntries();
+  const selectedEntryIndex = Math.max(0, entries.findIndex(entry => entry.type === 'category' && entry.index === modal.categoryIndex));
+  const window = stableWindow(entries.length, selectedEntryIndex, height);
+  if (window.start > 0) rows.push(`${GLYPHS.navigation.moreAbove} ${window.start} more row(s) above`);
+  for (let railIndex = window.start; railIndex < window.end; railIndex += 1) {
+    const entry = entries[railIndex]!;
+    if (entry.type === 'group') {
+      rows.push(`  ${entry.label.toUpperCase()}`);
+      continue;
+    }
+    const category = entry.category;
+    const active = entry.index === modal.categoryIndex;
     const count = categoryItemCount(modal, category);
     const cursor = active ? (modal.focusPane === 'categories' ? GLYPHS.navigation.selected : '•') : ' ';
     rows.push(`${cursor} ${CATEGORY_LABELS[category]} (${count})`);
   }
-  if (window.end < SETTINGS_CATEGORIES.length) rows.push(`${GLYPHS.navigation.moreBelow} ${SETTINGS_CATEGORIES.length - window.end} more categor${SETTINGS_CATEGORIES.length - window.end === 1 ? 'y' : 'ies'} below`);
+  if (window.end < entries.length) rows.push(`${GLYPHS.navigation.moreBelow} ${entries.length - window.end} more row(s) below`);
   while (rows.length < height) rows.push('');
   return rows.slice(0, height);
 }
@@ -590,7 +618,11 @@ export function renderSettingsModal(
   const header = contentLine(safeWidth, PALETTE.footerBg);
   drawVertical(header, dividerX, PALETTE.footerBg);
   writeText(header, leftStart + 1, leftWidth - 2, 'Categories', { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
-  const headerText = `${CATEGORY_LABELS[modal.currentCategory]} (${categoryItemCount(modal, modal.currentCategory)})${modal.lastSaveTriggeredRestart ? ` · Restarting ${modal.lastSaveTriggeredRestart}` : ''}`;
+  const notices = [
+    ...(modal.lastSaveTriggeredRestart ? [`Restarting ${modal.lastSaveTriggeredRestart}`] : []),
+    ...(modal.lastSettingEffectMessage ? [modal.lastSettingEffectMessage] : []),
+  ];
+  const headerText = `${CATEGORY_LABELS[modal.currentCategory]} (${categoryItemCount(modal, modal.currentCategory)})${notices.length > 0 ? ` · ${notices.join(' · ')}` : ''}`;
   writeText(header, centerStart + 1, centerWidth - 2, headerText, { fg: PALETTE.subtitle, bold: true, bg: PALETTE.footerBg });
   lines.push(header);
 

package/src/shell/service-settings-sync.ts

@@ -0,0 +1,273 @@
+import { mkdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import type { ManagedServiceStatus } from '@pellux/goodvibes-sdk/platform/daemon';
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import {
+  createPlatformServiceManager,
+  getServiceStateRoot,
+  type CliServiceRuntime,
+} from '../cli/service-posture.ts';
+
+type ManagedServiceAction = 'install' | 'uninstall' | 'start' | 'stop' | 'restart' | 'status';
+
+export interface ServiceManagerLike {
+  status(): ManagedServiceStatus;
+  install(): ManagedServiceStatus;
+  uninstall(): ManagedServiceStatus;
+  start(): ManagedServiceStatus;
+  stop(): ManagedServiceStatus;
+  restart(): ManagedServiceStatus;
+}
+
+export interface CommandResult {
+  readonly status: number | null;
+  readonly stdout?: string;
+  readonly stderr?: string;
+}
+
+export interface ServiceSettingsSyncChange {
+  readonly key: ConfigKey;
+  readonly previousValue: unknown;
+  readonly value: unknown;
+}
+
+export interface ServiceSettingsSyncResult {
+  readonly handled: boolean;
+  readonly action?: ManagedServiceAction | 'install-start' | 'disable';
+  readonly status?: ManagedServiceStatus;
+  readonly message?: string;
+  readonly error?: string;
+}
+
+export interface ServiceSettingsSyncOptions {
+  readonly createManager?: (runtime: CliServiceRuntime) => ServiceManagerLike;
+  readonly runCommand?: (command: string, args: readonly string[]) => CommandResult;
+  readonly mkdir?: typeof mkdirSync;
+}
+
+const SERVICE_DEFINITION_KEYS = new Set<ConfigKey>([
+  'service.restartOnFailure',
+  'service.platform',
+  'service.serviceName',
+  'service.logPath',
+] as ConfigKey[]);
+
+function runCommand(command: string, args: readonly string[], options: ServiceSettingsSyncOptions): CommandResult {
+  if (options.runCommand) return options.runCommand(command, args);
+  return spawnSync(command, [...args], { stdio: 'pipe', encoding: 'utf-8' });
+}
+
+function commandError(result: CommandResult): string | null {
+  if ((result.status ?? 1) === 0) return null;
+  return ((result.stderr ?? '') || (result.stdout ?? '') || `command exited with ${result.status}`).trim();
+}
+
+function serviceName(runtime: CliServiceRuntime, fallback = 'goodvibes'): string {
+  return String(runtime.configManager.get('service.serviceName') ?? fallback).trim() || fallback;
+}
+
+function runSystemd(runtime: CliServiceRuntime, args: readonly string[], options: ServiceSettingsSyncOptions): string | null {
+  const result = runCommand('systemctl', ['--user', ...args], options);
+  return commandError(result);
+}
+
+function reloadSystemdIfNeeded(
+  runtime: CliServiceRuntime,
+  status: ManagedServiceStatus,
+  options: ServiceSettingsSyncOptions,
+): string | null {
+  if (status.platform !== 'systemd') return null;
+  return runSystemd(runtime, ['daemon-reload'], options);
+}
+
+function disableSystemService(
+  runtime: CliServiceRuntime,
+  manager: ServiceManagerLike,
+  options: ServiceSettingsSyncOptions,
+): ServiceSettingsSyncResult {
+  const before = manager.status();
+  let disableError: string | null = null;
+  if (before.platform === 'systemd') {
+    disableError = before.installed || before.running
+      ? runSystemd(runtime, ['disable', '--now', `${serviceName(runtime)}.service`], options)
+      : null;
+    if (disableError) {
+      logger.warn('Settings service sync: systemd disable failed', { error: disableError });
+    }
+  } else if (before.running || before.installed) {
+    const stopped = manager.stop();
+    if (stopped.actionError) {
+      return {
+        handled: true,
+        action: 'stop',
+        status: stopped,
+        message: `Service disable failed: ${stopped.actionError}`,
+        error: stopped.actionError,
+      };
+    }
+  }
+
+  const uninstalled = manager.uninstall();
+  const reloadError = reloadSystemdIfNeeded(runtime, uninstalled, options);
+  const error = uninstalled.actionError ?? reloadError ?? disableError ?? undefined;
+  return {
+    handled: true,
+    action: 'disable',
+    status: uninstalled,
+    message: error ? `Service disable failed: ${error}` : 'OS service disabled',
+    ...(error ? { error } : {}),
+  };
+}
+
+function installAndStartSystemService(
+  runtime: CliServiceRuntime,
+  manager: ServiceManagerLike,
+  options: ServiceSettingsSyncOptions,
+): ServiceSettingsSyncResult {
+  (options.mkdir ?? mkdirSync)(getServiceStateRoot(runtime), { recursive: true });
+  const installed = manager.install();
+  if (installed.actionError) {
+    return {
+      handled: true,
+      action: 'install',
+      status: installed,
+      message: `Service install failed: ${installed.actionError}`,
+      error: installed.actionError,
+    };
+  }
+
+  const reloadError = reloadSystemdIfNeeded(runtime, installed, options);
+  if (reloadError) {
+    return {
+      handled: true,
+      action: 'install',
+      status: installed,
+      message: `Service install failed: ${reloadError}`,
+      error: reloadError,
+    };
+  }
+
+  const started = manager.start();
+  const error = started.actionError ?? undefined;
+  return {
+    handled: true,
+    action: 'install-start',
+    status: started,
+    message: error ? `Service start failed: ${error}` : 'OS service installed and started',
+    ...(error ? { error } : {}),
+  };
+}
+
+function refreshInstalledSystemService(
+  runtime: CliServiceRuntime,
+  manager: ServiceManagerLike,
+  options: ServiceSettingsSyncOptions,
+): ServiceSettingsSyncResult {
+  const before = manager.status();
+  if (!before.installed && runtime.configManager.get('service.autostart') !== true) {
+    return {
+      handled: true,
+      action: 'status',
+      status: before,
+      message: 'Service setting saved',
+    };
+  }
+
+  const installed = manager.install();
+  if (installed.actionError) {
+    return {
+      handled: true,
+      action: 'install',
+      status: installed,
+      message: `Service update failed: ${installed.actionError}`,
+      error: installed.actionError,
+    };
+  }
+
+  const reloadError = reloadSystemdIfNeeded(runtime, installed, options);
+  if (reloadError) {
+    return {
+      handled: true,
+      action: 'install',
+      status: installed,
+      message: `Service update failed: ${reloadError}`,
+      error: reloadError,
+    };
+  }
+
+  const next = before.running ? manager.restart() : manager.start();
+  const error = next.actionError ?? undefined;
+  return {
+    handled: true,
+    action: before.running ? 'restart' : 'start',
+    status: next,
+    message: error ? `Service update failed: ${error}` : 'OS service updated',
+    ...(error ? { error } : {}),
+  };
+}
+
+export function syncServiceSettingToPlatform(
+  runtime: CliServiceRuntime,
+  change: ServiceSettingsSyncChange,
+  options: ServiceSettingsSyncOptions = {},
+): ServiceSettingsSyncResult {
+  if (!String(change.key).startsWith('service.')) return { handled: false };
+  if (change.previousValue === change.value) return { handled: true, message: 'Service setting unchanged' };
+
+  const manager = options.createManager?.(runtime) ?? createPlatformServiceManager(runtime);
+
+  try {
+    if (change.key === 'service.autostart') {
+      if (change.value === true) {
+        if (runtime.configManager.get('service.enabled') !== true) {
+          runtime.configManager.setDynamic('service.enabled', true);
+        }
+        return installAndStartSystemService(runtime, manager, options);
+      }
+      return disableSystemService(runtime, manager, options);
+    }
+
+    if (change.key === 'service.enabled') {
+      if (change.value === false) {
+        if (runtime.configManager.get('service.autostart') === true) {
+          runtime.configManager.setDynamic('service.autostart', false);
+        }
+        return disableSystemService(runtime, manager, options);
+      }
+      if (runtime.configManager.get('service.autostart') === true) {
+        return installAndStartSystemService(runtime, manager, options);
+      }
+      return {
+        handled: true,
+        action: 'status',
+        status: manager.status(),
+        message: 'Service mode saved; enable autostart to install the OS service',
+      };
+    }
+
+    if (SERVICE_DEFINITION_KEYS.has(change.key)) {
+      if (runtime.configManager.get('service.enabled') === true && runtime.configManager.get('service.autostart') === true) {
+        return refreshInstalledSystemService(runtime, manager, options);
+      }
+      return {
+        handled: true,
+        action: 'status',
+        status: manager.status(),
+        message: 'Service setting saved; enable autostart to install the OS service',
+      };
+    }
+  } catch (error) {
+    const summarized = summarizeError(error);
+    logger.error('Settings service sync failed', { key: change.key, error: summarized });
+    return {
+      handled: true,
+      action: 'status',
+      status: manager.status(),
+      message: `Service sync failed: ${summarized}`,
+      error: summarized,
+    };
+  }
+
+  return { handled: false };
+}

package/src/shell/ui-openers.ts

@@ -12,6 +12,7 @@ import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config'
 import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
+import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
@@ -26,6 +27,8 @@ type WireShellUiOpenersOptions = {
   subscriptionManager: SubscriptionManager;
   secretsManager?: Pick<SecretsManager, 'delete' | 'get' | 'set'>;
   serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'>;
+  workingDirectory: string;
+  homeDirectory: string;
   getConfiguredProviderIds: () => string[];
   getPinned: () => Promise<string[]>;
   render: () => void;
@@ -89,6 +92,8 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     subscriptionManager,
     secretsManager,
     serviceRegistry,
+    workingDirectory,
+    homeDirectory,
     getConfiguredProviderIds,
     getPinned,
     render,
@@ -264,7 +269,12 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
 
   commandContext.openSettingsModal = (target?: string) => {
     input.modalOpened('settings');
-    input.settingsModal.open(configManager, featureFlags, subscriptionManager, serviceRegistry, mcpRegistry, secretsManager);
+    input.settingsModal.open(configManager, featureFlags, subscriptionManager, serviceRegistry, mcpRegistry, secretsManager, {
+      onSettingApplied: (change) => syncServiceSettingToPlatform(
+        { configManager, workingDirectory, homeDirectory },
+        change,
+      ),
+    });
     input.settingsModal.selectTarget(target);
     render();
   };

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