@pellux/goodvibes-agent 0.1.88 → 0.1.90

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.90 - 2026-06-01
+
+- 19f67ea Polish Agent command guidance
+
+## 0.1.89 - 2026-06-01
+
+- 6be201c Fix Agent workspace command targets
+
 ## 0.1.88 - 2026-06-01
 
 - e97d2a2 Fix release test daemon port allocation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.88",
+  "version": "0.1.90",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/cli/package-verification.ts

@@ -1,6 +1,8 @@
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
+import { CommandRegistry } from '../input/command-registry.ts';
+import { registerBuiltinCommands } from '../input/commands.ts';
 
 export interface PackageCliBinVerification {
   readonly command: 'goodvibes-agent';
@@ -108,11 +110,40 @@ const PACKAGE_FACING_REQUIRED_TEXT: readonly {
   { path: 'docs/runtime-connection.md', required: ['/api/goodvibes-agent/knowledge'] },
   { path: 'docs/release-and-publishing.md', required: ['/api/goodvibes-agent/knowledge'] },
 ];
+const NON_COMMAND_ROUTE_ROOTS = new Set(['api', 'status']);
 
 function readPackageJson(root: string): Record<string, unknown> {
   return JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8')) as Record<string, unknown>;
 }
 
+function buildRegisteredSlashCommandNames(): ReadonlySet<string> {
+  const registry = new CommandRegistry();
+  registerBuiltinCommands(registry);
+  const names = new Set<string>();
+  for (const command of registry.list()) {
+    names.add(command.name);
+    for (const alias of command.aliases ?? []) names.add(alias);
+  }
+  return names;
+}
+
+function verifyPackageFacingSlashCommands(path: string, content: string, registeredCommands: ReadonlySet<string>): readonly string[] {
+  const failures: string[] = [];
+  const commandPattern = /(^|[\s`([])\/([a-z][a-z0-9_-]*)(?=$|[\s`.,;:)\]])/g;
+  const lines = content.split(/\r?\n/);
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? '';
+    commandPattern.lastIndex = 0;
+    for (let match = commandPattern.exec(line); match !== null; match = commandPattern.exec(line)) {
+      const root = match[2] ?? '';
+      if (NON_COMMAND_ROUTE_ROOTS.has(root)) continue;
+      if (registeredCommands.has(root)) continue;
+      failures.push(`package-facing text ${path}:${lineIndex + 1} references unknown Agent slash command: /${root}`);
+    }
+  }
+  return failures;
+}
+
 function hasExecutableBit(path: string): boolean {
   return existsSync(path) && (statSync(path).mode & 0o111) !== 0;
 }
@@ -146,6 +177,7 @@ function registryPackDryRun(root: string): { readonly files: readonly string[];
 
 export function verifyPackageFacingText(root: string): { readonly checkedPaths: readonly string[]; readonly failures: readonly string[] } {
   const failures: string[] = [];
+  const registeredCommands = buildRegisteredSlashCommandNames();
   for (const path of PACKAGE_FACING_TEXT_PATHS) {
     const absolutePath = join(root, path);
     if (!existsSync(absolutePath)) {
@@ -153,6 +185,9 @@ export function verifyPackageFacingText(root: string): { readonly checkedPaths:
       continue;
     }
     const content = readFileSync(absolutePath, 'utf-8');
+    if (path !== 'CHANGELOG.md') {
+      failures.push(...verifyPackageFacingSlashCommands(path, content, registeredCommands));
+    }
     for (const forbidden of PACKAGE_FACING_FORBIDDEN_TEXT) {
       if (content.includes(forbidden)) {
         failures.push(`package-facing text ${path} contains forbidden default/TUI route or policy: ${forbidden}`);

package/src/input/agent-workspace-categories.ts

@@ -49,8 +49,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Agent uses externally managed channels. Pairing, account inspection, and readiness checks are visible here; inbound delivery and public channel exposure stay policy-gated.',
     actions: [
       { id: 'pair', label: 'Pair companion', detail: 'Open the QR pairing view for companion app setup.', command: '/pair', kind: 'command', safety: 'safe' },
-      { id: 'communication', label: 'Communication routes', detail: 'Inspect structured communication routes and recent activity.', command: '/communication', kind: 'command', safety: 'read-only' },
-      { id: 'setup-review', label: 'Channel setup review', detail: 'Review setup posture without starting inbound endpoints or mutating channel state.', command: '/setup review', kind: 'command', safety: 'read-only' },
+      { id: 'notification-routes', label: 'Notification routes', detail: 'Inspect configured webhook notification URLs without sending a test message.', command: '/notify list', kind: 'command', safety: 'read-only' },
+      { id: 'setup-review', label: 'Health review', detail: 'Review setup posture without starting inbound endpoints or mutating channel state.', command: '/health review', kind: 'command', safety: 'read-only' },
       { id: 'channel-safety', label: 'Delivery safety', detail: 'External messages, channel DMs, and public delivery targets require explicit user action and runtime policy. Agent will not silently send or expose channels from this workspace.', kind: 'guidance', safety: 'blocked' },
     ],
   },
@@ -90,14 +90,14 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     group: 'SETUP',
     label: 'Profiles',
     summary: 'Isolated Agent homes, config profiles, and setup bundles.',
-    detail: 'Profiles isolate Agent state. GoodVibes Agent exposes named homes, config profile pickers, profile-sync bundles, setup transfer bundles, and support bundles while keeping the shared runtime external.',
+    detail: 'Profiles isolate Agent state. GoodVibes Agent exposes named homes, starter templates, and config profile pickers while keeping the shared runtime external.',
     actions: [
       { id: 'profiles-open', label: 'Open config profiles', detail: 'Open the 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 Agent TUI.', command: '/agent-profile guide', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-templates', label: 'Browse starter templates', detail: 'List built-in and local Agent starter templates with persona, skill, routine, and source details.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
-      { id: 'profile-sync-list', label: 'Profile sync list', detail: 'Inspect saved config profiles available for export/import.', command: '/profilesync list', kind: 'command', safety: 'read-only' },
-      { id: 'profile-sync-export', label: 'Export profile sync', detail: 'Export config profiles to a portable bundle. Requires a real path and explicit --yes.', command: '/profilesync export <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'setup-transfer-export', label: 'Export setup transfer', detail: 'Export Agent setup transfer data from the current home. Requires a real path and explicit --yes.', command: '/setup transfer export <path> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-list', label: 'List Agent profiles', detail: 'List isolated Agent profile homes under this Agent home.', command: '/agent-profile list', kind: 'command', safety: 'read-only' },
+      { id: 'runtime-profile-template-export', label: 'Export starter template', detail: 'Export a starter template JSON file. Requires a real starter id, path, and explicit --yes.', command: '/agent-profile template export <id> <path> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-template-import', label: 'Import starter template', detail: 'Import a reviewed starter template JSON file into this Agent home. Requires a real path and explicit --yes.', command: '/agent-profile template import <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-create', label: 'Create Agent profile', detail: 'Open an in-workspace form that creates an isolated Agent home from a built-in or local starter.', editorKind: 'profile', kind: 'editor', safety: 'safe' },
       { id: 'runtime-profile-template-edit', label: 'Customize starter', detail: 'Export a starter JSON file, edit it, import it as a local starter, then create a profile from it.', command: '/agent-profile template export <id> <path> --yes', kind: 'command', safety: 'safe' },
       { id: 'runtime-profile-switch', label: 'Switch Agent profile', detail: 'Launch goodvibes-agent --agent-profile <name> to use that isolated Agent home. This workspace cannot switch the current process home after startup.', kind: 'guidance', safety: 'safe' },

package/src/input/agent-workspace-setup.ts

@@ -40,7 +40,7 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
       label: 'GoodVibes runtime',
       status: 'ready',
       detail: `Agent will connect to ${input.daemonBaseUrl}; runtime ownership stays outside this product.`,
-      command: '/status',
+      command: '/health',
     },
     {
       id: 'provider-model',

package/src/input/commands/agent-skills-runtime.ts

@@ -238,6 +238,10 @@ function runBundleCommand(args: readonly string[], ctx: CommandContext, skillReg
 
 export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
   const sub = (args[0] ?? 'list').toLowerCase();
+  if (sub === 'local' || sub === 'agent') {
+    await runAgentSkillsRuntimeCommand(args.slice(1), ctx);
+    return;
+  }
   const skillRegistry = registryFromContext(ctx);
   try {
     if (sub === 'bundle' || sub === 'bundles') {
@@ -356,7 +360,7 @@ export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx:
 export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'agent-skills',
-    aliases: ['askills', 'local-skills'],
+    aliases: ['askills', 'local-skills', 'skills', 'skill'],
     description: 'Manage local GoodVibes Agent skills',
     usage: '[list|enabled|search <query>|show <id>|create --name <name> --description <summary> --procedure <steps>|update <id> [--name ...] [--description ...] [--procedure ...]|enable <id>|disable <id>|review <id>|stale <id> <reason...>|delete <id> --yes|bundle ...]',
     handler: runAgentSkillsRuntimeCommand,

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

@@ -103,9 +103,9 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           `  recent failures: ${settings.recentFailureCount}`,
           `  staged bundle: ${settings.hasStagedManagedBundle ? 'present' : 'none'}`,
           ...(issues.length > 0 ? issues.map((issue) => `  issue: ${issue}`) : ['  no active settings-control issues detected']),
-          '  next: /settingssync panel',
-          '  next: /settingssync show <key>',
-          '  next: /managed staged',
+          '  next: /settings',
+          '  next: /config <key>',
+          '  next: /health repair settings',
         ].join('\n'));
         return;
       }
@@ -131,8 +131,8 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           `  active connections: ${snapshot.activeConnections}`,
           `  degraded: ${snapshot.degradedConnections}`,
           ...(issues.length > 0 ? issues.map((issue) => `  issue: ${issue}`) : ['  no active remote recovery issues detected']),
-          '  next: /remote supervisor',
-          '  next: /remote recover <runnerId>',
+          '  next: /delegate <build/fix/review task> for explicit TUI build work',
+          '  next: use the external runtime host for remote worker repair',
         ].join('\n'));
         return;
       }
@@ -217,14 +217,14 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  domain: settings');
           lines.push(...(
             settings.conflicts.length > 0
-              ? ['  /settingssync panel', '  /settingssync show <key>', '  /managed staged']
+              ? ['  /settings', '  /config <key>', '  runtime-owned managed setting repair stays external']
               : ['  no active settings repair actions suggested']
           ));
           lines.push('  verify: /health settings');
         } else if (domain === 'auth') {
           lines.push('  domain: auth');
           lines.push('  /auth review');
-          lines.push('  /providers');
+          lines.push('  /provider');
           lines.push('  /subscription providers');
           lines.push('  runtime auth users/bootstrap cleanup: use the runtime-owning GoodVibes TUI or host tooling');
           lines.push('  verify: /health auth');
@@ -237,15 +237,13 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
           lines.push('  verify: /health accounts');
         } else if (domain === 'services') {
           lines.push('  domain: services');
-          lines.push('  /services doctor');
-          lines.push('  /services auth-review');
           lines.push('  /health services');
+          lines.push('  runtime service repair belongs to the external GoodVibes runtime host');
           lines.push('  verify: /health services');
         } else if (domain === 'remote') {
           lines.push('  domain: remote');
-          lines.push('  /remote supervisor');
-          lines.push('  /remote recover <runnerId>');
-          lines.push('  /remote setup');
+          lines.push('  /delegate <build/fix/review task> for explicit TUI build work');
+          lines.push('  remote runner setup and recovery belong to the external runtime host');
           lines.push('  verify: /health remote');
         } else if (domain === 'mcp') {
           lines.push('  domain: mcp');
@@ -262,9 +260,8 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         } else if (domain === 'maintenance') {
           lines.push('  domain: maintenance');
           lines.push('  /health maintenance');
-          lines.push('  /guidance review');
+          lines.push('  /mode');
           lines.push('  /compact');
-          lines.push('  /panel tokens');
           lines.push('  verify: /health maintenance');
         } else {
           lines.push('  domains: settings, auth, accounts, services, remote, mcp, continuity, maintenance');
@@ -329,7 +326,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         '  /health remote',
         '  /health maintenance',
         '  /health repair <domain>',
-        '  /setup onboarding',
+        '  /onboarding',
       ].join('\n'));
     },
   });

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

@@ -202,7 +202,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
               ...needingAttention.map((server) => (
                 `  ${server.name}  connected=${server.connected ? 'yes' : 'no'}  freshness=${server.schemaFreshness}  trust=${server.trustMode}`
               )),
-              '  next: /services auth-review',
+              '  next: /auth review',
               '  next: /mcp repair <server>',
             ].join('\n')
           : 'MCP Auth Review\n  No MCP servers currently need auth or quarantine recovery.');
@@ -223,7 +223,7 @@ export function registerMcpRuntimeCommands(registry: CommandRegistry): void {
           selected.schemaFreshness === 'quarantined'
             ? `/mcp quarantine ${selected.name} approve operator --yes`
             : null,
-          !selected.connected ? '/services auth-review' : null,
+          !selected.connected ? '/auth review' : null,
           '/mcp review',
           '/health review',
         ].filter((entry): entry is string => entry !== null);

package/src/input/commands/session-workflow.ts

@@ -264,7 +264,7 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           ctx.print(`  Reopened panels: ${reopenedPanels.join(', ')}`);
         }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
-          ctx.print(`  Remote re-entry: /remote recover ${meta.returnContext.remoteRunners![0]}`);
+          ctx.print('  Remote re-entry: use the external runtime host for remote runner recovery; delegate explicit build/fix/review recovery from Agent.');
         }
         if ((meta.returnContext.worktreePaths?.length ?? 0) > 0) {
           ctx.print('  Worktree re-entry: open GoodVibes TUI in the target workspace; delegate explicit build/fix/review recovery from Agent.');

package/src/panels/approval-panel.ts

@@ -20,7 +20,7 @@ const APPROVAL_ROWS = [
   ['network', 'why prompted: external hosts, fetch scope, egress policy', 'review via /approval review network'],
   ['delegate', 'why prompted: recursive agents, spawn ceilings, write-set inheritance', 'review via /approval review delegate'],
   ['mcp', 'why prompted: trust escalation, host scope, path scope, coherence mismatch', 'review via /mcp trust and /security'],
-  ['remote', 'why prompted: runner trust, remote write scope, artifact requirements', 'review via /remote and delegated TUI execution context'],
+  ['remote', 'why prompted: runner trust, remote write scope, artifact requirements', 'review delegated TUI execution context'],
   ['hook', 'why prompted: deny/mutate authority, blocking behavior, runner provenance', 'review via /hooks and /security'],
   ['plugin', 'why prompted: install/update lifecycle, provenance, capability grants', 'review via /marketplace and /security'],
 ] as const;

package/src/panels/automation-control-panel.ts

@@ -88,7 +88,7 @@ export class AutomationControlPanel extends ScrollableListPanel<AutomationRun> {
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
     return [
       { command: '/schedule list', summary: 'inspect jobs and run history without mutating schedules' },
-      { command: '/automation jobs', summary: 'review runtime-owned automation jobs from Agent' },
+      { command: '/schedule receipts', summary: 'review Agent routine promotion receipts' },
     ];
   }
 

package/src/panels/provider-account-snapshot.ts

@@ -217,7 +217,7 @@ export async function buildProviderAccountSnapshot(
     }
     if (hasServiceOAuth && !serviceOauth?.usable) {
       issues.push('Service OAuth is configured but missing a usable credential.');
-      recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /services or /settings.`);
+      recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /settings or the external runtime host.`);
     }
 
     return {

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

@@ -55,8 +55,8 @@ export function buildProviderHealthDomainSummaries(
       auth.bootstrapCredentialPresent ? 'Runtime bootstrap cleanup must be done from the runtime-owning TUI or host tooling.' : '',
     ].filter(Boolean),
     nextSteps: auth.bootstrapCredentialPresent
-      ? ['/auth review', '/providers', '/subscription providers']
-      : ['/auth review', '/providers'],
+      ? ['/auth review', '/provider', '/subscription providers']
+      : ['/auth review', '/provider'],
   });
 
   const settingIssueCount = settings.conflictCount + settings.recentFailureCount + (settings.hasStagedManagedBundle ? 1 : 0);
@@ -68,7 +68,7 @@ export function buildProviderHealthDomainSummaries(
       : settingIssueCount > 0
         ? `${settings.conflictCount} conflicts / ${settings.recentFailureCount} failures${settings.hasStagedManagedBundle ? ' / staged bundle' : ''}`
         : 'settings runtime API clean',
-    next: settingIssueCount > 0 ? '/settingssync panel' : '/settingssync show <key>',
+    next: settingIssueCount > 0 ? '/settings' : '/config <key>',
     details: [
       settings.conflictCount > 0 ? `${settings.conflictCount} unresolved import conflict(s)` : '',
       settings.recentFailureCount > 0 ? `${settings.recentFailureCount} recent sync or managed failure(s)` : '',
@@ -76,8 +76,8 @@ export function buildProviderHealthDomainSummaries(
       settings.managedLockCount > 0 ? `${settings.managedLockCount} managed lock(s) enforced` : '',
     ].filter(Boolean),
     nextSteps: settingIssueCount > 0
-      ? ['/settingssync panel', '/settingssync show <key>', '/managed staged']
-      : ['/settingssync show <key>'],
+      ? ['/settings', '/config <key>', '/health settings']
+      : ['/config <key>'],
   });
 
   summaries.push({
@@ -86,7 +86,7 @@ export function buildProviderHealthDomainSummaries(
     summary: remote.supervisor.sessions.length === 0
       ? 'no remote sessions tracked'
       : `${remote.supervisor.sessions.length} sessions / ${remote.supervisor.degradedConnections} degraded`,
-    next: remote.supervisor.degradedConnections > 0 ? '/remote recover <workerId>' : '/remote supervisor',
+    next: remote.supervisor.degradedConnections > 0 ? '/delegate <build/fix/review task>' : '/health remote',
     details: remote.supervisor.sessions.length === 0
       ? ['no remote sessions have been attached yet']
       : remote.supervisor.sessions
@@ -99,8 +99,8 @@ 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 <workerId>', '/remote support']
-      : ['/remote supervisor'],
+      ? ['/delegate <build/fix/review task>', '/health remote']
+      : ['/health remote'],
   });
 
   const degradedServers = security.mcpServers.filter((server) =>
@@ -141,7 +141,7 @@ export function buildProviderHealthDomainSummaries(
         ? 'warn'
         : 'good',
     summary: maintenance.summary,
-    next: maintenance.nextSteps[0] ?? '/guidance review',
+    next: maintenance.nextSteps[0] ?? '/health maintenance',
     details: maintenance.reasons.slice(0, 3),
     nextSteps: maintenance.nextSteps,
   });

package/src/panels/session-browser-panel.ts

@@ -266,7 +266,7 @@ export class SessionBrowserPanel extends BasePanel {
             ...formatReturnContextLines(selected.returnContext).map((line) =>
               buildPanelLine(width, [[' ', DEFAULT_PANEL_PALETTE.dim], [truncateDisplay(line, Math.max(0, width - 2)), DEFAULT_PANEL_PALETTE.dim]])
             ),
-            buildPanelLine(width, [[' Next ', DEFAULT_PANEL_PALETTE.label], [selected.returnContext?.remoteRunners?.length ? `/remote recover ${selected.returnContext.remoteRunners[0]}` : '/session resume', DEFAULT_PANEL_PALETTE.dim]]),
+            buildPanelLine(width, [[' Next ', DEFAULT_PANEL_PALETTE.label], ['/session resume', DEFAULT_PANEL_PALETTE.dim]]),
           ],
         }
       : { title: 'Selected', lines: [] };

package/src/panels/session-maintenance.ts

@@ -76,13 +76,13 @@ export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput):
     level = 'needs-repair';
     summary = `Compact now to recover context headroom (${usagePct}% used).`;
     reasons.push(`Context pressure is high at ${usagePct}% usage.`);
-    nextSteps.push('/compact', '/panel tokens');
+    nextSteps.push('/compact', '/context');
     compactRecommended = true;
   } else if (usagePct >= thresholdPct || remainingTokens <= 15_000) {
     level = 'suggest-compact';
     summary = `Watch context growth (${usagePct}% used).`;
     reasons.push(`Context pressure is climbing at ${usagePct}% usage.`);
-    nextSteps.push('/panel tokens');
+    nextSteps.push('/context');
     compactRecommended = true;
   } else if (usagePct >= 70 || staleByMessageGrowth) {
     level = 'watch';
@@ -92,7 +92,7 @@ export function evaluateSessionMaintenance(input: PanelSessionMaintenanceInput):
     reasons.push(staleByMessageGrowth
       ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
       : `Context usage is climbing toward the ${thresholdPct}% maintenance threshold.`);
-    nextSteps.push('/panel tokens');
+    nextSteps.push('/context');
   } else {
     reasons.push('Context pressure is currently within the stable operating band.');
   }

package/src/panels/subscription-panel.ts

@@ -80,7 +80,7 @@ export class SubscriptionPanel extends ScrollableListPanel<SubscriptionRow> {
     return [
       { command: '/subscription login openai start --yes', summary: 'start the first-class OpenAI subscription flow' },
       { command: '/login provider <name> start --yes', summary: 'use the front-door auth flow for supported providers' },
-      { command: '/services auth-review', summary: 'inspect configured service auth posture and stored secrets' },
+      { command: '/auth review', summary: 'inspect runtime auth posture without exposing token values' },
     ];
   }
 

package/src/renderer/agent-workspace.ts

@@ -232,7 +232,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       });
     }
     base.push({ text: 'Only config key names and readiness state are rendered here.', fg: PALETTE.muted });
-    base.push({ text: 'Pairing: use /pair or /qrcode; inspect routed activity with /communication and /setup review.', fg: PALETTE.info });
+    base.push({ text: 'Pairing: use /pair or /qrcode; inspect notification targets with /notify list and health with /health review.', fg: PALETTE.info });
   } else if (category.id === 'knowledge') {
     base.push(
       { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },

package/src/renderer/help-overlay.ts

@@ -69,21 +69,23 @@ export function renderHelpOverlay(
   // Each entry is [commandName, subcommandOrArgHint, description].
   // Commands not registered in the live registry are omitted at render time.
   const FEATURED_COMMANDS: Array<[name: string, argHint: string, desc: string]> = [
-    ['onboarding',   '',           'Open the onboarding wizard with current settings preloaded'],
-    ['cockpit',      '',           'Unified runtime control room'],
-    ['settings',     '',           'Settings and config browser'],
+    ['agent',        '',           'Open the Agent operator workspace'],
+    ['onboarding',   '',           'Open Agent setup with current settings preloaded'],
+    ['knowledge',    'status',     'Inspect isolated Agent Knowledge readiness'],
+    ['memory',       '',           'Manage local Agent memory records'],
+    ['personas',     '',           'Manage serial Agent operating personas'],
+    ['agent-skills', '',           'Manage local Agent skills and bundles'],
+    ['routines',     '',           'Manage reusable main-conversation routines'],
+    ['workplan',     '',           'Inspect shared work-plan state'],
+    ['approval',     '',           'Review and explicitly act on approvals'],
+    ['schedule',     '',           'Inspect schedules and routine promotion receipts'],
+    ['delegate',     '',           'Explicitly hand build/fix/review work to GoodVibes TUI'],
+    ['mcp',          '',           'Inspect MCP servers and tool readiness'],
     ['provider',     '',           'Choose provider or model family'],
+    ['model',        '',           'Select the active model route'],
     ['subscription', '',           'Review provider logins and subscriptions'],
-    ['marketplace',  'open',       'Browse plugins, skills, and packs'],
-    ['remote',       'setup',      'Review remote, bridge, and tunnel flows'],
-    ['security',     '',           'Security review workspace'],
-    ['policy',       '',           'Simulation, lint, and preflight review'],
-    ['incident',     '',           'Incident workspace and export flows'],
-    ['knowledge',    '',           'Durable knowledge and review queue'],
-    ['hooks',        '',           'Hook workbench and runtime activity'],
-    ['orchestration','',           'Graph and recursive-agent control room'],
-    ['communication','',           'Structured agent communication workspace'],
-    ['tasks',        '',           'Read-only task view for list/show/pause/resume/output'],
+    ['secrets',      '',           'Manage secret references without printing values'],
+    ['health',       '',           'Run Agent runtime and setup diagnostics'],
   ];
 
   // Build command rows from featured list, filtering out unregistered commands.
@@ -115,7 +117,29 @@ export function renderHelpOverlay(
 
   if (commands && commands.length > 0) {
     commandRows.push('', '  Available Slash Commands', '  ' + '\u2500'.repeat(40));
-    const preferred = ['setup', 'cockpit', 'settings', 'provider', 'subscription', 'marketplace', 'remote', 'security', 'policy', 'incident', 'knowledge', 'hooks', 'orchestration', 'communication', 'tasks'];
+    const preferred = [
+      'agent',
+      'onboarding',
+      'knowledge',
+      'memory',
+      'personas',
+      'agent-skills',
+      'routines',
+      'workplan',
+      'approval',
+      'schedule',
+      'delegate',
+      'mcp',
+      'provider',
+      'model',
+      'subscription',
+      'secrets',
+      'health',
+      'settings',
+      'security',
+      'policy',
+      'tasks',
+    ];
     const seen = new Set<string>();
     for (const name of preferred) {
       const cmd = commands.find((entry) => entry.name === name);

package/src/renderer/settings-modal.ts

@@ -148,7 +148,7 @@ function buildSettingContext(modal: SettingsModal, entry: SettingEntry): string[
   ];
 
   if (entry.locked) lines.push(`Locked: ${entry.lockReason ?? 'This setting is locked by a higher-priority layer.'}`);
-  if (entry.conflict) lines.push(`Conflict: resolve with /settingssync resolve ${entry.setting.key} local|synced.`);
+  if (entry.conflict) lines.push(`Conflict: inspect with /settings and resolve runtime-owned sync state in the external host.`);
 
   lines.push('', entry.setting.description);
 

package/src/runtime/bootstrap-hook-bridge.ts

@@ -74,7 +74,7 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
           options.conversation.log(`Resume: Reopened panels: ${reopenedPanels.join(', ')}`, { fg: '244' });
         }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
-          options.conversation.log(`Resume: Remote re-entry -> /remote recover ${meta.returnContext.remoteRunners![0]}`, { fg: '244' });
+          options.conversation.log('Resume: Remote re-entry belongs to the external runtime host; delegate explicit build/fix/review recovery from Agent.', { fg: '244' });
         }
         if (returnContextMode === 'assisted') {
           const helperModel = new HelperModel({

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.88';
+let _version = '0.1.90';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {