@pellux/goodvibes-agent 1.9.1 → 1.10.0

package/src/input/commands/runtime-services.ts

@@ -16,7 +16,6 @@ import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { HookApi } from '@pellux/goodvibes-sdk/platform/hooks';
 import type { McpApi } from '@pellux/goodvibes-sdk/platform/mcp';
 import type { OperatorClient } from '@/runtime/index.ts';
-import type { OpsApi } from '@/runtime/index.ts';
 import type { PeerClient } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
 import type { ProviderApi } from '@pellux/goodvibes-sdk/platform/providers';
@@ -239,10 +238,6 @@ export function requireMcpApi(context: CommandContext): McpApi {
   return requireContextValue(context.clients?.mcpApi, 'clients.mcpApi');
 }
 
-export function requireOpsApi(context: CommandContext): OpsApi {
-  return requireContextValue(context.clients?.opsApi, 'clients.opsApi');
-}
-
 export function requireDirectTransport(context: CommandContext): DirectTransport {
   return requireContextValue(context.clients?.transport, 'clients.transport');
 }

package/src/input/commands/update-runtime.ts

@@ -0,0 +1,313 @@
+/**
+ * `/update` — a real self-update path for binary installs. The
+ * download-verify-swap mechanics are the SDK's canonical update policy module
+ * (platform/runtime/self-update), the same mechanism the TUI's `/update` and
+ * the daemon's hourly loop follow: one update mechanism everywhere. This file
+ * owns only the agent's /update UX: install-kind gating, this repo's release
+ * asset layout, and the printed report.
+ *
+ * Subcommands:
+ *   /update [check]   — resolve the latest release tag and report whether this
+ *                       build is already current.
+ *   /update apply     — for a binary install (a directly-downloaded release
+ *                       binary), download + verify + atomically swap the agent
+ *                       binary, and refresh the sqlite-vec native addon in
+ *                       lockstep so the vector index never goes stale beside a
+ *                       new binary. Every swap parks the outgoing file at
+ *                       `<path>.previous`, so the replaced version is always
+ *                       kept. For any other install kind, prints the exact
+ *                       command to run instead — it never attempts a swap it
+ *                       can't do safely.
+ *   /update rollback  — exchange each installed file with its kept `.previous`
+ *                       counterpart: one command back to the version that ran
+ *                       before the last update (and, being an exchange, one
+ *                       more command forward again).
+ *
+ * The agent ships ONE binary and no daemon binary, and its addon travels as a
+ * tar.gz ARCHIVE asset (see release-artifacts.ts) rather than a bare file —
+ * so the addon bytes are downloaded and checksum-verified as the archive,
+ * extracted in memory, and only then swapped with the same keep-previous
+ * mechanics as the binary. Verification order is strict: the addon archive is
+ * fully verified and extracted BEFORE the binary swap begins, so a corrupted
+ * addon download can never leave a new binary beside a stale (or half-written)
+ * addon.
+ */
+import { dirname, join } from 'node:path';
+import {
+  applyVerifiedUpdate,
+  realUpdateFileIo,
+  rollbackKeptPrevious,
+  sha256,
+  swapFileAtomically,
+  verifyChecksum,
+  type UpdateFileIo,
+} from '@pellux/goodvibes-sdk/platform/runtime/self-update';
+import type { CommandRegistry } from '../command-registry.ts';
+import { VERSION } from '../../version.ts';
+import {
+  CHECKSUM_MANIFEST_NAME,
+  extractTarGzEntry,
+  parseChecksumFile,
+  resolveAgentBinaryAssetName,
+  resolveSqliteVecArchive,
+} from '../../runtime/release-artifacts.ts';
+import {
+  compareVersions,
+  detectInstallKind,
+  fallbackUpdateCommand,
+  normalizeVersion,
+  resolveLatestReleaseTag,
+  type InstallKind,
+  type UpdateFetchLike,
+} from '../../runtime/update-check.ts';
+
+const REPO_RELEASES_LATEST_URL = 'https://github.com/mgd34msu/goodvibes-agent/releases/latest';
+
+function releaseDownloadBaseUrl(tag: string): string {
+  return `https://github.com/mgd34msu/goodvibes-agent/releases/download/${tag}`;
+}
+
+/**
+ * Suffix under which every swap keeps the file it replaced — re-exported from
+ * the SDK's canonical update policy module so rollback and swap share one
+ * definition everywhere.
+ */
+export { PREVIOUS_FILE_SUFFIX } from '@pellux/goodvibes-sdk/platform/runtime/self-update';
+import { PREVIOUS_FILE_SUFFIX } from '@pellux/goodvibes-sdk/platform/runtime/self-update';
+
+async function downloadBytes(fetchImpl: UpdateFetchLike, url: string): Promise<Buffer> {
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    throw new Error(`download failed (${response.status}) for ${url}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+export interface CheckForUpdateResult {
+  readonly latestTag: string;
+  readonly isCurrent: boolean;
+}
+
+export async function checkForUpdate(fetchImpl: UpdateFetchLike, currentVersion: string): Promise<CheckForUpdateResult> {
+  const latestTag = await resolveLatestReleaseTag(fetchImpl, REPO_RELEASES_LATEST_URL);
+  const isCurrent = compareVersions(currentVersion, latestTag) >= 0;
+  return { latestTag, isCurrent };
+}
+
+export interface ApplyUpdateOptions {
+  readonly fetchImpl: UpdateFetchLike;
+  readonly execPath: string;
+  readonly platform: NodeJS.Platform;
+  readonly arch: string;
+  readonly currentVersion: string;
+  readonly print: (line: string) => void;
+  /** Injectable filesystem seam (the SDK's UpdateFileIo) so tests observe swaps in memory. */
+  readonly io?: UpdateFileIo;
+}
+
+/**
+ * The real self-update path, delegating the download-verify-swap mechanics to
+ * the SDK's canonical update policy module. For a binary install: resolve the
+ * latest tag, compare to the running version, and if newer, verify and stage
+ * the addon archive first (bytes in memory, no writes), run the binary
+ * download-verify-swap, then swap the extracted addon file — each swap keeps
+ * the outgoing file at `<path>.previous`. For any other install kind, never
+ * attempts a swap — it prints the exact command for that install method
+ * instead.
+ */
+export async function applyUpdate(options: ApplyUpdateOptions): Promise<void> {
+  const installKind: InstallKind = detectInstallKind(options.execPath);
+  if (installKind !== 'binary') {
+    options.print(
+      [
+        `This install is not a self-updatable binary install (detected: ${installKind === 'bun-global-package' ? 'bun/npm package install' : 'running from source'}).`,
+        `Update with: ${fallbackUpdateCommand(installKind)}`,
+      ].join('\n'),
+    );
+    return;
+  }
+
+  const latestTag = await resolveLatestReleaseTag(options.fetchImpl, REPO_RELEASES_LATEST_URL);
+  if (compareVersions(options.currentVersion, latestTag) >= 0) {
+    options.print(`Already current: running v${normalizeVersion(options.currentVersion)}, latest release is ${latestTag}.`);
+    return;
+  }
+
+  const binaryAsset = resolveAgentBinaryAssetName(options.platform, options.arch);
+  if (!binaryAsset) {
+    options.print(`No prebuilt binaries are published for ${options.platform}-${options.arch}; cannot self-update.`);
+    return;
+  }
+
+  options.print(`Update available: ${latestTag} (running v${normalizeVersion(options.currentVersion)}). Downloading and verifying...`);
+
+  const baseUrl = releaseDownloadBaseUrl(latestTag);
+  const io = options.io ?? realUpdateFileIo;
+  const appBinaryPath = options.execPath;
+
+  // The sqlite-vec native addon travels with the binary as a tar.gz archive
+  // asset: refresh it in the same update so /update never leaves a new binary
+  // beside a stale addon. The manifest entry decides whether the target
+  // release ships it — an entry that IS present makes the download, checksum,
+  // and extraction mandatory (any failure is fatal, verified before the
+  // binary swap begins), while an absent entry means the target predates the
+  // addon archives and is skipped rather than blocking an otherwise-valid
+  // binary update.
+  const manifestBytes = await downloadBytes(options.fetchImpl, `${baseUrl}/${CHECKSUM_MANIFEST_NAME}`);
+  const checksums = parseChecksumFile(manifestBytes.toString('utf-8'));
+  const addon = resolveSqliteVecArchive(options.platform, options.arch);
+  const addonIncluded = addon !== null && checksums.get(addon.assetName) !== undefined;
+  let addonFileBytes: Buffer | null = null;
+  let addonTargetPath: string | null = null;
+  if (addon && addonIncluded) {
+    const archiveBytes = await downloadBytes(options.fetchImpl, `${baseUrl}/${addon.assetName}`);
+    verifyChecksum(addon.assetName, sha256(archiveBytes), checksums.get(addon.assetName));
+    addonFileBytes = extractTarGzEntry(archiveBytes, addon.entryPath);
+    if (addonFileBytes === null) {
+      throw new Error(`addon archive ${addon.assetName} verified but holds no ${addon.entryPath} — refusing a partial update`);
+    }
+    addonTargetPath = join(dirname(appBinaryPath), 'lib', addon.dirName, addon.fileName);
+  }
+
+  // One mechanism everywhere: downloads + verifies the binary against the
+  // same manifest, then swaps it atomically with the outgoing file kept at
+  // `<path>.previous`. The addon bytes above are already verified, so the
+  // addon swap after this cannot fail on bad data.
+  await applyVerifiedUpdate({
+    fetchImpl: options.fetchImpl,
+    downloadBaseUrl: baseUrl,
+    targets: [{ label: 'agent binary', path: appBinaryPath, assetName: binaryAsset, executable: true }],
+    io,
+    platform: options.platform,
+  });
+  if (addonFileBytes !== null && addonTargetPath !== null) {
+    swapFileAtomically(addonTargetPath, addonFileBytes, { executable: false, io, platform: options.platform });
+  }
+
+  options.print(
+    [
+      `Updated to ${latestTag}.`,
+      `  agent binary:  ${appBinaryPath}`,
+      ...(addonTargetPath
+        ? [`  vector addon:  ${addonTargetPath}`]
+        : [`  vector addon:  the ${latestTag} release ships no ${addon?.assetName ?? 'addon archive'} for this platform — left untouched`]),
+      '',
+      'Restart goodvibes-agent to run the new version.',
+    ].join('\n'),
+  );
+}
+
+export interface RollbackUpdateOptions {
+  readonly execPath: string;
+  readonly platform: NodeJS.Platform;
+  readonly arch: string;
+  readonly print: (line: string) => void;
+  /** Injectable filesystem seam (the SDK's UpdateFileIo) so tests observe renames in memory. */
+  readonly io?: UpdateFileIo;
+}
+
+/**
+ * One-command rollback to the version that ran before the last update,
+ * delegating the exchange mechanics to the SDK's rollbackKeptPrevious (the
+ * same module the swap uses): every installed file (agent binary, vector
+ * addon) that has a kept `.previous` counterpart is EXCHANGED with it — the
+ * previous version becomes live, and the version being rolled back is itself
+ * kept at `.previous`, so a second `/update rollback` rolls forward again.
+ * Files without a kept counterpart are reported and left untouched; nothing
+ * is downloaded.
+ */
+export function rollbackUpdate(options: RollbackUpdateOptions): void {
+  const installKind: InstallKind = detectInstallKind(options.execPath);
+  if (installKind !== 'binary') {
+    options.print(
+      [
+        `This install is not a self-updatable binary install (detected: ${installKind === 'bun-global-package' ? 'bun/npm package install' : 'running from source'}), so there is no kept previous binary to roll back to.`,
+        `Install a specific version with your package manager instead, e.g.: ${fallbackUpdateCommand(installKind)}`,
+      ].join('\n'),
+    );
+    return;
+  }
+
+  const io = options.io ?? realUpdateFileIo;
+  const addon = resolveSqliteVecArchive(options.platform, options.arch);
+  const targets = [
+    { label: 'agent binary', path: options.execPath },
+    ...(addon ? [{ label: 'vector addon', path: join(dirname(options.execPath), 'lib', addon.dirName, addon.fileName) }] : []),
+  ];
+
+  const result = rollbackKeptPrevious(targets, io);
+  if (result.restored.length === 0) {
+    options.print(
+      `No previous version is kept beside this install (nothing at ${options.execPath}${PREVIOUS_FILE_SUFFIX}). ` +
+      'The previous version is kept from the next update onward.',
+    );
+    return;
+  }
+
+  options.print(
+    [
+      'Rolled back to the previously installed version.',
+      ...result.restored.map((target) => `  ${target.label}: ${target.path} (the replaced version is kept at ${target.path}${PREVIOUS_FILE_SUFFIX})`),
+      '',
+      'Restart goodvibes-agent to run the restored version.',
+    ].join('\n'),
+  );
+}
+
+export function registerUpdateCommand(registry: CommandRegistry): void {
+  registry.register({
+    name: 'update',
+    aliases: ['upgrade'],
+    description: 'Check for a newer GoodVibes Agent release and, for binary installs, download/verify/apply it or roll back to the kept previous version',
+    usage: '[check|apply|rollback]',
+    async handler(args, ctx) {
+      const sub = args[0] ?? 'check';
+
+      if (sub === 'check') {
+        try {
+          const result = await checkForUpdate(fetch as UpdateFetchLike, VERSION);
+          ctx.print(
+            result.isCurrent
+              ? `Already current: running v${normalizeVersion(VERSION)} (latest release is ${result.latestTag}).`
+              : `Update available: ${result.latestTag} (running v${normalizeVersion(VERSION)}). Run /update apply to install it.`,
+          );
+        } catch (error) {
+          ctx.print(`Could not check for updates: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
+      if (sub === 'apply') {
+        try {
+          await applyUpdate({
+            fetchImpl: fetch as UpdateFetchLike,
+            execPath: process.execPath,
+            platform: process.platform,
+            arch: process.arch,
+            currentVersion: VERSION,
+            print: ctx.print,
+          });
+        } catch (error) {
+          ctx.print(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
+      if (sub === 'rollback') {
+        try {
+          rollbackUpdate({
+            execPath: process.execPath,
+            platform: process.platform,
+            arch: process.arch,
+            print: ctx.print,
+          });
+        } catch (error) {
+          ctx.print(`Rollback failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
+      ctx.print('Usage: /update [check|apply|rollback]');
+    },
+  });
+}

package/src/input/commands.ts

@@ -41,6 +41,7 @@ import { registerOperatorActionRuntimeCommands } from './commands/operator-actio
 import { registerConnectedHostAdminCommands } from './commands/connected-host-admin-runtime.ts';
 import { registerEmailRuntimeCommands } from './commands/email-runtime.ts';
 import { registerCalendarRuntimeCommands } from './commands/calendar-runtime.ts';
+import { registerUpdateCommand } from './commands/update-runtime.ts';
 
 function registerAgentMemoryCommand(registry: CommandRegistry): void {
   registry.register({
@@ -90,6 +91,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerLocalProviderRuntimeCommands(registry);
   registerNetworkScanRuntimeCommands(registry);
   registerHealthRuntimeCommands(registry);
+  registerUpdateCommand(registry);
   registerProviderAccountsRuntimeCommands(registry);
   registerConversationRuntimeCommands(registry);
   registerQrcodeRuntimeCommands(registry);

package/src/input/feed-context-factory.ts

@@ -95,9 +95,9 @@ export interface FeedContextStableRefs {
   selection: SelectionManager;
   pasteRegistry: Map<string, string>;
   imageRegistry: Map<string, { data: string; mediaType: string }>;
-  /** Ported from goodvibes-tui's DEBT-5 item 5; mutated in place, never reallocated. */
+  /** Ported from goodvibes-tui's unbracketed-paste-flood guard; mutated in place, never reallocated. */
   burstGuard: PanelBurstGuardState;
-  /** OS-level terminal focus tracker, ported from goodvibes-tui's W2.3. */
+  /** OS-level terminal focus tracker, ported from goodvibes-tui's core/focus-tracker.ts. */
   focusTracker: FocusTracker;
   projectRoot: string;
   selectionModal: SelectionModal;

package/src/input/handler-feed.ts

@@ -64,13 +64,13 @@ import type { FocusTracker } from '../core/focus-tracker.ts';
  *   - `inputHistory`, `conversationManager` — late-wired service handles; synced at
  *     feed() entry only since no in-feed action rewires them
  *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
- *   - `burstGuard` (ported from goodvibes-tui's DEBT-5 item 5) — the
+ *   - `burstGuard` (ported from goodvibes-tui's panel-paste-flood-guard.ts) — the
  *     unbracketed-paste-flood guard's sliding-window state, mutated in place
  *     across tokens by trackPanelPasteFloodGuard (see panel-paste-flood-guard.ts).
  *     Never reallocated. `burstSuppressedCount` is this wiring layer's own
  *     bookkeeping (not part of the ported module) for the honest resolution
  *     notice — see feedInputTokens below.
- *   - `focusTracker` (ported from goodvibes-tui's W2.3) — tracks OS-level
+ *   - `focusTracker` (ported from goodvibes-tui's core/focus-tracker.ts) — tracks OS-level
  *     terminal focus from `\x1b[I`/`\x1b[O` tokens (DECSET ?1004h, enabled in
  *     main.ts). Shared instance from RuntimeServices, threaded via
  *     uiServices.platform.focusTracker (mirrors the TUI's own wiring).
@@ -105,11 +105,11 @@ export interface InputFeedContext {
   contentWidth: number;
   readonly pasteRegistry: Map<string, string>;
   readonly imageRegistry: Map<string, { data: string; mediaType: string }>;
-  /** Ported from goodvibes-tui DEBT-5 item 5 — mutated in place, never reallocated. */
+  /** Ported from goodvibes-tui's paste-flood guard — mutated in place, never reallocated. */
   readonly burstGuard: PanelBurstGuardState;
   /** Wiring-layer bookkeeping (not part of the ported module) for the honest suppressed-count notice. */
   burstSuppressedCount: number;
-  /** Ported from goodvibes-tui W2.3 — OS-level terminal focus, fed from 'focus' tokens below. */
+  /** Ported from goodvibes-tui's focus tracker — OS-level terminal focus, fed from 'focus' tokens below. */
   readonly focusTracker: FocusTracker;
   readonly projectRoot: string;
   readonly selection: SelectionManager;
@@ -178,11 +178,11 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
   const keybindings = context.keybindingsManager;
   // One `now` per feed() call (not per token) — a genuine unbracketed-paste
   // flood delivers many tokens in one drain, and they should all measure as
-  // arriving "at once" (mirrors goodvibes-tui's handler-feed.ts DEBT-5 item 5 doc).
+  // arriving "at once" (mirrors the same doc note in goodvibes-tui's handler-feed.ts).
   const now = Date.now();
 
   for (const token of tokens) {
-    // Ported from goodvibes-tui W2.3: focus-reporting tokens (CSI ?1004h)
+    // Ported from goodvibes-tui's focus tracking: focus-reporting tokens (CSI ?1004h)
     // never reach the composer or any modal route — consumed here, first,
     // unconditionally. No render needed.
     if (token.type === 'focus') {
@@ -294,8 +294,8 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       }
     }
 
-    // Ported from goodvibes-tui's panel-paste-flood-guard.ts, DEBT-5 item
-    // 5: guards command-mode's key-driven dispatch (handleCommandModeToken,
+    // Ported from goodvibes-tui's panel-paste-flood-guard.ts: guards
+    // command-mode's key-driven dispatch (handleCommandModeToken,
     // below) from an unbracketed-paste-replay or control-character-injection
     // burst.
     //

package/src/input/handler.ts

@@ -94,7 +94,7 @@ export class InputHandler {
   public pasteRegistry = new Map<string, string>();
   public nextPasteId = 1;
   public lastCtrlCTime = 0;
-  /** Ported from goodvibes-tui DEBT-5 item 5 — unbracketed-paste-flood guard state, mutated in place. */
+  /** Ported from goodvibes-tui — unbracketed-paste-flood guard state, mutated in place. */
   public burstGuard: PanelBurstGuardState = { timestamps: [], suspended: false, hintShown: false };
   /** Long-lived feed context — reused across every feed() call to avoid per-keystroke allocation. */
   public feedContext!: import('./handler-feed.ts').InputFeedContext;

package/src/input/mcp-workspace.ts

@@ -150,7 +150,11 @@ function serverConfigToForm(server?: McpServerConfig): McpWorkspaceForm {
   };
 }
 
-function formToServerConfig(form: McpWorkspaceForm): McpServerConfig {
+// The workspace form edits stdio (command-launched) servers only, so the
+// converted config always carries a command; streamable-HTTP (url) servers
+// from the SDK's widened McpServerConfig appear in the list but are managed
+// through the /mcp command line.
+function formToServerConfig(form: McpWorkspaceForm): McpServerConfig & { command: string } {
   const name = form.name.trim();
   const command = form.command.trim();
   if (!name) throw new Error('Server name is required.');

package/src/input/panel-paste-flood-guard.ts

@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------
 // panel-paste-flood-guard.ts — ported from goodvibes-tui (commit 90eb3a26,
-// DEBT-5 item 5).
+// src/input/panel-paste-flood-guard.ts).
 //
 // A terminal WITHOUT bracketed paste delivers a pasted block as a burst of
 // discrete 1-char 'text' tokens (isPasteToken stays false for every one of

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

@@ -1,7 +1,7 @@
 import type { ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import type { ProviderAuthFreshness, ProviderAuthRoute } from '@/runtime/index.ts';
-import type { FeatureFlag, FlagState } from '@/runtime/index.ts';
+import type { FeatureSetting, FlagState } from '@/runtime/index.ts';
 
 export interface SettingsModalChange {
   readonly key: ConfigKey;
@@ -61,7 +61,9 @@ export type SettingsCategory =
   | 'policy'
   | 'fetch'
   | 'security'
-  | 'integrations';
+  | 'integrations'
+  | 'update'
+  | 'pricing';
 
 export type SettingsFocusPane = 'categories' | 'settings';
 
@@ -70,10 +72,10 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
   readonly categories: readonly SettingsCategory[];
 }> = [
   { label: 'Agent Experience', categories: ['display', 'ui', 'behavior', 'agents', 'notifications', 'permissions', 'policy', 'fetch', 'diagnostics'] },
-  { label: 'Models and Providers', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
+  { label: 'Models and Providers', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts', 'pricing'] },
   { label: 'Agent-local state', categories: ['storage', 'cache', 'telemetry', 'atRest', 'security', 'learning'] },
   { label: 'Channels and Tools', categories: ['surfaces', 'mcp', 'automation', 'checkin', 'integrations'] },
-  { label: 'Daemon Runtime', categories: ['daemon', 'service', 'controlPlane', 'httpListener', 'web', 'watchers', 'network', 'relay'] },
+  { label: 'Daemon Runtime', categories: ['daemon', 'service', 'controlPlane', 'httpListener', 'web', 'watchers', 'network', 'relay', 'update'] },
   { label: 'Advanced Runtime', categories: ['orchestration', 'planner', 'runtime', 'sandbox', 'batch', 'cloudflare', 'wrfc'] },
   { label: 'Advanced', categories: ['flags', 'release'] },
 ];
@@ -92,8 +94,12 @@ export interface SettingEntry {
 }
 
 export interface FlagEntry {
-  flag: FeatureFlag;
+  /** The feature as FEATURE_SETTINGS describes it: domain, enablement shape, settings keys, real description. */
+  feature: FeatureSetting;
+  /** Live gate state from the manager (kill-switch aware); config-derived when no manager is attached. */
   state: FlagState;
+  /** The enablement settings key's current config value, rendered on the row. */
+  enablementValue: string;
 }
 
 export interface McpEntry {