@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/cli/profiles-command.ts

@@ -1,12 +1,17 @@
 import {
   createAgentRuntimeProfile,
+  createAgentRuntimeProfileFromDiscovered,
+  createAgentRuntimeProfileTemplateFromDiscovered,
+  clearAgentRuntimeProfileSelection,
   deleteAgentRuntimeProfile,
   exportAgentRuntimeProfileTemplate,
   importAgentRuntimeProfileTemplate,
   isAgentRuntimeProfileTemplateId,
   listAgentRuntimeProfiles,
   listAgentRuntimeProfileTemplates,
+  readAgentRuntimeProfileSelection,
   resolveAgentRuntimeProfileHome,
+  setAgentRuntimeProfileSelection,
   type AgentRuntimeProfileTemplateId,
   type AgentRuntimeProfileCommandResult,
   type AgentRuntimeProfileInfo,
@@ -16,6 +21,7 @@ import type { CliCommandOutput, GoodVibesCliParseResult } from './types.ts';
 interface ProfilesCommandRuntime {
   readonly cli: GoodVibesCliParseResult;
   readonly homeDirectory: string;
+  readonly workingDirectory: string;
 }
 
 function hasYes(args: readonly string[]): boolean {
@@ -53,6 +59,12 @@ function parseTemplate(args: readonly string[]): AgentRuntimeProfileTemplateId |
   throw new Error(`Unknown Agent starter profile template: ${raw}. Use profiles templates to list starters.`);
 }
 
+function parseCsvFlag(args: readonly string[], names: readonly string[]): readonly string[] | undefined {
+  const raw = flagValue(args, names);
+  if (!raw) return undefined;
+  return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function profileLine(profile: AgentRuntimeProfileInfo): string {
   const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
   const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
@@ -99,6 +111,41 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
       `  use: goodvibes-agent profiles create <name> --template ${result.data.template.id} --yes`,
     ].join('\n');
   }
+  if (result.kind === 'agent.profiles.template.from_discovered' && result.data?.template) {
+    return [
+      `Agent starter template created from discovered behavior: ${result.data.template.id}`,
+      `  name: ${result.data.template.name}`,
+      `  persona: ${result.data.template.personaName}`,
+      `  skills: ${result.data.template.skillNames.join(', ')}`,
+      `  routines: ${result.data.template.routineNames.join(', ')}`,
+      `  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}`,
+      `  home: ${result.data.profile.homeDirectory}`,
+      `  starter: ${result.data.template.id}`,
+      `  persona: ${result.data.template.personaName}`,
+      `  skills: ${result.data.template.skillNames.join(', ')}`,
+      `  routines: ${result.data.template.routineNames.join(', ')}`,
+      `  launch: ${result.data.nextCommand ?? `goodvibes-agent --agent-profile ${result.data.profile.id}`}`,
+    ].join('\n');
+  }
   const profile = result.data?.profile;
   if (result.kind === 'agent.profiles.create' && profile) {
     const template = result.data?.appliedTemplate;
@@ -142,6 +189,51 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
 
     if (sub === 'templates' || sub === 'starters') {
       const [templateAction, templateId, templatePath] = values;
+      if (templateAction === 'from-discovered' || templateAction === 'import-discovered') {
+        if (!templateId) {
+          const result: AgentRuntimeProfileCommandResult = {
+            ok: false,
+            kind: 'agent.profiles.error',
+            error: 'Usage: goodvibes-agent profiles templates from-discovered <id> [--name <name>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --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 create Agent starter template ${templateId} from discovered behavior without --yes.`,
+          };
+          return {
+            output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+            exitCode: 2,
+          };
+        }
+        const template = await createAgentRuntimeProfileTemplateFromDiscovered({
+          homeDirectory: runtime.homeDirectory,
+          workingDirectory: runtime.workingDirectory,
+        }, {
+          id: templateId,
+          name: flagValue(rawRest, ['--name']) ?? undefined,
+          description: flagValue(rawRest, ['--description']) ?? undefined,
+          persona: flagValue(rawRest, ['--persona']) ?? undefined,
+          skills: parseCsvFlag(rawRest, ['--skills']),
+          routines: parseCsvFlag(rawRest, ['--routines']),
+          replace: hasYes(rawRest) && rawRest.includes('--replace'),
+        });
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: true,
+          kind: 'agent.profiles.template.from_discovered',
+          data: { template },
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 0,
+        };
+      }
       if (templateAction === 'export') {
         if (!templateId || !templatePath) {
           const result: AgentRuntimeProfileCommandResult = {
@@ -221,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) {
@@ -290,6 +483,59 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
       };
     }
 
+    if (sub === 'create-from-discovered' || sub === 'create-discovered') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles create-from-discovered <name> [--template-id <id>] [--profile-name <display>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --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 create Agent profile ${name} from discovered behavior without --yes.`,
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const created = await createAgentRuntimeProfileFromDiscovered({
+        homeDirectory: runtime.homeDirectory,
+        workingDirectory: runtime.workingDirectory,
+      }, {
+        profileName: name,
+        templateId: flagValue(rawRest, ['--template-id', '--starter-id']) ?? undefined,
+        name: flagValue(rawRest, ['--profile-name', '--name']) ?? undefined,
+        description: flagValue(rawRest, ['--description']) ?? undefined,
+        persona: flagValue(rawRest, ['--persona']) ?? undefined,
+        skills: parseCsvFlag(rawRest, ['--skills']),
+        routines: parseCsvFlag(rawRest, ['--routines']),
+        replace: rawRest.includes('--replace'),
+      });
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.create_from_discovered',
+        data: {
+          profile: created.profile,
+          appliedTemplate: created.profile.starterTemplateApplication,
+          template: created.template,
+          nextCommand: `goodvibes-agent --agent-profile ${created.profile.id}`,
+        },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
     if (sub === 'delete' || sub === 'remove') {
       const name = values[0];
       if (!name) {
@@ -336,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)}`}`,
     ),