@pellux/goodvibes-agent 0.1.47 → 0.1.48

package/src/input/agent-workspace.ts

@@ -5,6 +5,16 @@ import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
+import {
+  buildAgentWorkspaceChannels,
+  type AgentWorkspaceChannelStatus,
+} from './agent-workspace-channels.ts';
+import {
+  buildAgentWorkspaceSetupChecklist,
+  type AgentWorkspaceSetupChecklistItem,
+} from './agent-workspace-setup.ts';
+
+export type { AgentWorkspaceChannelRisk, AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -32,20 +42,6 @@ export interface AgentWorkspaceCategory {
 
 export type AgentWorkspaceCommandDispatcher = (command: string) => void;
 
-export type AgentWorkspaceChannelRisk = 'dm' | 'group' | 'public' | 'webhook' | 'bridge';
-
-export interface AgentWorkspaceChannelStatus {
-  readonly id: string;
-  readonly label: string;
-  readonly enabled: boolean;
-  readonly ready: boolean;
-  readonly missingConfigCount: number;
-  readonly defaultTarget: 'configured' | 'missing' | 'not-required';
-  readonly delivery: 'disabled' | 'blocked' | 'explicit-target' | 'default-ready';
-  readonly risk: AgentWorkspaceChannelRisk;
-  readonly riskLabel: string;
-}
-
 export type AgentWorkspaceActionResultKind = 'guidance' | 'blocked' | 'dispatched' | 'refreshed' | 'error';
 
 export interface AgentWorkspaceActionResult {
@@ -100,139 +96,10 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly runtimeStarterTemplateCount: number;
   readonly localStarterTemplateCount: number;
   readonly configProfileCount: number;
+  readonly setupChecklist: readonly AgentWorkspaceSetupChecklistItem[];
   readonly warnings: readonly string[];
 }
 
-interface AgentWorkspaceChannelSpec {
-  readonly id: string;
-  readonly label: string;
-  readonly enabledKey: string;
-  readonly requiredKeys: readonly string[];
-  readonly defaultTargetKeys: readonly string[];
-  readonly risk: AgentWorkspaceChannelRisk;
-  readonly riskLabel: string;
-}
-
-const AGENT_WORKSPACE_CHANNEL_SPECS: readonly AgentWorkspaceChannelSpec[] = [
-  {
-    id: 'slack',
-    label: 'Slack',
-    enabledKey: 'surfaces.slack.enabled',
-    requiredKeys: ['surfaces.slack.botToken', 'surfaces.slack.signingSecret'],
-    defaultTargetKeys: ['surfaces.slack.defaultChannel'],
-    risk: 'group',
-    riskLabel: 'workspace/group channel',
-  },
-  {
-    id: 'discord',
-    label: 'Discord',
-    enabledKey: 'surfaces.discord.enabled',
-    requiredKeys: ['surfaces.discord.botToken', 'surfaces.discord.publicKey', 'surfaces.discord.applicationId'],
-    defaultTargetKeys: ['surfaces.discord.defaultChannelId'],
-    risk: 'group',
-    riskLabel: 'server/channel delivery',
-  },
-  {
-    id: 'telegram',
-    label: 'Telegram',
-    enabledKey: 'surfaces.telegram.enabled',
-    requiredKeys: ['surfaces.telegram.botToken'],
-    defaultTargetKeys: ['surfaces.telegram.defaultChatId'],
-    risk: 'dm',
-    riskLabel: 'bot DM/group delivery',
-  },
-  {
-    id: 'ntfy',
-    label: 'ntfy',
-    enabledKey: 'surfaces.ntfy.enabled',
-    requiredKeys: ['surfaces.ntfy.baseUrl', 'surfaces.ntfy.chatTopic', 'surfaces.ntfy.agentTopic'],
-    defaultTargetKeys: ['surfaces.ntfy.topic'],
-    risk: 'public',
-    riskLabel: 'topic-based public/private feed',
-  },
-  {
-    id: 'googleChat',
-    label: 'Google Chat',
-    enabledKey: 'surfaces.googleChat.enabled',
-    requiredKeys: ['surfaces.googleChat.webhookUrl', 'surfaces.googleChat.verificationToken'],
-    defaultTargetKeys: ['surfaces.googleChat.spaceId'],
-    risk: 'group',
-    riskLabel: 'space delivery',
-  },
-  {
-    id: 'signal',
-    label: 'Signal',
-    enabledKey: 'surfaces.signal.enabled',
-    requiredKeys: ['surfaces.signal.bridgeUrl', 'surfaces.signal.account'],
-    defaultTargetKeys: ['surfaces.signal.defaultRecipient'],
-    risk: 'bridge',
-    riskLabel: 'private bridge delivery',
-  },
-  {
-    id: 'whatsapp',
-    label: 'WhatsApp',
-    enabledKey: 'surfaces.whatsapp.enabled',
-    requiredKeys: ['surfaces.whatsapp.accessToken', 'surfaces.whatsapp.verifyToken', 'surfaces.whatsapp.phoneNumberId'],
-    defaultTargetKeys: ['surfaces.whatsapp.defaultRecipient'],
-    risk: 'dm',
-    riskLabel: 'phone-number delivery',
-  },
-  {
-    id: 'imessage',
-    label: 'iMessage',
-    enabledKey: 'surfaces.imessage.enabled',
-    requiredKeys: ['surfaces.imessage.bridgeUrl', 'surfaces.imessage.account'],
-    defaultTargetKeys: ['surfaces.imessage.defaultChatId'],
-    risk: 'bridge',
-    riskLabel: 'Apple bridge delivery',
-  },
-  {
-    id: 'bluebubbles',
-    label: 'BlueBubbles',
-    enabledKey: 'surfaces.bluebubbles.enabled',
-    requiredKeys: ['surfaces.bluebubbles.serverUrl', 'surfaces.bluebubbles.password'],
-    defaultTargetKeys: ['surfaces.bluebubbles.defaultChatGuid'],
-    risk: 'bridge',
-    riskLabel: 'iMessage bridge delivery',
-  },
-  {
-    id: 'msteams',
-    label: 'Microsoft Teams',
-    enabledKey: 'surfaces.msteams.enabled',
-    requiredKeys: ['surfaces.msteams.appId', 'surfaces.msteams.appPassword'],
-    defaultTargetKeys: ['surfaces.msteams.defaultConversationId', 'surfaces.msteams.defaultChannelId'],
-    risk: 'group',
-    riskLabel: 'tenant/channel delivery',
-  },
-  {
-    id: 'mattermost',
-    label: 'Mattermost',
-    enabledKey: 'surfaces.mattermost.enabled',
-    requiredKeys: ['surfaces.mattermost.baseUrl', 'surfaces.mattermost.botToken'],
-    defaultTargetKeys: ['surfaces.mattermost.defaultChannelId'],
-    risk: 'group',
-    riskLabel: 'team/channel delivery',
-  },
-  {
-    id: 'matrix',
-    label: 'Matrix',
-    enabledKey: 'surfaces.matrix.enabled',
-    requiredKeys: ['surfaces.matrix.homeserverUrl', 'surfaces.matrix.accessToken'],
-    defaultTargetKeys: ['surfaces.matrix.defaultRoomId'],
-    risk: 'group',
-    riskLabel: 'room delivery',
-  },
-  {
-    id: 'webhook',
-    label: 'Webhook',
-    enabledKey: 'surfaces.webhook.enabled',
-    requiredKeys: ['surfaces.webhook.defaultTarget'],
-    defaultTargetKeys: ['surfaces.webhook.defaultTarget'],
-    risk: 'webhook',
-    riskLabel: 'external HTTP delivery',
-  },
-];
-
 function readConfigString(context: CommandContext, key: string, fallback: string): string {
   try {
     const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
@@ -270,48 +137,6 @@ function readConfigBoolean(context: CommandContext, key: string, fallback: boole
   }
 }
 
-function hasConfigValue(context: CommandContext, key: string): boolean {
-  try {
-    const configManager = context.platform?.configManager as unknown as AgentWorkspaceConfigReader | undefined;
-    const value = configManager?.get(key);
-    if (typeof value === 'string') return value.trim().length > 0;
-    if (typeof value === 'number') return Number.isFinite(value);
-    if (typeof value === 'boolean') return value;
-    return value !== null && value !== undefined;
-  } catch {
-    return false;
-  }
-}
-
-function buildChannelStatus(context: CommandContext, spec: AgentWorkspaceChannelSpec): AgentWorkspaceChannelStatus {
-  const enabled = readConfigBoolean(context, spec.enabledKey, false);
-  const missingConfigCount = spec.requiredKeys.filter((key) => !hasConfigValue(context, key)).length;
-  const defaultTarget = spec.defaultTargetKeys.length === 0
-    ? 'not-required'
-    : spec.defaultTargetKeys.some((key) => hasConfigValue(context, key))
-      ? 'configured'
-      : 'missing';
-  const ready = enabled && missingConfigCount === 0;
-  const delivery = !enabled
-    ? 'disabled'
-    : !ready
-      ? 'blocked'
-      : defaultTarget === 'configured'
-        ? 'default-ready'
-        : 'explicit-target';
-  return {
-    id: spec.id,
-    label: spec.label,
-    enabled,
-    ready,
-    missingConfigCount,
-    defaultTarget,
-    delivery,
-    risk: spec.risk,
-    riskLabel: spec.riskLabel,
-  };
-}
-
 function inferActiveRuntimeProfile(homeDirectory: string): string {
   const marker = `${sep}.goodvibes${sep}agent${sep}profile-homes${sep}`;
   return homeDirectory.includes(marker) ? basename(homeDirectory) : '(default home)';
@@ -408,6 +233,24 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const ttsVoice = readConfigString(context, 'tts.voice', '(voice default)');
   const ttsLlmProvider = readConfigString(context, 'tts.llmProvider', '');
   const ttsLlmModel = readConfigString(context, 'tts.llmModel', '');
+  const daemonBaseUrl = `http://${host}:${port}`;
+  const channels = buildAgentWorkspaceChannels(context);
+  const setupChecklist = buildAgentWorkspaceSetupChecklist({
+    provider,
+    model,
+    daemonBaseUrl,
+    sessionMemoryCount,
+    routineCount: routineSnapshot.count,
+    enabledRoutineCount: routineSnapshot.enabled,
+    skillCount: skillSnapshot.count,
+    enabledSkillCount: skillSnapshot.enabled,
+    activePersonaName: personaSnapshot.activeName,
+    readyChannelCount: channels.filter((channel) => channel.ready).length,
+    voiceProviderCount: voiceProviders.length,
+    mediaProviderCount: mediaProviders.length,
+    runtimeProfileCount: runtimeProfiles.length,
+    runtimeStarterTemplateCount: runtimeStarterTemplates.length,
+  });
 
   return {
     provider,
@@ -416,7 +259,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     sessionId: context.session?.runtime?.sessionId ?? 'unknown',
     workingDirectory: context.workspace?.shellPaths?.workingDirectory ?? 'unavailable',
     homeDirectory: context.workspace?.shellPaths?.homeDirectory ?? 'unavailable',
-    daemonBaseUrl: `http://${host}:${port}`,
+    daemonBaseUrl,
     daemonOwnership: 'external',
     sessionMemoryCount,
     localRoutineCount: routineSnapshot.count,
@@ -429,7 +272,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',
     wrfcPolicy: 'explicit-build-delegation-only',
-    channels: AGENT_WORKSPACE_CHANNEL_SPECS.map((spec) => buildChannelStatus(context, spec)),
+    channels,
     voiceProviderCount: voiceProviders.length,
     voiceStreamingProviderCount: voiceProviders.filter((entry) => entry.capabilities.includes('tts-stream')).length,
     voiceSttProviderCount: voiceProviders.filter((entry) => entry.capabilities.includes('stt')).length,
@@ -449,6 +292,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     runtimeStarterTemplateCount: runtimeStarterTemplates.length,
     localStarterTemplateCount: runtimeStarterTemplates.filter((template) => template.source === 'local').length,
     configProfileCount,
+    setupChecklist,
     warnings,
   };
 }
@@ -480,24 +324,6 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'auth', label: 'Auth review', detail: 'Review authentication posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
     ],
   },
-  {
-    id: 'capabilities',
-    group: 'SETUP',
-    label: 'Capabilities',
-    summary: 'OpenClaw/Hermes benchmark and live daemon coverage.',
-    detail: 'Use this area to measure both layers: what GoodVibes Agent makes usable, and what the externally owned GoodVibes daemon actually exposes through public routes. Agent Knowledge is checked only through /api/goodvibes-agent/knowledge/*.',
-    actions: [
-      { id: 'capabilities-benchmark', label: 'Benchmark report', detail: 'Show the OpenClaw/Hermes parity benchmark with Agent posture, setup commands, usage paths, and remaining product gaps.', command: '/capabilities', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon', label: 'Live daemon audit', detail: 'Inspect the public daemon method catalog plus isolated Agent Knowledge route coverage. Does not query default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-gaps', label: 'Daemon gap plan', detail: 'Classify live daemon coverage into platform gaps, Agent route gaps, route-risk reviews, and Agent UX work without querying default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon gaps', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-risk', label: 'Route risk review', detail: 'Inspect daemon read-only, mutating, dangerous, and authenticated route metadata for approval-center planning.', command: '/capabilities daemon risk', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-inventory', label: 'Full method inventory', detail: 'List every public daemon method by category, HTTP posture, access, and dangerous flag without querying default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon inventory', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-coverage', label: 'UX coverage matrix', detail: 'Map every public daemon method to Agent UX coverage: usable, read-only, explicit confirmation, blocked, or not surfaced.', command: '/capabilities daemon coverage', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-knowledge', label: 'Knowledge coverage', detail: 'Filter the live daemon audit to the isolated Agent Knowledge segment.', command: '/capabilities daemon knowledge', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-channels', label: 'Channel coverage', detail: 'Filter the live daemon audit to channel and delivery gateway route coverage.', command: '/capabilities daemon channels', kind: 'command', safety: 'read-only' },
-      { id: 'capabilities-daemon-automation', label: 'Automation coverage', detail: 'Filter the live daemon audit to automation, schedule, run, and capacity route coverage.', command: '/capabilities daemon automation', kind: 'command', safety: 'read-only' },
-    ],
-  },
   {
     id: 'channels',
     group: 'SETUP',
@@ -532,7 +358,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     group: 'SETUP',
     label: 'Voice, Media & Nodes',
     summary: 'Voice, TTS, image input, browser surface, and node/remote posture.',
-    detail: 'Hermes and OpenClaw expose voice, media, browser, and node surfaces as first-class operator capabilities. Agent uses the GoodVibes voice/media/provider/browser/remote bones while keeping daemon ownership external and side effects explicit.',
+    detail: 'Voice, media, browser, and node surfaces are first-class operator surfaces. Agent uses the GoodVibes voice/media/provider/browser/remote bones while keeping daemon ownership external and side effects explicit.',
     actions: [
       { id: 'tts-config', label: 'Configure live TTS', detail: 'Open the TUI-derived config workspace at the TTS settings group.', command: '/config tts', kind: 'command', safety: 'safe' },
       { id: 'tts-provider', label: 'Choose TTS provider', detail: 'Open provider/model routing for spoken responses through the settings flow.', command: '/config tts.provider', kind: 'command', safety: 'safe' },
@@ -548,7 +374,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     group: 'SETUP',
     label: 'Profiles & Portability',
     summary: 'Isolated Agent homes, config profiles, and setup bundles.',
-    detail: 'Hermes profiles isolate agent state. GoodVibes Agent exposes named runtime homes, config profile pickers, profile-sync bundles, setup transfer bundles, and support bundles while keeping the daemon external.',
+    detail: 'Profiles isolate agent state. GoodVibes Agent exposes named runtime homes, config profile pickers, profile-sync bundles, setup transfer bundles, and support bundles while keeping the daemon external.',
     actions: [
       { id: 'profiles-open', label: 'Open config profiles', detail: 'Open the TUI-derived config profile picker for display/provider/behavior profile files.', command: '/profiles', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-guide', label: 'Starter authoring guide', detail: 'Open the Agent-local starter authoring flow inside the TUI command surface.', command: '/agent-profile guide', kind: 'command', safety: 'safe' },
@@ -584,7 +410,6 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'workplan', label: 'Open work plan', detail: 'Open the workspace-scoped work plan panel.', command: '/workplan panel', kind: 'command', safety: 'read-only' },
       { id: 'workplan-list', label: 'List work plan', detail: 'Print a concise work plan summary.', command: '/workplan list', kind: 'command', safety: 'read-only' },
       { id: 'approvals', label: 'Review approvals', detail: 'Open/read approval posture. This workspace does not approve or deny requests.', command: '/approval open', kind: 'command', safety: 'read-only' },
-      { id: 'approval-risk', label: 'Route risk review', detail: 'Inspect daemon route risk and dangerous method metadata without approving, denying, or mutating requests.', command: '/approval risk', kind: 'command', safety: 'read-only' },
     ],
   },
   {

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

@@ -4,13 +4,6 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { requirePanelManager, requireShellPaths } from './runtime-services.ts';
 import { requireYesFlag, stripYesFlag } from './confirmation.ts';
 import { resolveAgentDaemonConnection } from '../../agent/routine-schedule-promotion.ts';
-import {
-  buildDaemonCapabilityRouteRiskReport,
-  fetchLiveDaemonCapabilityAudit,
-  filterDaemonCapabilityRouteRiskAreas,
-  renderDaemonCapabilityFailure,
-  renderDaemonCapabilityRouteRisk,
-} from '../../operator/daemon-capability-audit.ts';
 
 interface VoiceBundle {
   readonly version: 1;
@@ -186,7 +179,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
     name: 'approval',
     aliases: ['approvals'],
     description: 'Review action-specific approval classes and the specialized security UX matrix',
-    usage: '[matrix|risk|review <kind>]',
+    usage: '[matrix|review <kind>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'matrix').toLowerCase();
       if (sub === 'open' || sub === 'panel') {
@@ -213,25 +206,9 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ctx.print([
           'Approval Matrix',
           ...matrix.map(([kind, summary]) => `  ${kind.padEnd(10)} ${summary}`),
-          '',
-          'Live daemon route risk: /approval risk',
         ].join('\n'));
         return;
       }
-      if (sub === 'risk' || sub === 'route-risk') {
-        const shellPaths = requireShellPaths(ctx);
-        const connection = resolveAgentDaemonConnection(ctx.platform.configManager, shellPaths.homeDirectory);
-        const audit = await fetchLiveDaemonCapabilityAudit(connection);
-        if (!audit.ok) {
-          ctx.print(renderDaemonCapabilityFailure(audit));
-          return;
-        }
-        const report = buildDaemonCapabilityRouteRiskReport(audit);
-        const query = args.slice(1).join(' ').trim() || undefined;
-        const areas = filterDaemonCapabilityRouteRiskAreas(report.areas, query);
-        ctx.print(renderDaemonCapabilityRouteRisk(report, areas));
-        return;
-      }
       if (sub === 'review') {
         const kind = (args[1] ?? '').toLowerCase();
         const entry = matrix.find(([id]) => id === kind);
@@ -246,7 +223,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         ].join('\n'));
         return;
       }
-      ctx.print('Usage: /approval [open|matrix|risk|review <kind>]');
+      ctx.print('Usage: /approval [open|matrix|review <kind>]');
     },
   });
 

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

@@ -46,7 +46,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
     name: 'remote',
     aliases: [],
     description: 'Inspect, dispatch, and review self-hosted remote runners and artifacts',
-    usage: '[list | show [agentId] | supervisor [runnerId] | capabilities [runnerId] | recover [runnerId] | setup [export <path> --yes] | env [export <path> --yes] | tunnel [review|export <path> --yes] | bootstrap [export <path> --yes|inspect <path>] | session <export|inspect|import> <path> [--yes] | pool <list|show|create|assign|unassign> ... | dispatch [template] <description> | dispatch-pool <pool> [template] <description> | contract [agentId] | cancel <agentId> | export <agentId> [path] --yes | artifact list | artifact show <id> | artifact export <id> [path] --yes | review <id> | rerun-local <id> | import <path> --yes]',
+    usage: '[list | show [agentId] | supervisor [runnerId] | support [runnerId] | recover [runnerId] | setup [export <path> --yes] | env [export <path> --yes] | tunnel [review|export <path> --yes] | bootstrap [export <path> --yes|inspect <path>] | session <export|inspect|import> <path> [--yes] | pool <list|show|create|assign|unassign> ... | dispatch [template] <description> | dispatch-pool <pool> [template] <description> | contract [agentId] | cancel <agentId> | export <agentId> [path] --yes | artifact list | artifact show <id> | artifact export <id> [path] --yes | review <id> | rerun-local <id> | import <path> --yes]',
     async handler(args, ctx) {
       if (args.length === 0) {
         if (ctx.openRemotePanel) {
@@ -131,7 +131,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           `  messageCount: ${selected.messageCount}`,
           `  errorCount: ${selected.errorCount}`,
           ...(selected.lastError ? [`  lastError: ${selected.lastError}`] : []),
-          '  capabilities:',
+          '  runner support:',
           ...selected.capabilities.map((capability) => `    ${capability.id}: ${capability.supported ? 'yes' : 'no'} (${capability.detail})`),
           '  recovery:',
           ...selected.recovery.map((action) => `    ${action.command} — ${action.reason}`),
@@ -139,7 +139,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
         return;
       }
 
-      if (subcommand === 'capabilities') {
+      if (subcommand === 'support') {
         const snapshot = peerSnapshot.supervisor;
         const runnerId = args[1];
         const selected = runnerId
@@ -150,14 +150,14 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           return;
         }
         ctx.print([
-          `Remote Capabilities ${selected.runnerId}`,
+          `Remote Support ${selected.runnerId}`,
           `  label: ${selected.label}`,
           `  transport: ${selected.transportState}`,
           `  executionProtocol: ${selected.negotiation.executionProtocol}`,
           `  reviewMode: ${selected.negotiation.reviewMode}`,
           `  communicationLane: ${selected.negotiation.communicationLane}`,
           `  trustClass: ${selected.negotiation.trustClass}`,
-          '  capabilities:',
+          '  runner support:',
           ...selected.capabilities.map((capability) => (
             `    ${capability.id}: ${capability.supported ? 'supported' : 'missing'} — ${capability.detail}`
           )),

package/src/input/commands.ts

@@ -59,7 +59,6 @@ import { registerDelegationRuntimeCommands } from './commands/delegation-runtime
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
 import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
 import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
-import { registerCapabilitiesRuntimeCommands } from './commands/capabilities-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -69,7 +68,6 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
   registerAgentRuntimeProfileRuntimeCommands(registry);
-  registerCapabilitiesRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
   registerRoutinesRuntimeCommands(registry);

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -114,7 +114,7 @@ export function buildCapabilitiesStep(controller: OnboardingWizardController): O
         kind: 'action',
         id: 'capabilities.select-all',
         action: 'select-all-capabilities',
-        label: 'Review external-daemon capabilities',
+        label: 'Review external-daemon surfaces',
         hint: 'Review browser, LAN, webhooks/events, and external app surfaces without letting Agent own daemon lifecycle.',
         defaultValue: 'Action',
       },
@@ -123,17 +123,17 @@ export function buildCapabilitiesStep(controller: OnboardingWizardController): O
         id: 'capabilities.clear',
         action: 'clear-capabilities',
         label: 'Keep Agent local-only',
-        hint: 'Clear external-daemon capabilities and keep Agent work in this terminal conversation.',
+        hint: 'Clear external-daemon surfaces and keep Agent work in this terminal conversation.',
         defaultValue: 'Action',
       },
     ];
 
     return {
       id: 'capabilities',
-      title: 'Choose GoodVibes capabilities',
+      title: 'Choose GoodVibes surfaces',
       shortLabel: 'Capabilities',
-      description: 'Choose what Agent should prepare locally. Daemon-backed capabilities are reviewed as external dependencies; Agent does not enable service mode or autostart.',
-      summaryTitle: 'Selected capabilities',
+      description: 'Choose what Agent should prepare locally. Daemon-backed surfaces are reviewed as external dependencies; Agent does not enable service mode or autostart.',
+      summaryTitle: 'Selected surfaces',
       summaryLines: [
         `${selectedCount}/${capabilities.length} option(s) selected`,
         `Mode: ${controller.mode === 'edit' ? 'edit existing shell state' : controller.mode === 'reopen' ? 'reopen review flow' : 'new setup'}`,
@@ -327,7 +327,7 @@ export function buildExternalServicesStep(controller: OnboardingWizardController
         id: 'external-services.clear',
         action: 'clear-external-surfaces',
         label: 'Clear all external surfaces',
-        hint: 'Hide all external surface setup screens. The HTTP listener can still be enabled separately by webhook/event capabilities.',
+        hint: 'Hide all external surface setup screens. The HTTP listener can still be enabled separately by webhook/event settings.',
         defaultValue: 'Action',
       },
       {
@@ -705,7 +705,7 @@ export function buildAccountsStep(controller: OnboardingWizardController): Onboa
             ? 'An existing local auth admin user was detected and will be kept.'
             : controller.hasLocalAuthUser()
               ? 'Existing local auth users were detected and will be kept.'
-              : 'No server-backed capability is selected, so local auth is not required.',
+              : 'No server-backed surface is selected, so local auth is not required.',
         defaultValue: needsAuthBootstrap
           ? controller.hasBootstrapCredentialPresent() ? 'Bootstrap replacement required' : 'Local admin required'
           : controller.hasAdminAuthUser() ? 'Admin detected' : controller.hasLocalAuthUser() ? 'Local auth detected' : 'Not required',

package/src/panels/provider-health-domains.ts

@@ -104,7 +104,7 @@ export function buildProviderHealthDomainSummaries(
           .slice(0, 3)
           .map((entry) => `${entry.runnerId}: transport=${entry.transportState} heartbeat=${entry.heartbeat.status}${entry.lastError ? ` error=${entry.lastError}` : ''}`),
     nextSteps: remote.supervisor.degradedConnections > 0
-      ? ['/remote supervisor', '/remote recover <runnerId>', '/remote capabilities']
+      ? ['/remote supervisor', '/remote recover <runnerId>', '/remote support']
       : ['/remote supervisor'],
   });
 

package/src/panels/remote-panel.ts

@@ -204,8 +204,8 @@ export class RemotePanel extends BasePanel {
       ]));
     }
     postureLines.push(
-      buildGuidanceLine(width, '/remote recover', 'resume remote state with runner, capability, and disconnect recovery hints', C),
-      buildGuidanceLine(width, '/remote capabilities', 'inspect transport support before routing remote work or reattaching a session', C),
+      buildGuidanceLine(width, '/remote recover', 'resume remote state with runner support and disconnect recovery hints', C),
+      buildGuidanceLine(width, '/remote support', 'inspect transport support before routing remote work or reattaching a session', C),
     );
 
     const footerLines = [

package/src/renderer/agent-workspace.ts

@@ -72,6 +72,33 @@ function actionCommand(action: AgentWorkspaceAction): string {
 
 type ContextLine = { readonly text: string; readonly fg?: string; readonly bold?: boolean; readonly dim?: boolean };
 
+function setupStatusColor(status: AgentWorkspaceRuntimeSnapshot['setupChecklist'][number]['status']): string {
+  if (status === 'ready') return PALETTE.good;
+  if (status === 'recommended') return PALETTE.warn;
+  if (status === 'blocked') return PALETTE.bad;
+  return PALETTE.muted;
+}
+
+function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const readyCount = snapshot.setupChecklist.filter((item) => item.status === 'ready').length;
+  const recommendedCount = snapshot.setupChecklist.filter((item) => item.status === 'recommended').length;
+  const blockedCount = snapshot.setupChecklist.filter((item) => item.status === 'blocked').length;
+  const lines: ContextLine[] = [
+    { text: 'Setup Checklist', fg: PALETTE.title, bold: true },
+    { text: `${readyCount}/${snapshot.setupChecklist.length} ready; ${recommendedCount} recommended; ${blockedCount} blocked`, fg: blockedCount > 0 ? PALETTE.warn : PALETTE.info },
+  ];
+  for (const item of snapshot.setupChecklist) {
+    const command = item.command ? ` -> ${item.command}` : '';
+    lines.push({
+      text: `${item.status.toUpperCase()} ${item.label}${command}`,
+      fg: setupStatusColor(item.status),
+      bold: item.status === 'blocked',
+    });
+    lines.push({ text: `  ${item.detail}`, fg: PALETTE.muted });
+  }
+  return lines;
+}
+
 function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
   if (!snapshot) return [{ text: 'Runtime context is not loaded yet.', fg: PALETTE.warn }];
   const base: ContextLine[] = [{ text: 'Live Agent Context', fg: PALETTE.title, bold: true }];
@@ -87,14 +114,8 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: `Daemon ownership: ${snapshot.daemonOwnership}; Agent never starts or restarts it`, fg: PALETTE.good },
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
-    );
-  } else if (category.id === 'capabilities') {
-    base.push(
-      { text: `External daemon: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
-      { text: 'Live audit source: /api/control-plane/methods plus /api/goodvibes-agent/knowledge/status.', fg: PALETTE.info },
-      { text: 'Isolation: no default Knowledge/Wiki, HomeGraph, or Home Assistant route is used for Agent Knowledge coverage.', fg: PALETTE.good },
-      { text: 'Readiness meaning: daemon route coverage is platform capability; missing Agent UX remains a product gap to close here.', fg: PALETTE.muted },
-      { text: 'Use filtered audits for knowledge, channels, automation, voice/media/nodes, providers, MCP/tools, approvals, or sessions.', fg: PALETTE.muted },
+      { text: '' },
+      ...setupChecklistLines(snapshot),
     );
   } else if (category.id === 'channels') {
     const enabledCount = snapshot.channels.filter((channel) => channel.enabled).length;
@@ -275,10 +296,17 @@ function footerText(workspace: AgentWorkspace): string {
 }
 
 export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, height: number): Line[] {
-  const layoutOptions = { width, height, leftWidth: width < 90 ? undefined : 30, contextRatio: 0.62, minContextRows: 10 };
-  const metrics = getFullscreenWorkspaceMetrics(layoutOptions);
   const category = workspace.selectedCategory;
   const action = workspace.selectedAction;
+  const setupCategory = category.id === 'setup';
+  const layoutOptions = {
+    width,
+    height,
+    leftWidth: width < 90 ? undefined : 30,
+    contextRatio: setupCategory ? 0.86 : 0.62,
+    minContextRows: setupCategory ? 18 : 10,
+  };
+  const metrics = getFullscreenWorkspaceMetrics(layoutOptions);
 
   return renderFullscreenWorkspace({
     width,

package/src/tools/agent-context-policy.ts

@@ -3,13 +3,13 @@ import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 const CONTEXT_TOOL_DENIAL = [
   'GoodVibes Agent does not expose copied GoodVibes runtime context through model tools in the main conversation.',
   'The copied context tool can describe TUI/default runtime assumptions that are not the Agent product boundary.',
-  'Use explicit Agent CLI/slash commands such as status, compat, capabilities, and isolated Agent Knowledge instead.',
+  'Use explicit Agent CLI/slash commands such as status, compat, setup, and isolated Agent Knowledge instead.',
 ].join(' ');
 
 export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
     'Blocked in GoodVibes Agent main conversation: copied runtime context.',
-    'Use explicit Agent CLI/slash status, compat, capabilities, and Agent Knowledge commands for product-scoped context.',
+    'Use explicit Agent CLI/slash status, compat, setup, and Agent Knowledge commands for product-scoped context.',
     'Default Knowledge/Wiki, HomeGraph, and copied TUI runtime assumptions are not Agent fallbacks.',
   ].join(' ');
   tool.definition.sideEffects = [];

package/src/verification/live-verifier.ts

@@ -1,7 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
-import { auditGoodVibesHome } from '../config/goodvibes-home-audit.ts';
 import { buildVerificationLedger } from './verification-ledger.ts';
 import { SDK_VERSION } from '../version.ts';
 
@@ -309,20 +308,6 @@ export async function buildLiveVerificationReport(options: LiveVerificationOptio
     detail: `${ledger.totals.localBehaviorPercent}% local behavior verified; ${ledger.totals.externalOutcomeRequired} item(s) require external outcomes.`,
   });
 
-  const audit = await auditGoodVibesHome({ homeDir });
-  const staleCandidates = audit.settings?.staleCandidates?.length ?? 0;
-  checks.push({
-    id: 'goodvibes-home-audit',
-    title: 'GoodVibes home ownership/settings audit',
-    status: audit.findings.length === 0 && staleCandidates === 0 ? 'pass' : 'warn',
-    summary: audit.findings.length === 0
-      ? 'No ownership, stale-setting, or secret-permission findings.'
-      : `${audit.findings.length} audit finding(s).`,
-    detail: audit.findings.length === 0
-      ? `${audit.settings?.recognizedKeyCount ?? 0} current schema key(s), ${staleCandidates} stale candidate(s).`
-      : audit.findings.map((finding) => `${finding.severity}: ${finding.message}`).join('\n'),
-  });
-
   checks.push({
     id: 'compiled-cli-present',
     title: 'Compiled GoodVibes Agent CLI binary',

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.47';
+let _version = '0.1.48';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {