@pellux/goodvibes-agent 0.1.116 → 1.0.0

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

@@ -4,11 +4,29 @@ import type { CommandRegistry } from '../command-registry.ts';
 import type { CommandContext } from '../command-registry.ts';
 import type { AgentWorkspaceChannelStatus } from '../agent-workspace-channels.ts';
 import { buildAgentWorkspaceChannels } from '../agent-workspace-channels.ts';
+import {
+  buildAgentChannelDeliveryPreview,
+  deliverAgentChannelMessage,
+  formatAgentChannelDeliveryPreview,
+  formatAgentChannelDeliveryResult,
+} from '../../agent/channel-delivery.ts';
+import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 
 type ChannelFilter = 'all' | 'ready' | 'attention';
 type JsonRecord = Record<string, unknown>;
 
-interface ChannelDaemonConnection {
+interface ChannelSendArgs {
+  readonly message: string;
+  readonly title?: string;
+  readonly channel?: string;
+  readonly route?: string;
+  readonly webhook?: string;
+  readonly link?: string;
+  readonly yes: boolean;
+  readonly errors: readonly string[];
+}
+
+interface ChannelConnectedHostConnection {
   readonly baseUrl: string;
   readonly token: string | null;
   readonly tokenPath: string;
@@ -23,12 +41,20 @@ interface ChannelRouteSuccess {
 interface ChannelRouteFailure {
   readonly ok: false;
   readonly route: string;
-  readonly kind: 'auth_required' | 'daemon_unavailable' | 'route_unavailable' | 'daemon_error';
+  readonly kind: 'auth_required' | 'connected_host_unavailable' | 'connected_host_route_unavailable' | 'connected_host_error';
+  readonly baseUrl: string;
   readonly message: string;
 }
 
 type ChannelRouteResult = ChannelRouteSuccess | ChannelRouteFailure;
 
+const CHANNEL_FAILURE_LABELS: Record<ChannelRouteFailure['kind'], string> = {
+  auth_required: 'auth required',
+  connected_host_unavailable: 'connected host unavailable',
+  connected_host_route_unavailable: 'connected host route unavailable',
+  connected_host_error: 'connected host error',
+};
+
 function isRecord(value: unknown): value is JsonRecord {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -48,7 +74,59 @@ function readRecordArray(record: JsonRecord, key: string): readonly JsonRecord[]
   return Array.isArray(value) ? value.filter(isRecord) : [];
 }
 
-function resolveChannelDaemonConnection(context: CommandContext): ChannelDaemonConnection {
+function readFlagValue(args: readonly string[], index: number, flag: string, errors: string[]): string | null {
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) {
+    errors.push(`${flag} requires a value.`);
+    return null;
+  }
+  return value;
+}
+
+function parseChannelSendArgs(args: readonly string[]): ChannelSendArgs {
+  const parsed = stripYesFlag([...args]);
+  const errors: string[] = [];
+  const messageParts: string[] = [];
+  let title: string | undefined;
+  let channel: string | undefined;
+  let route: string | undefined;
+  let webhook: string | undefined;
+  let link: string | undefined;
+
+  for (let index = 0; index < parsed.rest.length; index += 1) {
+    const arg = parsed.rest[index];
+    if (arg === '--title' || arg === '--message' || arg === '--channel' || arg === '--route' || arg === '--webhook' || arg === '--link') {
+      const value = readFlagValue(parsed.rest, index, arg, errors);
+      index += 1;
+      if (!value) continue;
+      if (arg === '--title') title = value;
+      else if (arg === '--message') messageParts.push(value);
+      else if (arg === '--channel') channel = value;
+      else if (arg === '--route') route = value;
+      else if (arg === '--webhook') webhook = value;
+      else link = value;
+    } else if (arg?.startsWith('--')) {
+      errors.push(`Unknown channel send flag ${arg}`);
+    } else if (arg) {
+      messageParts.push(arg);
+    }
+  }
+
+  const message = messageParts.join(' ').trim();
+  if (!message) errors.push('Channel send message is required.');
+  return {
+    message,
+    ...(title ? { title } : {}),
+    ...(channel ? { channel } : {}),
+    ...(route ? { route } : {}),
+    ...(webhook ? { webhook } : {}),
+    ...(link ? { link } : {}),
+    yes: parsed.yes,
+    errors,
+  };
+}
+
+function resolveChannelConnectedHostConnection(context: CommandContext): ChannelConnectedHostConnection {
   const hostValue = context.platform?.configManager?.get('controlPlane.host');
   const portValue = context.platform?.configManager?.get('controlPlane.port');
   const host = typeof hostValue === 'string' && hostValue.trim().length > 0 ? hostValue.trim() : '127.0.0.1';
@@ -66,13 +144,14 @@ function resolveChannelDaemonConnection(context: CommandContext): ChannelDaemonC
 }
 
 async function fetchChannelRoute(context: CommandContext, route: string): Promise<ChannelRouteResult> {
-  const connection = resolveChannelDaemonConnection(context);
+  const connection = resolveChannelConnectedHostConnection(context);
   if (!connection.token) {
     return {
       ok: false,
       route,
       kind: 'auth_required',
-      message: `No runtime operator token found at ${connection.tokenPath}`,
+      baseUrl: connection.baseUrl,
+      message: `No connected-host operator token found at ${connection.tokenPath}`,
     };
   }
 
@@ -97,8 +176,9 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
         kind: response.status === 401 || response.status === 403
           ? 'auth_required'
           : response.status === 404
-            ? 'route_unavailable'
-            : 'daemon_error',
+            ? 'connected_host_route_unavailable'
+            : 'connected_host_error',
+        baseUrl: connection.baseUrl,
         message: `HTTP ${response.status}${detail ? `: ${detail}` : ''}`,
       };
     }
@@ -107,7 +187,8 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
     return {
       ok: false,
       route,
-      kind: 'daemon_unavailable',
+      kind: 'connected_host_unavailable',
+      baseUrl: connection.baseUrl,
       message: error instanceof Error ? error.message : String(error),
     };
   }
@@ -116,7 +197,9 @@ async function fetchChannelRoute(context: CommandContext, route: string): Promis
 function formatChannelRouteFailure(title: string, failure: ChannelRouteFailure): string {
   return [
     `${title}: unavailable`,
+    `  status: ${CHANNEL_FAILURE_LABELS[failure.kind]}`,
     `  kind: ${failure.kind}`,
+    `  connected host: ${failure.baseUrl}`,
     `  route: ${failure.route}`,
     `  error: ${failure.message}`,
     '  policy: read-only; no channel send/action route was called',
@@ -207,21 +290,21 @@ function formatChannelAccounts(body: unknown): string {
   const accounts = readRecordArray(root, 'accounts');
   const lines = [
     'Channel Accounts',
-    `  accounts: ${accounts.length}`,
-    '  policy: read-only account posture; secret values are never shown',
+    `  accounts ${accounts.length}`,
+    '  policy read-only account posture; secret values are never shown',
     '',
   ];
-  if (accounts.length === 0) return [...lines, '  No channel accounts reported by connected services.'].join('\n');
+  if (accounts.length === 0) return [...lines, '  No channel accounts reported by connected host.'].join('\n');
   for (const account of accounts.slice(0, 20)) {
     const surface = readString(account, 'surface', 'unknown');
     const accountId = readString(account, 'accountId', '');
     const authState = readString(account, 'authState', readString(account, 'state', 'unknown'));
     const configured = readBoolean(account, 'configured') ? 'configured' : 'not-configured';
     const linked = readBoolean(account, 'linked') ? 'linked' : 'not-linked';
-    const secrets = readRecordArray(account, 'secrets')
-      .map((secret) => `${readString(secret, 'field', 'secret')}:${readString(secret, 'source', 'configured')}`)
+    const secretFields = readRecordArray(account, 'secrets')
+      .map((secret) => readString(secret, 'field', 'secret'))
       .join(', ') || 'none';
-    lines.push(`  ${surface}${accountId ? `/${accountId}` : ''}: ${configured}; ${linked}; auth=${authState}; secret refs=${secrets}`);
+    lines.push(`  ${surface}${accountId ? `/${accountId}` : ''}: ${configured}; ${linked}; auth=${authState}; secret refs=${secretFields === 'none' ? 'none' : secretFields.split(', ').map((field) => `${field}:config`).join(',')}`);
   }
   if (accounts.length > 20) lines.push(`  ${accounts.length - 20} more account(s) omitted.`);
   return lines.join('\n');
@@ -232,11 +315,11 @@ function formatChannelPolicies(body: unknown): string {
   const policies = readRecordArray(root, 'policies');
   const lines = [
     'Channel Policies',
-    `  policies: ${policies.length}`,
-    '  policy: read-only policy posture; use exact confirmed commands for changes',
+    `  policies ${policies.length}`,
+    '  policy read-only policy posture; use exact confirmed commands for changes',
     '',
   ];
-  if (policies.length === 0) return [...lines, '  No channel policies reported by connected services.'].join('\n');
+  if (policies.length === 0) return [...lines, '  No channel policies reported by connected host.'].join('\n');
   for (const policy of policies.slice(0, 20)) {
     const surface = readString(policy, 'surface', 'unknown');
     const direct = readBoolean(policy, 'allowDirectMessages') ? 'direct=yes' : 'direct=no';
@@ -254,8 +337,8 @@ function formatChannelStatus(body: unknown): string {
   const channels = readRecordArray(root, 'channels');
   const lines = [
     'Connected Channel Status',
-    `  channels: ${channels.length}`,
-    '  policy: read-only connected-service status',
+    `  channels ${channels.length}`,
+    '  policy read-only connected-host status',
     '',
   ];
   if (channels.length === 0) return [...lines, '  No connected channel status reported.'].join('\n');
@@ -276,9 +359,9 @@ function formatChannelDoctor(surface: string, body: unknown): string {
   const repairActions = readRecordArray(root, 'repairActions');
   const lines = [
     `Channel Doctor: ${readString(root, 'surface', surface)}`,
-    `  checks: ${checks.length}`,
-    `  repair actions: ${repairActions.length}`,
-    '  policy: read-only doctor report; repair actions are not run here',
+    `  checks ${checks.length}`,
+    `  repair actions ${repairActions.length}`,
+    '  policy read-only doctor report; repair actions are not run here',
     '',
   ];
   if (checks.length === 0) lines.push('  No doctor checks reported.');
@@ -298,18 +381,18 @@ function formatChannelSetup(surface: string, body: unknown): string {
   const secretTargets = readRecordArray(root, 'secretTargets');
   const lines = [
     `Channel Setup Schema: ${readString(root, 'surface', surface)}`,
-    `  version: ${typeof root.version === 'number' ? root.version : 'unknown'}`,
-    `  fields: ${fields.length}`,
-    `  secret targets: ${secretTargets.length}`,
-    '  policy: read-only setup schema; no credentials or values are printed',
+    `  version ${typeof root.version === 'number' ? root.version : 'unknown'}`,
+    `  fields ${fields.length}`,
+    `  secret targets ${secretTargets.length}`,
+    '  policy read-only setup form; no credentials or values are printed',
     '',
   ];
   if (fields.length > 0) {
-    lines.push('  Fields:');
+    lines.push('  Fields');
     for (const field of fields.slice(0, 20)) lines.push(`  - ${readString(field, 'id', 'field')}`);
   }
   if (secretTargets.length > 0) {
-    lines.push('', '  Secret targets:');
+    lines.push('', '  Secret targets');
     for (const target of secretTargets.slice(0, 12)) {
       const required = readBoolean(target, 'required') ? 'required' : 'optional';
       lines.push(`  - ${readString(target, 'id', 'secret')} (${required})`);
@@ -336,9 +419,9 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'channels',
     aliases: ['channel'],
-    description: 'Inspect Agent channel readiness without sending messages',
-    usage: '[list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]',
-    argsHint: 'list|readiness|ready|attention|show|accounts|policies|status|doctor|setup',
+    description: 'Inspect Agent channel readiness or send an explicitly confirmed delivery message',
+    usage: '[list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]',
+    argsHint: 'list|readiness|ready|attention|show|send|accounts|policies|status|doctor|setup',
     async handler(args, ctx) {
       const channels = buildAgentWorkspaceChannels(ctx);
       const subcommand = (args[0] ?? 'readiness').trim().toLowerCase();
@@ -366,13 +449,44 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         }
         const channel = channels.find((entry) => entry.id.toLowerCase() === channelId || entry.label.toLowerCase() === channelId);
         if (!channel) {
-          ctx.print(`Unknown channel: ${channelId}\nUse /channels list to see available channel ids.`);
+          ctx.print(`Unknown channel ${channelId}\nUse /channels list to see available channel ids.`);
           return;
         }
         printChannelDetail(ctx.print, channel);
         return;
       }
 
+      if (subcommand === 'send') {
+        const router = ctx.platform.channelDeliveryRouter;
+        if (!router) {
+          ctx.print('Channel delivery is not available in this Agent runtime.');
+          return;
+        }
+        const parsed = parseChannelSendArgs(args.slice(1));
+        if (parsed.errors.length > 0) {
+          ctx.print(`[channels] ${parsed.errors.join('\n[channels] ')}`);
+          return;
+        }
+        let preview: ReturnType<typeof buildAgentChannelDeliveryPreview>;
+        try {
+          preview = buildAgentChannelDeliveryPreview(parsed);
+        } catch (error) {
+          ctx.print(`[channels] ${error instanceof Error ? error.message : String(error)}`);
+          return;
+        }
+        if (!parsed.yes) {
+          ctx.print(formatAgentChannelDeliveryPreview(preview, router.listStrategies().length));
+          requireYesFlag(ctx, 'send a channel delivery message', '/channels send --channel <surface[:route[:label]]> --message <text> --yes');
+          return;
+        }
+        try {
+          ctx.print(formatAgentChannelDeliveryResult(await deliverAgentChannelMessage(router, parsed)));
+        } catch (error) {
+          ctx.print(`[channels] Send failed ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
       if (subcommand === 'accounts') {
         await printReadOnlyChannelRoute(ctx, 'Channel accounts', '/api/channels/accounts', formatChannelAccounts);
         return;
@@ -403,7 +517,7 @@ export function registerChannelsRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|accounts|policies|status|doctor <id>|setup <id>]');
+      ctx.print('Usage: /channels [list|readiness|ready|attention|show <id>|send --channel <id> --message <text> --yes|accounts|policies|status|doctor <id>|setup <id>]');
     },
   });
 }

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

@@ -0,0 +1,32 @@
+import type { CliCommandRuntime } from '../../cli/management.ts';
+import { handleCompatCommand } from '../../cli/agent-knowledge-command.ts';
+import { parseGoodVibesCli } from '../../cli/parser.ts';
+import type { CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+export function registerCompatRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'compat',
+    aliases: ['compatibility'],
+    description: 'Inspect Agent SDK pin, connected host version, and Agent Knowledge route readiness',
+    usage: '[--json]',
+    argsHint: '[--json]',
+    async handler(args, ctx) {
+      const cli = parseGoodVibesCli(['compat', ...args], 'goodvibes-agent');
+      if (cli.errors.length > 0) {
+        ctx.print(cli.errors.join('\n'));
+        return;
+      }
+
+      const shellPaths = requireShellPaths(ctx);
+      const runtime: CliCommandRuntime = {
+        cli,
+        configManager: ctx.platform.configManager,
+        workingDirectory: shellPaths.workingDirectory,
+        homeDirectory: shellPaths.homeDirectory,
+      };
+      const result = await handleCompatCommand(runtime);
+      ctx.print(result.output);
+    },
+  });
+}

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

@@ -6,11 +6,15 @@ function hasFlag(args: readonly string[], flag: string): boolean {
   return args.includes(flag);
 }
 
+function hasAnyFlag(args: readonly string[], flags: readonly string[]): boolean {
+  return flags.some((flag) => hasFlag(args, flag));
+}
+
 function delegationTaskValues(args: readonly string[]): string[] {
   const values: string[] = [];
   for (let index = 0; index < args.length; index += 1) {
     const token = args[index]!;
-    if (token === '--wrfc') continue;
+    if (token === '--review' || token === '--wrfc') continue;
     if (!token.startsWith('--')) {
       values.push(token);
       continue;
@@ -19,35 +23,35 @@ function delegationTaskValues(args: readonly string[]): string[] {
   return values;
 }
 
-function buildDelegationBody(task: string, wrfcRequested: boolean): string {
+function buildDelegationBody(task: string, reviewRequested: boolean): string {
   return [
     'GoodVibes Agent explicit build delegation.',
     '',
-    'Original user ask:',
+    'Original user ask',
     task,
     '',
-    'Agent policy:',
+    'Agent policy',
     '- GoodVibes Agent is not the coding TUI.',
     '- Preserve the full original ask.',
-    '- GoodVibes TUI owns file edits, git/worktree flows, execution isolation UX, and any WRFC owner chain.',
-    wrfcRequested
-      ? '- WRFC was explicitly requested by the Agent user for this build/fix/review delegation.'
-      : '- WRFC was not explicitly requested; do not turn this into WRFC solely because it came from Agent.',
+    '- GoodVibes TUI owns file edits, git/worktree flows, execution isolation UX, and any delegated review owner chain.',
+    reviewRequested
+      ? '- Delegated review was explicitly requested by the Agent user for this build/fix/review handoff.'
+      : '- Delegated review was not explicitly requested; do not add review solely because this came from Agent.',
   ].join('\n');
 }
 
 export function registerDelegationRuntimeCommands(registry: CommandRegistry): void {
-  const makeHandler = (defaultWrfc: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
-    const wrfcRequested = defaultWrfc || hasFlag(args, '--wrfc');
+  const makeHandler = (defaultReview: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
+    const reviewRequested = defaultReview || hasAnyFlag(args, ['--review', '--wrfc']);
     const task = delegationTaskValues(args).join(' ').trim();
     if (!task) {
-      ctx.print(defaultWrfc ? 'Usage: /wrfc <build/fix/review task>' : 'Usage: /delegate [--wrfc] <build/fix/review task>');
+      ctx.print(defaultReview ? 'Usage: /delegate --review <build/fix/review task>' : 'Usage: /delegate [--review] <build/fix/review task>');
       return;
     }
     const operator = ctx.clients?.operator;
     if (!operator) {
       ctx.print([
-        'Delegation unavailable: no operator client is attached.',
+        'Delegation unavailable. No operator client is attached.',
         'Use the shared-session route from a configured Agent runtime, or open GoodVibes TUI in the target workspace.',
       ].join('\n'));
       return;
@@ -67,12 +71,13 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
           originSurface: 'goodvibes-agent',
           sourceSessionId: ctx.session.runtime.sessionId,
           task,
-          wrfcRequested,
+          reviewRequested,
+          wrfcRequested: reviewRequested,
         },
       });
       await operator.sessions.submitMessage({
         sessionId: session.id,
-        body: buildDelegationBody(task, wrfcRequested),
+        body: buildDelegationBody(task, reviewRequested),
         surfaceKind: participant.surfaceKind,
         surfaceId: participant.surfaceId,
         externalId: participant.externalId,
@@ -83,7 +88,8 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
           sourceSessionId: ctx.session.runtime.sessionId,
           kind: 'task',
           task,
-          wrfcRequested,
+          reviewRequested,
+          wrfcRequested: reviewRequested,
         },
         routing: {
           executionIntent: {
@@ -96,16 +102,16 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
       });
       ctx.print([
         'Delegation submitted to GoodVibes TUI/shared-session routes.',
-        `  session: ${session.id}`,
-        `  mode: ${wrfcRequested ? 'WRFC requested' : 'direct build delegation'}`,
-        `  task: ${task}`,
-        '  next: check GoodVibes TUI shared-session/task status for the result.',
+        `  session ${session.id}`,
+        `  mode ${reviewRequested ? 'delegated review requested' : 'direct build delegation'}`,
+        `  task ${task}`,
+        '  next check GoodVibes TUI shared-session/task status for the result.',
       ].join('\n'));
     } catch (error) {
       ctx.print([
         'Delegation failed.',
-        `  error: ${summarizeError(error)}`,
-        '  fallback: open GoodVibes TUI in the target workspace and paste the original task there.',
+        `  error ${summarizeError(error)}`,
+        '  fallback open GoodVibes TUI in the target workspace and paste the original task there.',
       ].join('\n'));
     }
   };
@@ -114,8 +120,8 @@ export function registerDelegationRuntimeCommands(registry: CommandRegistry): vo
     name: 'delegate',
     aliases: ['build'],
     description: 'Explicitly delegate build/fix/review work to GoodVibes TUI through shared-session routes',
-    usage: '[--wrfc] <task>',
-    argsHint: '[--wrfc] <task>',
+    usage: '[--review] <task>',
+    argsHint: '[--review] <task>',
     handler: makeHandler(false),
   });
 }

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

@@ -3,6 +3,7 @@ import { dirname, resolve } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
+import { handleApprovalOperatorAction } from './operator-actions-runtime.ts';
 
 interface VoiceBundle {
   readonly version: 1;
@@ -25,18 +26,19 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
     name: 'approval',
     aliases: ['approvals'],
     description: 'Review action-specific approval classes and the specialized security UX matrix',
-    usage: '[matrix|review <kind>]',
+    usage: '[matrix|review <kind>|approve <id> --yes|deny <id> --yes|cancel <id> --yes]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'matrix').toLowerCase();
+      if (await handleApprovalOperatorAction(args, ctx)) return;
       if (sub === 'open' || sub === 'panel') {
-        ctx.print('Approval panels are not part of the Agent workspace. Use /approval matrix.');
+        ctx.print('Open Agent Workspace -> Work -> Review approvals for the workspace view, or run /approval matrix for the compact command output.');
         return;
       }
       const matrix = [
         ['shell', 'Shell execution approval with side-effect and credential review.'],
         ['file', 'File mutation approval with config/notebook differentiation.'],
         ['network', 'Network access approval with host/scope review.'],
-        ['delegate', 'Explicit GoodVibes TUI build delegation approval; local Agent spawn is blocked.'],
+        ['delegate', 'Explicit GoodVibes TUI build delegation approval; Agent-owned job fanout is blocked.'],
         ['mcp', 'MCP trust escalation approval with host/path review.'],
         ['remote', 'Remote dispatch approval with trust/artifact review.'],
         ['hook', 'Hook execution approval with deny/mutate authority review.'],
@@ -63,7 +65,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ].join('\n'));
         return;
       }
-      ctx.print('Usage: /approval [matrix|review <kind>]');
+      ctx.print('Usage: /approval [matrix|review <kind>|approve <id> --yes|deny <id> --yes|cancel <id> --yes]');
     },
   });
 

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

@@ -22,10 +22,10 @@ export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void
           '  /setup              - open Agent setup with current settings preloaded',
           '  /agent              - open the Agent operator workspace',
           '  /knowledge          - inspect isolated Agent Knowledge status, ask, and search',
-          '  /memory             - manage local Agent memory',
-          '  /personas           - manage local Agent personas',
-          '  /agent-skills       - manage reusable local Agent skills',
-          '  /routines           - manage local Agent routines',
+          '  /memory             - manage Agent-local memory',
+          '  /personas           - manage Agent-local personas',
+          '  /skills       - manage reusable Agent-local skills',
+          '  /routines           - manage Agent-local routines',
           '  /delegate           - explicitly hand build/fix/review work to GoodVibes TUI',
         ].join('\n'));
         return;