@pellux/goodvibes-tui 0.22.0 → 0.24.0

package/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.24.0] — 2026-06-12
+
+Fourth best-in-class program release: the engineering-task backlog closed, crash durability made real, and the composer brought to readline parity. Every change passed independent review before commit.
+
+### Features
+- Added composer editing at readline parity: coalesced undo/redo (Ctrl+Z / Ctrl+Shift+Z with cursor restoration), a 32-entry kill ring (Ctrl+K/U, Alt+D, Ctrl+Shift+Y yank, Alt+Y yank-pop with emacs invalidation semantics), Unicode word navigation (Alt+B/F), and a line-count indicator rendered inside the prompt border so footer height never jumps.
+- Added transcript search navigation: n/N next/previous in locked search mode, an honest (wrap) marker on the match count, and the bindings documented in both help overlays.
+- Added a SIGKILL-proof transcript journal: fsync-per-record append-only log between snapshots, with replay wired into every resume seam — command resume, Ctrl+R crash recovery, and panel resume — proven by real-seam tests.
+- Added push notifications for long-running turns (behavior.notifyAfterSeconds): desktop and webhook delivery with metadata only — conversation text can never leak, pinned by literal and compile-time assertions.
+- Added one-key retry from turn errors: r re-submits through the shared failover snapshot path (never a duplicate user message), m opens the model picker; the exhausted-chain notice says plainly that r reuses the same provider.
+- Added /health term: real terminal-capability posture in the doctor surface.
+- Added command grammar conventions enforced by a live-registry lint; settingssync/profilesync/workplan renamed to kebab-case primaries with the old names kept as aliases.
+
+### Fixes
+- Fixed wide-character padding in diff headers, progress rows, and panel spinners (ANSI-aware width everywhere); width-utility docs state the per-code-point contract honestly.
+- Fixed the /pin collision by naming the session-memory command /keep; model favorites keep /pin.
+- Deflaked the websocket reconnect test with a deadline poll.
+
+### Internal
+- Architecture gate detects import cycles (Tarjan SCC, proven against an injected scratch cycle) and enforces 8 directional layer rules; the conversation/system-message-router cycle is genuinely broken.
+- Golden-frame harness pins four renderer surfaces with regen-stable committed snapshots; CI fails on a missing golden.
+- Release pipeline: live verifier runs warn-only in validation, a release-blocking macOS smoke job covers the darwin-arm64 binaries, and release.ts runs all six gates pre-tag.
+- Auth listener behavior pinned by 18 live tests; whole-suite single-process run verified clean (8978 tests); settings-modal split into activation/adjustment modules; CLI management helpers deduplicated.
+- Inline terminal images (Kitty/iTerm2/sixel) explicitly canned by owner decision — images stay as [image N] slugs for identical behavior in every terminal.
+
+## [0.23.0] — 2026-06-12
+
+Third best-in-class program release: provider failover on the turn path, the context/compaction surface completed, the E20 export track closed, and the renderer pinned by golden frames. Every change passed independent review before commit.
+
+### Features
+- Added turn-path provider failover with bounded same-turn retries: the fallback chain is walked with a per-turn visited set, duplicate user messages are prevented by a message-count snapshot and rollback, synthetic models are never failed into, and retries preserve the original content and options.
+- Added /compact preview and after-notice: a clearly labelled estimate before compaction and the real before/after message and token figures from the compaction event when it completes.
+- Added /compact-history: lists past compaction events; restore is list-only until the SDK exposes a snapshot/restore API, and the output says so plainly.
+- Added /keep: pin text into session memory; pinned entries flow into the compaction handoff on both manual and auto-compact paths, with honest session-only wording (named /keep because /pin belongs to model favorites).
+- Added /channel: routes, delivery, status, and policy snapshots for the omnichannel substrate, with --json on every subcommand.
+- Added inbound event narration: GitHub, Slack, ntfy, and webhook events emit a transcript line naming the surface and event before agent dispatch, with self-narration guarded for companion and internal sources.
+
+### Fixes
+- Fixed a command registration collision between the new session-memory pin and the model-favorites /pin by naming the new command /keep.
+- Deflaked the websocket reconnect test with a deadline poll in place of a fixed sleep.
+
+### Internal
+- Architecture gate now detects import cycles (Tarjan SCC over the import graph, proven against an injected scratch cycle) and enforces 8 directional layer rules; the conversation and system-message-router cycle is genuinely broken via the runtime barrel.
+- Auth listener behavior pinned by 18 live tests: default login rate limit (five 401s then 429), proxy-spoofing posture, and empty-password handling.
+- Golden-frame harness pins four renderer surfaces with committed snapshots: regeneration is byte-for-byte stable, a missing golden fails instead of regenerating, and GOODVIBES_UPDATE_GOLDENS=1 is the only write path.
+- CLI management helpers deduplicated into management-utils with openBrowser extracted to a shared utility.
+
 ## [0.22.0] — 2026-06-12
 
 Second best-in-class program release: the backlog tail, the providers/failover track opened, and the release pipeline made fully honest. Every change passed independent review at 10/10 before commit.

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.22.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.24.0-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.
 
@@ -803,7 +803,7 @@ Key commands:
 - `/update`
 - `/trust`
 - `/bridge`
-- `/profilesync`
+- `/profile-sync`
 
 The setup surface is also broader than a single readiness screen:
 
@@ -848,7 +848,7 @@ GoodVibes includes an automation layer with:
 - cron-like scheduled agent tasks with timezone-aware schedules, missed-run tracking, run history, and manual trigger support
 - TUI-owned project planning with readiness gaps, one-question-at-a-time clarification, project language, decision records, task/dependency/verification metadata, and explicit execution approval
 - planning commands with project-planning inspection, active-plan review, and mode/explain/override/status controls
-- persistent work-plan tracking for concrete task checklists via `/workplan`
+- persistent work-plan tracking for concrete task checklists via `/work-plan`
 
 Key commands:
 
@@ -874,7 +874,7 @@ Key commands:
 
 - `/services inspect|test|resolve|auth|auth-review|doctor|export|import`
 - `/profiles`
-- `/profilesync`
+- `/profile-sync`
 - `/setup transfer export|inspect|import`
 
 Service entries can use existing `tokenKey` fields, a SecretRef in the key field, or explicit `tokenRef` / `passwordRef` / `webhookUrlRef` / `signingSecretRef` / `publicKeyRef` / `appTokenRef` fields:
@@ -1281,7 +1281,7 @@ Those pieces cover conversation-noise routing, panel-health/performance budgets,
 | `/git [action]` | `/g` | Git commands: status, log, diff. Opens git panel if no action given |
 | `/scan` | — | Scan for local LLM servers |
 | `/plan [goal]` | — | Inspect or seed TUI-owned project planning state; `panel`, `approve`, `list`, and `show <id>` are supported |
-| `/workplan [action]` | `/wp`, `/todo` | Open or update the persistent workspace work-plan checklist |
+| `/work-plan [action]` | `/wp`, `/todo` | Open or update the persistent workspace work-plan checklist |
 | `/panel [action]` | `/panels` | Panel management: open, close, list, toggle, move, focus, split, width, height |
 | `/plugin [action]` | — | Manage plugins (enable/disable/reload/list) |
 | `/marketplace [action]` | — | Browse curated plugin, skill, hook-pack, and policy-pack surfaces |
@@ -1333,14 +1333,23 @@ All shortcuts are customizable via `~/.goodvibes/tui/keybindings.json`. Use `/ke
 | `Enter` | Send message |
 | `Shift+Enter` | Insert newline |
 | `Tab` | Toggle block collapse / path completion |
-| `Ctrl+U` | Clear the prompt line |
-| `Ctrl+W` | Delete word backward |
-| `Ctrl+K` | Kill to end of line |
+| `Ctrl+U` | Kill to start of line (push to kill ring) |
+| `Alt+U` | Clear entire prompt |
+| `Ctrl+W` | Kill word backward (push to kill ring) |
+| `Ctrl+K` | Kill to end of line (push to kill ring) |
+| `Alt+D` | Kill word forward (push to kill ring) |
+| `Ctrl+Shift+Y` | Yank from kill ring |
+| `Alt+Y` | Yank-pop (rotate kill ring, replace last yank) |
+| `Alt+B` | Move word backward |
+| `Alt+F` | Move word forward |
 | `Ctrl+Z` | Undo prompt edit |
 | `Ctrl+Shift+Z` | Redo prompt edit |
 | `Ctrl+V` | Paste (image or text) |
 | `@` | Open file picker (insert file path) |
 | `?` | Open help/command picker (empty prompt) |
+| `r` / `m` | After a turn error: retry the turn / open the model picker (any other key dismisses) |
+
+> **Note:** `Ctrl+W` uses whitespace-delimited word boundaries (readline/unix-word-rubout semantics), while `Alt+D`, `Alt+B`, and `Alt+F` use Unicode word boundaries (letters, digits, underscore).
 
 ### Navigation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "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/management-commands.ts

@@ -10,7 +10,7 @@ import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platfo
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { classifyBindPosture, isNetworkFacing } from './network-posture.ts';
 import type { CliCommandRuntime } from './types.ts';
-import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser, probeTcp, readAuthPaths, runNonInteractiveAgent, urlHostForBindHost, withRuntimeServices, yesNo } from './management.ts';
+import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser, probeTcp, readAuthPaths, runNonInteractiveAgent, urlHostForBindHost, withRuntimeServices, yesNo } from './management-utils.ts';
 
 export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<string> {
   return await withRuntimeServices(runtime, async (services) => {

package/src/cli/management-utils.ts

@@ -0,0 +1,352 @@
+/**
+ * management-utils.ts — shared CLI utility functions.
+ *
+ * Extracted from management.ts to break the import cycle:
+ *   management.ts ↔ management-commands.ts
+ *   management.ts ↔ surface-command.ts
+ *
+ * Both management-commands.ts and surface-command.ts import from here;
+ * management.ts also imports from here (no longer from the child modules
+ * for these utilities).
+ *
+ * No imports from management-commands.ts or surface-command.ts are allowed
+ * in this file — that would recreate the cycle.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { networkInterfaces } from 'node:os';
+import type { ConfigManager, GoodVibesConfig } from '../config/index.ts';
+import { bootstrapRuntime } from '../runtime/bootstrap.ts';
+import { createRuntimeServices } from '../runtime/services.ts';
+import { createRuntimeStore } from '../runtime/store/index.ts';
+import type { RuntimeServices } from '../runtime/services.ts';
+import { RuntimeEventBus, type TurnEvent, createShellPathService } from '@/runtime/index.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { resolveRuntimeEndpointBinding } from './endpoints.ts';
+import { applyRuntimeEndpointFlagOverrides } from './config-overrides.ts';
+import type { RuntimeEndpointId } from './endpoints.ts';
+import type { CliCommandRuntime, GoodVibesCliParseResult } from './types.ts';
+import { openBrowser as _openBrowser } from '../utils/browser.ts';
+
+type Formatter = (value: unknown, text: string) => string;
+
+export function yesNo(value: unknown): string {
+  return value === true ? 'yes' : 'no';
+}
+
+export function formatJsonOrText(cli: GoodVibesCliParseResult): Formatter {
+  return (value, text) => cli.flags.outputFormat === 'json'
+    ? JSON.stringify(value, null, 2)
+    : text;
+}
+
+export function exitCodeForText(output: string): number {
+  if (output.startsWith('Usage:') || output.startsWith('Invalid ')) return 2;
+  if (output.startsWith('Session not found:') || output.startsWith('Unknown task:') || output.startsWith('Task submit failed ')) return 1;
+  if (output.startsWith('No stored ') || output.startsWith('No pending ') || output.startsWith('No model ') || output.startsWith('No provider ') || output.startsWith('No auth ')) return 1;
+  if (output.startsWith('Unknown ')) return 1;
+  if (output === 'Bundle has no config object to import.') return 1;
+  return 0;
+}
+
+export function splitCommandOption(token: string): { readonly name: string; readonly value: string | undefined } {
+  const index = token.indexOf('=');
+  if (index < 0) return { name: token, value: undefined };
+  return { name: token.slice(0, index), value: token.slice(index + 1) };
+}
+
+export function readOptionValue(args: readonly string[], name: string): string | undefined {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    const split = splitCommandOption(token);
+    if (split.name !== name) continue;
+    if (split.value !== undefined) return split.value;
+    const next = args[index + 1];
+    if (next === undefined || next.startsWith('--')) return undefined;
+    return next;
+  }
+  return undefined;
+}
+
+export function readOptionValues(args: readonly string[], name: string): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    const split = splitCommandOption(token);
+    if (split.name !== name) continue;
+    if (split.value !== undefined) {
+      values.push(split.value);
+      continue;
+    }
+    const next = args[index + 1];
+    if (next !== undefined && !next.startsWith('--')) values.push(next);
+  }
+  return values;
+}
+
+export function hasCommandFlag(args: readonly string[], name: string): boolean {
+  return args.some((arg) => splitCommandOption(arg).name === name);
+}
+
+export function commandValues(args: readonly string[]): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (!token.startsWith('--')) {
+      values.push(token);
+      continue;
+    }
+    if (!token.includes('=') && args[index + 1] && !args[index + 1]!.startsWith('--')) index += 1;
+  }
+  return values;
+}
+
+export function readPassword(args: readonly string[]): string | null {
+  const explicit = readOptionValue(args, '--password');
+  if (explicit !== undefined) return explicit;
+  if (hasCommandFlag(args, '--password-stdin')) return readFileSync(0, 'utf-8').trimEnd();
+  return process.env.GOODVIBES_AUTH_PASSWORD ?? null;
+}
+
+export function extractAuthorizationCode(input: string): string {
+  try {
+    const url = new URL(input);
+    return url.searchParams.get('code') ?? input;
+  } catch {
+    return input;
+  }
+}
+
+export function isPresentConfigValue(value: unknown): boolean {
+  if (typeof value === 'string') return value.trim().length > 0;
+  return value !== undefined && value !== null && value !== false;
+}
+
+export function getNestedValue(source: unknown, key: string): unknown {
+  let cursor = source;
+  for (const part of key.split('.')) {
+    if (cursor == null || typeof cursor !== 'object') return undefined;
+    cursor = (cursor as Record<string, unknown>)[part];
+  }
+  return cursor;
+}
+
+function getLocalNetworkIp(): string {
+  try {
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+      for (const netInfo of nets[name] ?? []) {
+        if (netInfo.family === 'IPv4' && !netInfo.internal) return netInfo.address;
+      }
+    }
+  } catch {
+    return '127.0.0.1';
+  }
+  return '127.0.0.1';
+}
+
+function connectHostForBindHost(host: string): string {
+  if (host === '0.0.0.0' || host === '::') return '127.0.0.1';
+  return host || '127.0.0.1';
+}
+
+export function urlHostForBindHost(host: string): string {
+  if (host === '0.0.0.0' || host === '::') return getLocalNetworkIp();
+  return host || '127.0.0.1';
+}
+
+export function enableServicePosture(config: ConfigManager): void {
+  config.setDynamic('service.enabled', true);
+  config.setDynamic('service.autostart', true);
+  config.setDynamic('service.restartOnFailure', true);
+}
+
+export function enableEndpointLanDefault(config: ConfigManager, endpoint: RuntimeEndpointId): void {
+  const binding = resolveRuntimeEndpointBinding(config, endpoint);
+  if (binding.hostMode === 'custom') return;
+  if (endpoint === 'controlPlane') {
+    config.setDynamic('controlPlane.hostMode', 'network');
+    config.setDynamic('controlPlane.host', '0.0.0.0');
+    config.setDynamic('controlPlane.allowRemote', true);
+    return;
+  }
+  if (endpoint === 'httpListener') {
+    config.setDynamic('httpListener.hostMode', 'network');
+    config.setDynamic('httpListener.host', '0.0.0.0');
+    return;
+  }
+  config.setDynamic('web.hostMode', 'network');
+  config.setDynamic('web.host', '0.0.0.0');
+}
+
+export function applyTargetEndpointFlagsOrDefault(
+  runtime: CliCommandRuntime,
+  endpoint: RuntimeEndpointId,
+): string | null {
+  const errors = applyRuntimeEndpointFlagOverrides(runtime.configManager, endpoint, runtime.cli.flags);
+  if (errors.length > 0) return errors.join('\n');
+  if (runtime.cli.flags.hostname === undefined) {
+    enableEndpointLanDefault(runtime.configManager, endpoint);
+  }
+  if (endpoint === 'controlPlane') {
+    const binding = resolveRuntimeEndpointBinding(runtime.configManager, endpoint);
+    runtime.configManager.setDynamic('controlPlane.allowRemote', binding.hostMode !== 'local');
+  }
+  return null;
+}
+
+/**
+ * Re-export openBrowser from utils/browser.ts for backward compatibility.
+ * management.ts and management-commands.ts both used to export/import this;
+ * now all callers should prefer importing from utils/browser.ts directly.
+ */
+export { openBrowser } from '../utils/browser.ts';
+
+export async function probeTcp(host: string, port: number, timeoutMs = 750): Promise<boolean> {
+  return await new Promise<boolean>((resolve) => {
+    const socket = net.createConnection({ host: connectHostForBindHost(host), port });
+    const finish = (value: boolean) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+  });
+}
+
+export async function withRuntimeServices<T>(
+  runtime: CliCommandRuntime,
+  fn: (services: RuntimeServices) => Promise<T> | T,
+): Promise<T> {
+  const runtimeBus = new RuntimeEventBus();
+  const runtimeStore = createRuntimeStore();
+  const services = createRuntimeServices({
+    configManager: runtime.configManager,
+    runtimeBus,
+    runtimeStore,
+    workingDir: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+  services.providerRegistry.initModelLimits();
+  services.benchmarkStore.initBenchmarks();
+  services.providerRegistry.initCatalog();
+  try {
+    await services.providerRegistry.ready();
+    return await fn(services);
+  } finally {
+    services.providerRegistry.stopWatching();
+  }
+}
+
+export function readAuthPaths(runtime: CliCommandRuntime) {
+  const shellPaths = createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+  const userStorePath = shellPaths.resolveUserPath('tui', 'auth-users.json');
+  const bootstrapCredentialPath = shellPaths.resolveUserPath('tui', 'auth-bootstrap.txt');
+  const operatorTokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  return {
+    userStorePath,
+    userStorePresent: existsSync(userStorePath),
+    bootstrapCredentialPath,
+    bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
+    operatorTokenPath,
+    operatorTokenPresent: existsSync(operatorTokenPath),
+  };
+}
+
+export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
+  const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
+  if (!prompt) {
+    console.error('Usage: goodvibes run|exec [prompt]');
+    return 2;
+  }
+
+  const outputFormat = runtime.cli.flags.outputFormat;
+  const ctx = await bootstrapRuntime(process.stdout, {
+    configManager: runtime.configManager,
+    workingDir: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+
+  const events: TurnEvent[] = [];
+  let finalResponse = '';
+  let finalError = '';
+  let finalStopReason = '';
+  let exitCode = 0;
+
+  const done = new Promise<void>((resolve) => {
+    const unsubs = [
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'STREAM_DELTA' }>>('STREAM_DELTA', ({ payload }) => {
+        events.push(payload);
+        if (outputFormat === 'stream-json') {
+          process.stdout.write(JSON.stringify({ type: payload.type, content: payload.content, accumulated: payload.accumulated }) + '\n');
+        }
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_COMPLETED' }>>('TURN_COMPLETED', ({ payload }) => {
+        events.push(payload);
+        finalResponse = payload.response;
+        finalStopReason = payload.stopReason;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_ERROR' }>>('TURN_ERROR', ({ payload }) => {
+        events.push(payload);
+        finalError = payload.error;
+        finalStopReason = payload.stopReason;
+        exitCode = 1;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+      ctx.runtimeBus.on<Extract<TurnEvent, { type: 'TURN_CANCEL' }>>('TURN_CANCEL', ({ payload }) => {
+        events.push(payload);
+        finalError = payload.reason ?? 'cancelled';
+        finalStopReason = payload.stopReason;
+        exitCode = 130;
+        for (const unsub of unsubs) unsub();
+        resolve();
+      }),
+    ];
+  });
+
+  try {
+    await ctx.orchestrator.handleUserInput(prompt);
+    await done;
+    if (outputFormat === 'json') {
+      process.stdout.write(JSON.stringify({
+        ok: exitCode === 0,
+        response: finalResponse,
+        error: finalError || undefined,
+        stopReason: finalStopReason,
+        sessionId: ctx.runtime.sessionId,
+        model: ctx.runtime.model,
+        provider: ctx.runtime.provider,
+        events: events.length,
+      }, null, 2) + '\n');
+    } else if (outputFormat !== 'stream-json') {
+      process.stdout.write((exitCode === 0 ? finalResponse : finalError) + '\n');
+    } else {
+      process.stdout.write(JSON.stringify({
+        type: exitCode === 0 ? 'TURN_COMPLETED' : 'TURN_ERROR',
+        ok: exitCode === 0,
+        response: finalResponse,
+        error: finalError || undefined,
+        stopReason: finalStopReason,
+      }) + '\n');
+    }
+  } finally {
+    const snapshot = ctx.conversation.toJSON() as Parameters<typeof ctx.shutdown>[0];
+    await ctx.shutdown(snapshot);
+  }
+  return exitCode;
+}
+
+/** @deprecated Use ConfigManager directly. Kept for backward compat with management.ts usages. */
+export type { GoodVibesConfig };