@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/cli/local-library-command.ts

@@ -4,6 +4,10 @@ import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-
 import { discoverSkills, type SkillRecord } from '../agent/skill-discovery.ts';
 import {
   AgentSkillRegistry,
+  buildAgentSkillRequirements,
+  evaluateAgentSkillBundleReadiness,
+  evaluateAgentSkillReadiness,
+  formatAgentSkillRequirement,
   type AgentSkillBundleRecord,
   type AgentSkillRecord,
 } from '../agent/skill-registry.ts';
@@ -170,7 +174,7 @@ function renderDiscoveredPersonaList(personas: readonly DiscoveredPersonaRecord[
     return [
       'Discovered Agent persona files',
       '  No persona markdown files found in Agent persona folders.',
-      '  Search roots: .goodvibes/personas, .goodvibes/agent/personas, .goodvibes/agents, ~/.goodvibes/personas, ~/.goodvibes/agent/personas, ~/.goodvibes/agents',
+      '  Search roots: .goodvibes/personas, .goodvibes/agent/personas, ~/.goodvibes/personas, ~/.goodvibes/agent/personas',
     ].join('\n');
   }
   return [
@@ -204,21 +208,29 @@ function discoveredPersonaFrontmatterList(persona: DiscoveredPersonaRecord, key:
 function summarizeSkill(skill: AgentSkillRecord): string {
   const enabled = skill.enabled ? 'enabled' : 'disabled';
   const tags = skill.tags.length > 0 ? ` tags=${skill.tags.join(',')}` : '';
-  return `  ${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}${tags}`;
+  const readiness = evaluateAgentSkillReadiness(skill);
+  const ready = readiness.ready ? 'ready' : `needs ${readiness.missing.map(formatAgentSkillRequirement).join(',')}`;
+  return `  ${skill.id}  ${enabled}  ${skill.reviewState}  ${ready}  ${skill.name} - ${skill.description}${tags}`;
 }
 
-function summarizeBundle(bundle: AgentSkillBundleRecord): string {
+function summarizeBundle(bundle: AgentSkillBundleRecord, skills: readonly AgentSkillRecord[]): string {
   const enabled = bundle.enabled ? 'enabled' : 'disabled';
-  return `  ${bundle.id}  ${enabled}  ${bundle.reviewState}  ${bundle.name} - ${bundle.description} skills=${bundle.skillIds.join(',')}`;
+  const readiness = evaluateAgentSkillBundleReadiness(bundle, skills);
+  const missing = [
+    ...readiness.missingRequirements.map(formatAgentSkillRequirement),
+    ...readiness.missingSkillIds.map((skillId) => `skill:${skillId}`),
+  ];
+  const ready = readiness.ready ? 'ready' : `needs ${missing.join(',')}`;
+  return `  ${bundle.id}  ${enabled}  ${bundle.reviewState}  ${ready}  ${bundle.name} - ${bundle.description} skills=${bundle.skillIds.join(',')}`;
 }
 
-function renderSkillList(title: string, path: string, skills: readonly AgentSkillRecord[]): string {
+function renderSkillList(title: string, path: string, skills: readonly AgentSkillRecord[], emptyMessage?: string): string {
   if (skills.length === 0) {
     return [
       title,
-      '  No local Agent skills yet.',
-      '  Create one with: goodvibes-agent skills create --name <name> --description <summary> --procedure <steps>',
-    ].join('\n');
+      `  ${emptyMessage ?? 'No local Agent skills yet.'}`,
+      emptyMessage ? '' : '  Create one with: goodvibes-agent skills create --name <name> --description <summary> --procedure <steps>',
+    ].filter(Boolean).join('\n');
   }
   return [
     `${title} (${skills.length})`,
@@ -273,26 +285,38 @@ function discoveredFrontmatterList(skill: SkillRecord, key: string): readonly st
   return value.split(',').map((entry) => entry.trim()).filter(Boolean);
 }
 
-function renderBundleList(title: string, path: string, bundles: readonly AgentSkillBundleRecord[]): string {
+function discoveredFrontmatterAnyList(skill: SkillRecord, keys: readonly string[]): readonly string[] {
+  for (const key of keys) {
+    const values = discoveredFrontmatterList(skill, key);
+    if (values.length > 0) return values;
+  }
+  return [];
+}
+
+function renderBundleList(title: string, path: string, bundles: readonly AgentSkillBundleRecord[], skills: readonly AgentSkillRecord[], emptyMessage?: string): string {
   if (bundles.length === 0) {
     return [
       title,
-      '  No local Agent skill bundles yet.',
-      '  Create one with: goodvibes-agent skills bundle create --name <name> --description <summary> --skills <id,id>',
-    ].join('\n');
+      `  ${emptyMessage ?? 'No local Agent skill bundles yet.'}`,
+      emptyMessage ? '' : '  Create one with: goodvibes-agent skills bundle create --name <name> --description <summary> --skills <id,id>',
+    ].filter(Boolean).join('\n');
   }
   return [
     `${title} (${bundles.length})`,
     `  store: ${path}`,
-    ...bundles.map(summarizeBundle),
+    ...bundles.map((bundle) => summarizeBundle(bundle, skills)),
   ].join('\n');
 }
 
 function renderSkill(skill: AgentSkillRecord): string {
+  const readiness = evaluateAgentSkillReadiness(skill);
   return [
     `Skill ${skill.name}`,
     `  id: ${skill.id}`,
     `  enabled: ${skill.enabled ? 'yes' : 'no'}`,
+    `  readiness: ${readiness.ready ? 'ready' : 'needs setup'}`,
+    `  requirements: ${skill.requirements.map(formatAgentSkillRequirement).join(', ') || '(none)'}`,
+    readiness.missing.length > 0 ? `  missing: ${readiness.missing.map(formatAgentSkillRequirement).join(', ')}` : '',
     `  review: ${skill.reviewState}`,
     `  source: ${skill.source}`,
     `  provenance: ${skill.provenance}`,
@@ -308,11 +332,18 @@ function renderSkill(skill: AgentSkillRecord): string {
   ].filter((line): line is string => Boolean(line)).join('\n');
 }
 
-function renderBundle(bundle: AgentSkillBundleRecord): string {
+function renderBundle(bundle: AgentSkillBundleRecord, skills: readonly AgentSkillRecord[]): string {
+  const readiness = evaluateAgentSkillBundleReadiness(bundle, skills);
+  const missing = [
+    ...readiness.missingRequirements.map(formatAgentSkillRequirement),
+    ...readiness.missingSkillIds.map((skillId) => `skill:${skillId}`),
+  ];
   return [
     `Skill bundle ${bundle.name}`,
     `  id: ${bundle.id}`,
     `  enabled: ${bundle.enabled ? 'yes' : 'no'}`,
+    `  readiness: ${readiness.ready ? 'ready' : 'needs setup'}`,
+    missing.length > 0 ? `  missing: ${missing.join(', ')}` : '',
     `  review: ${bundle.reviewState}`,
     `  source: ${bundle.source}`,
     `  provenance: ${bundle.provenance}`,
@@ -330,11 +361,11 @@ function usagePersonas(): string {
 }
 
 function usageSkills(): string {
-  return 'Usage: goodvibes-agent skills [list|enabled|active|discover|import-discovered <name> --yes|search <query>|show <id>|create|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes|bundle ...]';
+  return 'Usage: goodvibes-agent skills [list|enabled|active|attention|discover|import-discovered <name> --yes|search <query>|show <id>|create [--requires-env A,B] [--requires-command gh,jq]|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes|bundle ...]';
 }
 
 function usageBundles(): string {
-  return 'Usage: goodvibes-agent skills bundle [list|enabled|search <query>|show <id>|create|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes]';
+  return 'Usage: goodvibes-agent skills bundle [list|enabled|attention|search <query>|show <id>|create|update <id>|enable <id>|disable <id>|review <id>|stale <id> <reason>|delete <id> --yes]';
 }
 
 function errorOutput(runtime: CliCommandRuntime, error: unknown, kind: string): CliCommandOutput {
@@ -473,6 +504,7 @@ function skillPayloadFromOptions(options: ParsedOptions): {
   readonly procedure: string;
   readonly tags: readonly string[] | undefined;
   readonly triggers: readonly string[] | undefined;
+  readonly requirements: ReturnType<typeof buildAgentSkillRequirements>;
   readonly enabled: boolean | undefined;
   readonly provenance: string;
 } {
@@ -483,6 +515,10 @@ function skillPayloadFromOptions(options: ParsedOptions): {
     procedure: requiredOption(options, 'procedure', usage),
     tags: csvOption(options, 'tags'),
     triggers: csvOption(options, 'triggers'),
+    requirements: buildAgentSkillRequirements({
+      env: csvOption(options, 'requires-env'),
+      commands: csvOption(options, 'requires-command') ?? csvOption(options, 'requires-commands'),
+    }),
     enabled: hasFlag(options, 'enabled') ? true : undefined,
     provenance: optionValue(options, 'provenance') ?? 'cli',
   };
@@ -495,22 +531,26 @@ async function handleSkillBundleCommand(runtime: CliCommandRuntime, args: readon
     const registry = skillRegistry(runtime);
     const snapshot = registry.snapshot();
     if (normalized === 'list' || normalized === 'ls') {
-      return success(runtime, 'agent.skills.bundles.list', { path: snapshot.path, bundles: snapshot.bundles }, renderBundleList('Agent skill bundles', snapshot.path, snapshot.bundles));
+      return success(runtime, 'agent.skills.bundles.list', { path: snapshot.path, bundles: snapshot.bundles }, renderBundleList('Agent skill bundles', snapshot.path, snapshot.bundles, snapshot.skills));
     }
     if (normalized === 'enabled') {
-      return success(runtime, 'agent.skills.bundles.enabled', { path: snapshot.path, bundles: snapshot.enabledBundles }, renderBundleList('Enabled Agent skill bundles', snapshot.path, snapshot.enabledBundles));
+      return success(runtime, 'agent.skills.bundles.enabled', { path: snapshot.path, bundles: snapshot.enabledBundles }, renderBundleList('Enabled Agent skill bundles', snapshot.path, snapshot.enabledBundles, snapshot.skills));
+    }
+    if (normalized === 'attention' || normalized === 'needs-setup') {
+      const bundles = snapshot.bundles.filter((bundle) => !evaluateAgentSkillBundleReadiness(bundle, snapshot.skills).ready);
+      return success(runtime, 'agent.skills.bundles.attention', { path: snapshot.path, bundles }, renderBundleList('Agent skill bundles needing setup', snapshot.path, bundles, snapshot.skills, 'No local Agent skill bundles need setup.'));
     }
     if (normalized === 'search' || normalized === 'find') {
       const query = rest.join(' ').trim();
       const results = registry.searchBundles(query);
-      return success(runtime, 'agent.skills.bundles.search', { query, results }, renderBundleList(`Agent skill bundles matching "${query}"`, snapshot.path, results));
+      return success(runtime, 'agent.skills.bundles.search', { query, results }, renderBundleList(`Agent skill bundles matching "${query}"`, snapshot.path, results, snapshot.skills));
     }
     if (normalized === 'show' || normalized === 'get') {
       const id = rest[0];
       if (!id) return failure(runtime, 'invalid_skill_bundle_command', 'Usage: goodvibes-agent skills bundle show <id>', 2);
       const bundle = registry.getBundle(id);
       if (!bundle) return failure(runtime, 'skill_bundle_not_found', `Unknown Agent skill bundle: ${id}`, 1);
-      return success(runtime, 'agent.skills.bundles.show', bundle, renderBundle(bundle));
+      return success(runtime, 'agent.skills.bundles.show', bundle, renderBundle(bundle, snapshot.skills));
     }
     if (normalized === 'create') {
       const options = parseOptions(rest);
@@ -584,9 +624,13 @@ export async function handleSkillsCommand(runtime: CliCommandRuntime): Promise<C
     if (normalized === 'active') {
       return success(runtime, 'agent.skills.active', { path: snapshot.path, skills: snapshot.activeSkills, bundles: snapshot.enabledBundles }, [
         renderSkillList('Active Agent skills', snapshot.path, snapshot.activeSkills),
-        snapshot.enabledBundles.length > 0 ? renderBundleList('Enabled Agent skill bundles', snapshot.path, snapshot.enabledBundles) : '',
+        snapshot.enabledBundles.length > 0 ? renderBundleList('Enabled Agent skill bundles', snapshot.path, snapshot.enabledBundles, snapshot.skills) : '',
       ].filter(Boolean).join('\n\n'));
     }
+    if (normalized === 'attention' || normalized === 'needs-setup') {
+      const skills = snapshot.skills.filter((skill) => !evaluateAgentSkillReadiness(skill).ready);
+      return success(runtime, 'agent.skills.attention', { path: snapshot.path, skills }, renderSkillList('Agent skills needing setup', snapshot.path, skills, 'No local Agent skills need setup.'));
+    }
     if (normalized === 'discover') {
       const discovered = await discoverSkills(shellPaths(runtime));
       return success(runtime, 'agent.skills.discover', { skills: discovered }, renderDiscoveredSkillList(discovered));
@@ -616,6 +660,10 @@ export async function handleSkillsCommand(runtime: CliCommandRuntime): Promise<C
         procedure: discovered.body,
         tags: discoveredFrontmatterList(discovered, 'tags'),
         triggers: discoveredFrontmatterList(discovered, 'triggers'),
+        requirements: buildAgentSkillRequirements({
+          env: discoveredFrontmatterAnyList(discovered, ['requiresEnv', 'requires-env', 'requires_env']),
+          commands: discoveredFrontmatterAnyList(discovered, ['requiresCommands', 'requires-commands', 'requires_commands', 'commands']),
+        }),
         enabled: hasFlag(options, 'enabled'),
         source: 'imported',
         provenance: `discovered:${discovered.origin}:${discovered.path}`,
@@ -648,6 +696,12 @@ export async function handleSkillsCommand(runtime: CliCommandRuntime): Promise<C
         procedure: optionValue(options, 'procedure'),
         tags: csvOption(options, 'tags'),
         triggers: csvOption(options, 'triggers'),
+        requirements: options.values.has('requires-env') || options.values.has('requires-command') || options.values.has('requires-commands')
+          ? buildAgentSkillRequirements({
+            env: csvOption(options, 'requires-env'),
+            commands: csvOption(options, 'requires-command') ?? csvOption(options, 'requires-commands'),
+          })
+          : undefined,
         provenance: optionValue(options, 'provenance'),
       });
       return success(runtime, 'agent.skills.update', skill, `Agent skill updated: ${skill.id}`);

package/src/cli/management-commands.ts

@@ -1,16 +1,17 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname } from 'node:path';
 import { SecretsManager } from '../config/secrets.ts';
 import { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, resolveSecretRef } from '@pellux/goodvibes-sdk/platform/config';
 import { getSubscriptionProviderConfig, listAvailableSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
 import { inspectProviderAuth } from '@/runtime/index.ts';
-import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
+import { buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import type { CliCommandRuntime } from './management.ts';
 import { extractAuthorizationCode, formatJsonOrText, hasCommandFlag, openBrowser, urlHostForBindHost, withRuntimeServices, yesNo } from './management.ts';
 import { GOODVIBES_AGENT_PAIRING_SURFACE } from '../config/surface.ts';
+import { connectedHostTokenRequiredMessage, readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 
 export async function renderSubscriptions(runtime: CliCommandRuntime): Promise<string> {
   return await withRuntimeServices(runtime, async (services) => {
@@ -279,7 +280,7 @@ export async function handleTasks(runtime: CliCommandRuntime): Promise<string> {
   const [sub = 'list', ...rest] = runtime.cli.commandArgs;
   if (sub === 'submit') {
     return [
-      'GoodVibes Agent blocks CLI task submission from the service-owned task workflow.',
+      'GoodVibes Agent blocks CLI task submission from the host-owned task workflow.',
       '  policy: do normal assistant work in the main Agent conversation or use `goodvibes-agent run <prompt>` for an explicit one-shot run.',
       '  build/fix/review: use `goodvibes-agent delegate <task>` for explicit GoodVibes TUI handoff.',
       '  result: no local task was started.',
@@ -289,7 +290,7 @@ export async function handleTasks(runtime: CliCommandRuntime): Promise<string> {
     const tasks = [...services.runtimeStore.getState().tasks.tasks.values()];
     if (sub === 'list') {
       return tasks.length === 0
-        ? 'GoodVibes tasks\n  No connected-service tasks are currently recorded.'
+        ? 'GoodVibes tasks\n  No connected-host tasks are currently recorded.'
         : ['GoodVibes tasks', ...tasks.map((task) => `  ${task.id} ${task.status} ${task.kind} ${task.title}`)].join('\n');
     }
     if (sub === 'show') {
@@ -302,8 +303,8 @@ export async function handleTasks(runtime: CliCommandRuntime): Promise<string> {
 }
 
 export async function renderPairing(runtime: CliCommandRuntime): Promise<string> {
-  const daemonHomeDir = join(runtime.homeDirectory, '.goodvibes', 'daemon');
-  const tokenRecord = getOrCreateCompanionToken(GOODVIBES_AGENT_PAIRING_SURFACE, { daemonHomeDir });
+  const tokenRecord = readConnectedHostOperatorToken(runtime.homeDirectory);
+  if (!tokenRecord.token) return connectedHostTokenRequiredMessage(tokenRecord.path);
   const binding = resolveRuntimeEndpointBinding(runtime.configManager, 'controlPlane');
   const daemonUrl = `http://${urlHostForBindHost(binding.host)}:${binding.port}`;
   const info = buildCompanionConnectionInfo({

package/src/cli/management.ts

@@ -19,14 +19,9 @@ import { BUILTIN_SECRET_PROVIDER_SOURCES, describeSecretRef, isSecretRefInput, r
 import { getSubscriptionProviderConfig, listAvailableSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
 import { inspectProviderAuth } from '@/runtime/index.ts';
-import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
-import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
 import type { GoodVibesCliParseResult } from './types.ts';
 import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
-import { resolveRuntimeEndpointBinding } from './endpoints.ts';
-import { applyRuntimeEndpointFlagOverrides } from './config-overrides.ts';
-import type { RuntimeEndpointId } from './endpoints.ts';
 import { handleBundleCommand } from './bundle-command.ts';
 import { handleSecrets, handleSessions, handleTasks, renderPairing, renderSubscriptions } from './management-commands.ts';
 import { handleAgentKnowledgeCommand, handleAgentKnowledgeShortcutCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
@@ -132,46 +127,6 @@ export function urlHostForBindHost(host: string): string {
   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;
-}
-
 export function openBrowser(url: string): string {
   const platform = process.platform;
   const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
@@ -544,8 +499,8 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
   ]);
   if (blocked.has(sub)) {
     return [
-      'Unsupported: connected-service auth user/session administration is outside GoodVibes Agent.',
-      'GoodVibes Agent does not create, delete, rotate, revoke, or clear connected-service users, sessions, or bootstrap credentials.',
+      'Unsupported: connected-host auth user/session administration is outside GoodVibes Agent.',
+      'GoodVibes Agent does not create, delete, rotate, revoke, or clear connected-host users, sessions, or bootstrap credentials.',
       'Use the owning GoodVibes host for auth administration.',
     ].join('\n');
   }
@@ -566,21 +521,21 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
   if (sub === 'users' || sub === 'sessions') {
     return formatJsonOrText(runtime.cli)(value, [
       `GoodVibes Agent auth ${sub}`,
-      '  owner: connected GoodVibes services',
+      '  owner: connected GoodVibes host',
       `  operator token: ${paths.operatorTokenPresent ? 'present' : 'missing'}`,
       `  operator token path: ${paths.operatorTokenPath}`,
       `  ${sub}: managed outside Agent`,
-      '  Agent does not enumerate or mutate connected-service users/sessions from the local CLI.',
+      '  Agent does not enumerate or mutate connected-host users/sessions from the local CLI.',
     ].join('\n'));
   }
   return formatJsonOrText(runtime.cli)(value, [
     'GoodVibes Agent auth',
-    '  owner: connected GoodVibes services',
+    '  owner: connected GoodVibes host',
     `  permission mode: ${String(value.permissionMode)}`,
     `  operator token: ${paths.operatorTokenPresent ? 'present' : 'missing'} (${paths.operatorTokenPath})`,
     `  compatibility user store: ${paths.userStorePresent ? 'present' : 'missing'} (${paths.userStorePath})`,
     `  compatibility bootstrap credential: ${paths.bootstrapCredentialPresent ? 'present' : 'missing'} (${paths.bootstrapCredentialPath})`,
-    '  connected-service user/session administration: outside Agent',
+    '  connected-host user/session administration: outside Agent',
     '  next: goodvibes-agent providers',
     '  next: goodvibes-agent subscription providers',
   ].join('\n'));

package/src/cli/parser.ts

@@ -58,7 +58,28 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   version: 'version',
 };
 
-const RETIRED_LAUNCHER_ALIASES = new Set(['app', 'launch', 'start', 'tui']);
+const BLOCKED_PRODUCT_COMMANDS = new Set([
+  'app',
+  'bridge',
+  'control-plane',
+  'controlplane',
+  'cp',
+  'daemon',
+  'http-listener',
+  'launch',
+  'listener',
+  'remote',
+  'serve',
+  'server',
+  'service',
+  'services',
+  'start',
+  'surface',
+  'surfaces',
+  'tui',
+  'web',
+  'webhook',
+]);
 
 function createDefaultFlags(): GoodVibesCliFlags {
   return {
@@ -200,7 +221,7 @@ export function parseGoodVibesCli(
     if (!token.startsWith('-') || token === '-') {
       if (!sawCommand) {
         const commandToken = token.toLowerCase();
-        if (RETIRED_LAUNCHER_ALIASES.has(commandToken)) {
+        if (BLOCKED_PRODUCT_COMMANDS.has(commandToken)) {
           command = 'unknown';
           rawCommand = token;
           sawCommand = true;