@pellux/goodvibes-agent 0.1.116 → 0.1.117

package/src/cli/profiles-command.ts

@@ -2,13 +2,16 @@ import {
   createAgentRuntimeProfile,
   createAgentRuntimeProfileFromDiscovered,
   createAgentRuntimeProfileTemplateFromDiscovered,
+  clearAgentRuntimeProfileSelection,
   deleteAgentRuntimeProfile,
   exportAgentRuntimeProfileTemplate,
   importAgentRuntimeProfileTemplate,
   isAgentRuntimeProfileTemplateId,
   listAgentRuntimeProfiles,
   listAgentRuntimeProfileTemplates,
+  readAgentRuntimeProfileSelection,
   resolveAgentRuntimeProfileHome,
+  setAgentRuntimeProfileSelection,
   type AgentRuntimeProfileTemplateId,
   type AgentRuntimeProfileCommandResult,
   type AgentRuntimeProfileInfo,
@@ -118,6 +121,20 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
       `  use: goodvibes-agent profiles create <name> --template ${result.data.template.id} --yes`,
     ].join('\n');
   }
+  if (result.kind === 'agent.profiles.default') {
+    const selected = result.data?.selectedProfile;
+    if (!selected) return 'No default Agent profile selected. Use: goodvibes-agent profiles use <name> --yes';
+    return [
+      `Default Agent profile: ${selected.id}${selected.exists ? '' : ' (missing)'}`,
+      `  home: ${selected.homeDirectory}`,
+      selected.selectedAt ? `  selectedAt: ${selected.selectedAt}` : '',
+      `  next launch: ${result.data?.nextCommand ?? 'goodvibes-agent'}`,
+      selected.exists ? '' : '  fix: create the profile again or clear it with goodvibes-agent profiles default clear --yes',
+    ].filter(Boolean).join('\n');
+  }
+  if (result.kind === 'agent.profiles.default.clear') {
+    return 'Default Agent profile cleared. Next launch uses the base Agent home unless --agent-profile is provided.';
+  }
   if (result.kind === 'agent.profiles.create_from_discovered' && result.data?.profile && result.data.template) {
     return [
       `Agent profile created from discovered behavior: ${result.data.profile.id}`,
@@ -296,6 +313,107 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
       };
     }
 
+    if (sub === 'default') {
+      const target = values[0];
+      if (target === 'clear' || target === 'none' || target === 'base') {
+        if (!hasYes(rawRest)) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: 'Refusing to clear the default Agent profile without --yes.',
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        clearAgentRuntimeProfileSelection(runtime.homeDirectory);
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.default.clear',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
+      if (target) {
+        if (!hasYes(rawRest)) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: `Refusing to set default Agent profile ${target} without --yes.`,
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        const selected = setAgentRuntimeProfileSelection(runtime.homeDirectory, target);
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.default',
+          data: {
+            selectedProfile: selected,
+            nextCommand: 'goodvibes-agent',
+          },
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
+      const selected = readAgentRuntimeProfileSelection(runtime.homeDirectory);
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.default',
+        data: selected ? { selectedProfile: selected, nextCommand: 'goodvibes-agent' } : undefined,
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
+    if (sub === 'use' || sub === 'select' || sub === 'switch') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles use <name> --yes',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      if (!hasYes(rawRest)) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: `Refusing to set default Agent profile ${name} without --yes.`,
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const selected = setAgentRuntimeProfileSelection(runtime.homeDirectory, name);
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.default',
+        data: {
+          selectedProfile: selected,
+          nextCommand: 'goodvibes-agent',
+        },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
     if (sub === 'show' || sub === 'path' || sub === 'home') {
       const name = values[0];
       if (!name) {
@@ -464,7 +582,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
     const result: AgentRuntimeProfileCommandResult = {
       ok: false,
       kind: 'agent.profiles.error',
-      error: 'Usage: goodvibes-agent profiles [list|templates|show <name>|create <name> [--template <id>] --yes|delete <name> --yes]',
+      error: 'Usage: goodvibes-agent profiles [list|templates|default [<name>|clear] --yes|use <name> --yes|show <name>|create <name> [--template <id>] --yes|delete <name> --yes]',
     };
     return {
       output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),

package/src/cli/routines-command.ts

@@ -1,6 +1,7 @@
 import { createShellPathService } from '@/runtime/index.ts';
 import { discoverRoutines, type DiscoveredRoutineRecord } from '../agent/routine-discovery.ts';
-import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import { AgentRoutineRegistry, evaluateAgentRoutineReadiness, type AgentRoutineRecord } from '../agent/routine-registry.ts';
+import { buildAgentSkillRequirements, formatAgentSkillRequirement } from '../agent/skill-registry.ts';
 import {
   buildRoutineSchedulePreview,
   promoteRoutineToDaemonSchedule,
@@ -34,10 +35,26 @@ interface RoutinesCommandFailure {
   readonly error: string;
 }
 
+interface ParsedRoutineOptions {
+  readonly positionals: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+const ROUTINE_CREATE_USAGE = 'Usage: goodvibes-agent routines create --name <name> --description <summary> --steps <steps> [--tags a,b] [--triggers a,b] [--requires-env A,B] [--requires-command gh,jq] [--enabled]';
+
 function jsonOrText(runtime: CliCommandRuntime, value: unknown, text: string): string {
   return runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text;
 }
 
+function commandFailure(runtime: CliCommandRuntime, kind: string, error: string, exitCode: number): CliCommandOutput {
+  const failure: RoutinesCommandFailure = { ok: false, kind, error };
+  return {
+    output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : error,
+    exitCode,
+  };
+}
+
 function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
   return AgentRoutineRegistry.fromShellPaths(createShellPathService({
     workingDirectory: runtime.workingDirectory,
@@ -64,6 +81,47 @@ function splitList(value: string | undefined): readonly string[] {
   return value.split(',').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function parseRoutineOptions(args: readonly string[]): ParsedRoutineOptions {
+  const flags = new Map<string, string>();
+  const positionals: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { positionals, flags, yes };
+}
+
+function optionValue(options: ParsedRoutineOptions, key: string): string | undefined {
+  const value = options.flags.get(key)?.trim();
+  return value ? value : undefined;
+}
+
+function hasFlag(options: ParsedRoutineOptions, key: string): boolean {
+  return options.flags.get(key) === 'true';
+}
+
+function requiredOption(options: ParsedRoutineOptions, key: string): string {
+  const value = optionValue(options, key);
+  if (!value) throw new Error(`${ROUTINE_CREATE_USAGE}\nMissing --${key}.`);
+  return value;
+}
+
 function parseImportFlags(args: readonly string[]): {
   readonly name: string;
   readonly enabled: boolean;
@@ -89,7 +147,9 @@ function parseImportFlags(args: readonly string[]): {
 function summarizeRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
   const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
-  return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
+  const readiness = evaluateAgentRoutineReadiness(routine);
+  const ready = readiness.ready ? 'ready' : `needs ${readiness.missing.map(formatAgentSkillRequirement).join(',')}`;
+  return `  ${routine.id}  ${enabled}  ${routine.reviewState}  ${ready}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
 }
 
 function summarizeDiscoveredRoutine(routine: DiscoveredRoutineRecord): string {
@@ -136,13 +196,21 @@ function discoveredRoutineFrontmatterList(routine: DiscoveredRoutineRecord, key:
   return splitList(value);
 }
 
-function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[]): string {
+function discoveredRoutineFrontmatterAnyList(routine: DiscoveredRoutineRecord, keys: readonly string[]): readonly string[] {
+  for (const key of keys) {
+    const values = discoveredRoutineFrontmatterList(routine, key);
+    if (values.length > 0) return values;
+  }
+  return [];
+}
+
+function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[], emptyMessage?: string): string {
   if (routines.length === 0) {
     return [
       title,
-      '  No local Agent routines yet.',
-      '  Create routines inside the Agent TUI with /routines create, or create an Agent profile from a starter template.',
-    ].join('\n');
+      `  ${emptyMessage ?? 'No local Agent routines yet.'}`,
+      emptyMessage ? '' : '  Open /agent routines in the TUI, or use goodvibes-agent routines create for scripted setup.',
+    ].filter(Boolean).join('\n');
   }
   return [
     `${title} (${routines.length})`,
@@ -152,10 +220,14 @@ function renderRoutineList(title: string, path: string, routines: readonly Agent
 }
 
 function renderRoutine(routine: AgentRoutineRecord): string {
+  const readiness = evaluateAgentRoutineReadiness(routine);
   return [
     `Routine ${routine.name}`,
     `  id: ${routine.id}`,
     `  enabled: ${routine.enabled ? 'yes' : 'no'}`,
+    `  readiness: ${readiness.ready ? 'ready' : 'needs setup'}`,
+    `  requirements: ${routine.requirements.map(formatAgentSkillRequirement).join(', ') || '(none)'}`,
+    readiness.missing.length > 0 ? `  missing: ${readiness.missing.map(formatAgentSkillRequirement).join(', ')}` : '',
     `  review: ${routine.reviewState}`,
     `  source: ${routine.source}`,
     `  provenance: ${routine.provenance}`,
@@ -235,15 +307,23 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
   const registry = routineRegistry(runtime);
   const snapshot = registry.snapshot();
   const normalized = sub.toLowerCase();
-  if (normalized === 'list' || normalized === 'enabled') {
-    const routines = normalized === 'enabled' ? snapshot.enabledRoutines : snapshot.routines;
+  if (normalized === 'list' || normalized === 'enabled' || normalized === 'attention' || normalized === 'needs-setup') {
+    const routines = normalized === 'enabled'
+      ? snapshot.enabledRoutines
+      : normalized === 'attention' || normalized === 'needs-setup'
+        ? snapshot.routines.filter((routine) => !evaluateAgentRoutineReadiness(routine).ready)
+        : snapshot.routines;
     const value: RoutinesCommandSuccess<{
       readonly path: string;
       readonly routines: readonly AgentRoutineRecord[];
       readonly enabledCount: number;
     }> = {
       ok: true,
-      kind: normalized === 'enabled' ? 'agent.routines.enabled' : 'agent.routines.list',
+      kind: normalized === 'enabled'
+        ? 'agent.routines.enabled'
+        : normalized === 'attention' || normalized === 'needs-setup'
+          ? 'agent.routines.attention'
+          : 'agent.routines.list',
       data: {
         path: snapshot.path,
         routines,
@@ -251,7 +331,16 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       },
     };
     return {
-      output: jsonOrText(runtime, value, renderRoutineList(normalized === 'enabled' ? 'Enabled Agent routines' : 'Agent routines', snapshot.path, routines)),
+      output: jsonOrText(runtime, value, renderRoutineList(
+        normalized === 'enabled'
+          ? 'Enabled Agent routines'
+          : normalized === 'attention' || normalized === 'needs-setup'
+            ? 'Agent routines needing setup'
+            : 'Agent routines',
+        snapshot.path,
+        routines,
+        normalized === 'attention' || normalized === 'needs-setup' ? 'No local Agent routines need setup.' : undefined,
+      )),
       exitCode: 0,
     };
   }
@@ -317,6 +406,10 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       steps: discovered.steps,
       tags: discoveredRoutineFrontmatterList(discovered, 'tags'),
       triggers: discoveredRoutineFrontmatterList(discovered, 'triggers'),
+      requirements: buildAgentSkillRequirements({
+        env: discoveredRoutineFrontmatterAnyList(discovered, ['requiresEnv', 'requires-env', 'requires_env']),
+        commands: discoveredRoutineFrontmatterAnyList(discovered, ['requiresCommands', 'requires-commands', 'requires_commands', 'commands']),
+      }),
       enabled: parsed.enabled,
       source: 'imported',
       provenance: `discovered:${discovered.origin}:${discovered.path}`,
@@ -331,6 +424,41 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       exitCode: 0,
     };
   }
+  if (normalized === 'create') {
+    const options = parseRoutineOptions(rest);
+    try {
+      const routine = registry.create({
+        name: requiredOption(options, 'name'),
+        description: requiredOption(options, 'description'),
+        steps: optionValue(options, 'steps') ?? options.positionals.join(' ').trim(),
+        tags: splitList(optionValue(options, 'tags')),
+        triggers: splitList(optionValue(options, 'triggers')),
+        requirements: buildAgentSkillRequirements({
+          env: splitList(optionValue(options, 'requires-env')),
+          commands: splitList(optionValue(options, 'requires-command') ?? optionValue(options, 'requires-commands')),
+        }),
+        enabled: hasFlag(options, 'enabled'),
+        source: 'user',
+        provenance: 'cli',
+      });
+      const value: RoutinesCommandSuccess<AgentRoutineRecord> = {
+        ok: true,
+        kind: 'agent.routines.create',
+        data: routine,
+      };
+      return {
+        output: jsonOrText(runtime, value, `Created Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`),
+        exitCode: 0,
+      };
+    } catch (error) {
+      return commandFailure(
+        runtime,
+        error instanceof Error && error.message.startsWith('Usage:') ? 'invalid_routine_command' : 'agent.routines.create.error',
+        error instanceof Error ? error.message : String(error),
+        error instanceof Error && error.message.startsWith('Usage:') ? 2 : 1,
+      );
+    }
+  }
   if (normalized === 'show') {
     const id = rest[0];
     if (!id) return { output: 'Usage: goodvibes-agent routines show <id>', exitCode: 2 };
@@ -396,7 +524,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|discover|import-discovered <name> --yes|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
+    output: `Usage: goodvibes-agent routines [list|enabled|attention|discover|import-discovered <name> --yes|create --name <name> --description <summary> --steps <steps>|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]`,
     exitCode: 2,
   };
 }

package/src/cli/service-posture.ts

@@ -32,7 +32,7 @@ export interface CliServiceLogPosture {
   readonly readError?: string;
 }
 
-export interface CliExternalDaemonLifecyclePosture {
+export interface CliExternalHostLifecyclePosture {
   readonly platform: 'manual';
   readonly path: string;
   readonly installed: false;
@@ -54,7 +54,7 @@ export interface CliServicePosture {
     readonly restartOnFailure: boolean;
     readonly daemonEnabled: boolean;
   };
-  readonly managed: CliExternalDaemonLifecyclePosture;
+  readonly managed: CliExternalHostLifecyclePosture;
   readonly endpoints: readonly CliServiceEndpointPosture[];
   readonly log: CliServiceLogPosture;
   readonly issues: readonly string[];
@@ -140,10 +140,10 @@ function resolveConfiguredLogPath(runtime: CliServiceRuntime): string | undefine
   return isAbsolute(trimmed) ? trimmed : join(runtime.homeDirectory, trimmed);
 }
 
-function createExternalDaemonLifecycle(logPath: string | undefined): CliExternalDaemonLifecyclePosture {
+function createExternalHostLifecycle(logPath: string | undefined): CliExternalHostLifecyclePosture {
   return {
     platform: 'manual',
-    path: 'connected GoodVibes services',
+    path: 'connected GoodVibes host',
     installed: false,
     autostart: false,
     running: false,
@@ -151,7 +151,7 @@ function createExternalDaemonLifecycle(logPath: string | undefined): CliExternal
     commandPreview: 'managed outside goodvibes-agent',
     suggestedCommands: [],
     lastAction: 'status',
-    pidPath: 'connected GoodVibes services',
+    pidPath: 'connected GoodVibes host',
     lastError: null,
   };
 }
@@ -184,7 +184,7 @@ export async function buildCliServicePosture(
   const issues: string[] = [];
 
   if (serverBackedEnabled && !config.enabled) {
-    issues.push('Connected-service settings are present, but Agent service ownership is disabled by design.');
+    issues.push('Connected-host settings are present, but Agent host ownership is disabled by design.');
   }
   for (const endpoint of endpoints) {
     if (endpoint.enabled && options.probe && endpoint.reachable === false) {
@@ -209,7 +209,7 @@ export async function buildCliServicePosture(
 
   return {
     config,
-    managed: createExternalDaemonLifecycle(configuredLogPath),
+    managed: createExternalHostLifecycle(configuredLogPath),
     endpoints,
     log,
     issues,
@@ -223,16 +223,16 @@ function yesNo(value: boolean): string {
 export function formatCliServicePosture(posture: CliServicePosture, json = false): string {
   if (json) return JSON.stringify(posture, null, 2);
   return [
-    'GoodVibes Agent runtime connection diagnostics',
-    '  ownership: managed outside goodvibes-agent',
-    '  Agent owns lifecycle: no',
+    'GoodVibes Agent connected-host diagnostics',
+    '  lifecycle owner: outside goodvibes-agent',
+    '  Agent starts connected host: no',
     `  external host config present: ${yesNo(posture.config.enabled)}`,
     '  external host lifecycle config: ignored by Agent',
     `  legacy host switch present: ${yesNo(posture.config.daemonEnabled)}`,
     `  log: ${posture.log.path ?? 'n/a'} (${posture.log.exists ? 'present' : 'missing'})`,
     ...(posture.log.readError ? [`  log read error: ${posture.log.readError}`] : []),
     '',
-    'Connected GoodVibes API checks:',
+    'Connected API checks:',
     ...posture.endpoints.map((endpoint) =>
       `  ${endpoint.label}: enabled=${yesNo(endpoint.enabled)} ${endpoint.binding.hostMode} ${endpoint.binding.host}:${endpoint.binding.port} posture=${endpoint.bindPosture.label}${endpoint.reachable === undefined ? '' : ` reachable=${yesNo(endpoint.reachable)}`}`,
     ),

package/src/cli/status.ts

@@ -124,9 +124,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-unreachable',
         area: 'runtime',
         severity: 'warning',
-        summary: 'Connected GoodVibes services are not reachable.',
+        summary: 'Connected GoodVibes host is not reachable.',
         cause: `Agent could not reach ${options.externalRuntime.baseUrl}${options.externalRuntime.error ? `: ${options.externalRuntime.error}` : '.'}`,
-        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until connected GoodVibes services are available.',
+        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until the connected GoodVibes host is available.',
         action: 'Start or repair the owning GoodVibes host, then rerun goodvibes-agent status.',
       });
     } else if (!options.externalRuntime.compatible) {
@@ -134,8 +134,8 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-version-mismatch',
         area: 'runtime',
         severity: 'warning',
-        summary: 'Connected GoodVibes service SDK version does not match Agent.',
-        cause: `Connected service reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
+        summary: 'Connected GoodVibes host SDK version does not match Agent.',
+        cause: `Connected host reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
         impact: 'Agent-only routes, especially isolated Agent Knowledge, may be missing or incompatible.',
         action: 'Update the owning GoodVibes host so /status matches this Agent package SDK pin.',
       });
@@ -146,9 +146,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-token-missing',
         area: 'auth',
         severity: 'warning',
-        summary: 'Connected-service operator token is missing.',
+        summary: 'Connected-host operator token is missing.',
         cause: `No operator token was found at ${options.externalRuntime.operatorToken.path}.`,
-        impact: 'Agent can inspect only unauthenticated routes and cannot use protected connected-service APIs.',
+        impact: 'Agent can inspect only unauthenticated routes and cannot use protected connected-host APIs.',
         action: 'Pair or provision access through the owning GoodVibes host, then rerun goodvibes-agent auth.',
       });
     }
@@ -161,7 +161,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         summary: 'Isolated Agent Knowledge route is not ready.',
         cause: `${options.externalRuntime.agentKnowledge.route} returned ${options.externalRuntime.agentKnowledge.kind}${options.externalRuntime.agentKnowledge.statusCode === null ? '' : ` (${options.externalRuntime.agentKnowledge.statusCode})`}.`,
         impact: 'Agent Knowledge ask/search will not use any fallback wiki or non-Agent knowledge segment; it will fail closed until the Agent route is available.',
-        action: 'Update the connected GoodVibes services to the Agent-compatible SDK and verify goodvibes-agent compat.',
+        action: 'Update the connected GoodVibes host to the Agent-compatible SDK and verify goodvibes-agent compat.',
       });
     }
   }
@@ -171,10 +171,10 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'runtime-ownership-external',
       area: 'runtime',
       severity: 'warning',
-      summary: 'Connected-service settings are present while Agent service ownership is disabled by design.',
+      summary: 'Connected-host settings are present while Agent host ownership is disabled by design.',
       cause: 'One or more connected API, inbound events, or browser companion settings are enabled while service.enabled is false.',
       impact: 'The owning GoodVibes host must provide availability for those endpoints; Agent will not start or enable them.',
-      action: 'Manage connected-service availability from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
+      action: 'Manage connected-host availability from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
     });
   }
 
@@ -186,9 +186,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         area: 'runtime',
         severity: 'warning',
         summary: issue,
-        cause: 'The connected-service inspection found a mismatch between configured endpoint state and observed host state.',
+        cause: 'The connected-host inspection found a mismatch between configured endpoint state and observed host state.',
         impact: 'Connected API, listener, or web availability may not match the configuration.',
-        action: 'Use Agent status and doctor diagnostics here, then manage connected services outside Agent.',
+        action: 'Use Agent status and doctor diagnostics here, then manage the connected host outside Agent.',
       });
     }
   }
@@ -198,9 +198,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'onboarding-incomplete',
       area: 'onboarding',
       severity: 'warning',
-      summary: 'Agent setup has not been shown for this user.',
-      cause: 'No global user setup check marker was found.',
-      impact: 'Important connected-service, network, provider, auth, or permission choices may still be implicit defaults.',
+      summary: 'Agent setup has not been applied for this user.',
+      cause: 'No global user setup completion marker was found.',
+      impact: 'Important connected-host, network, provider, auth, or permission choices may still be implicit defaults.',
       action: 'Run /setup in GoodVibes Agent or goodvibes-agent setup status to review setup state.',
     });
   }
@@ -210,10 +210,10 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'network-endpoint-without-runtime-auth-signal',
       area: 'auth',
       severity: 'risk',
-      summary: 'Network-facing connected-service endpoints are enabled without a visible auth signal.',
-      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see connected-service auth state from its local compatibility files.`,
+      summary: 'Network-facing connected-host endpoints are enabled without a visible auth signal.',
+      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see connected-host auth state from its local compatibility files.`,
       impact: 'Remote access paths may be unusable or unsafe unless the owning host configured auth.',
-      action: 'Review connected-service auth outside Agent; Agent will not create local service users.',
+      action: 'Review connected-host auth outside Agent; Agent will not create local service users.',
     });
   }
 
@@ -364,15 +364,11 @@ export function renderCliStatus(options: CliStatusOptions): string {
       '  live check: unavailable',
     ]),
     '',
-    'Connected GoodVibes Services:',
+    'Connected Host:',
     '  Agent role: client/operator TUI only',
-    '  service ownership: outside Agent',
-    '  Agent starts services: no',
+    '  lifecycle owner: outside Agent',
+    '  Agent starts connected host: no',
     ...(options.service ? [
-      `  platform: ${options.service.managed.platform}`,
-      `  installed: ${yesNo(options.service.managed.installed)}`,
-      `  running: ${yesNo(options.service.managed.running)}`,
-      `  definition: ${options.service.managed.path}`,
       `  log: ${options.service.log.path ?? 'n/a'} (${options.service.log.exists ? 'present' : 'missing'})`,
     ] : []),
     'Onboarding:',
@@ -384,7 +380,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
   if (options.doctor) {
     lines.push(
       '',
-      'Connected-Service Config Signals:',
+      'Connected Host Config Signals:',
       `  host config present: ${yesNo(serviceEnabled)}`,
       '  lifecycle config: external to Agent',
       '',