@pellux/goodvibes-agent 0.1.64 → 0.1.66

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.66 - 2026-05-31
+
+- Removed remote-runner and node/device posture wording from first-run Agent setup surfaces.
+- Replaced the blocked remote-runner workspace action with a read-only build-delegation status action.
+- Added onboarding/workspace regressions to keep visible setup focused on Agent features instead of copied runner internals.
+
+## 0.1.65 - 2026-05-31
+
+- Made the operator workspace more product-facing by replacing foundation/setup jargon with Agent profile, runtime status, voice/media, and browser-tool language.
+- Removed the remote-runner item from the first-run voice/media workspace so day-one setup stays focused on user-facing assistant capabilities.
+- Reworded settings, status panels, profile commands, and docs away from control-plane/runtime-profile terminology while preserving the same underlying contracts.
+
 ## 0.1.64 - 2026-05-31
 
 - Cleaned remaining visible setup, workspace, panel, and auth wording that still exposed copied runtime-host terminology.

package/README.md

@@ -52,9 +52,9 @@ bun run publish:check
 
 Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator workspace. It is the Agent-first fullscreen surface for setup, status, knowledge, local memory/skills, work-plan/approval review, automation observability, and explicit build delegation to GoodVibes TUI.
 
-Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated runtime profiles from them.
+Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated Agent profiles from them.
 
-Use isolated Agent runtime profiles when one machine needs separate operator identities or local state:
+Use isolated Agent profiles when one machine needs separate operator identities or local state:
 
 ```sh
 goodvibes-agent profiles templates
@@ -113,4 +113,4 @@ Package-facing docs are intentionally narrow during the near-fork baseline:
 - [Deployment And Services](docs/deployment-and-services.md)
 - [Release And Publishing](docs/release-and-publishing.md)
 
-Broader TUI-derived reference docs may exist in the source tree while the near-fork foundation is being completed, but the package-facing Agent documentation is limited to the docs listed above.
+Broader foundation reference docs may exist in the source tree while the near-fork foundation is being completed, but the package-facing Agent documentation is limited to the docs listed above.

package/docs/getting-started.md

@@ -56,7 +56,7 @@ Use a separate Agent home when you want isolated local state:
 GOODVIBES_AGENT_HOME=/path/to/agent-home goodvibes-agent status
 ```
 
-Use named runtime profiles for repeatable local identities:
+Use named Agent profiles for repeatable local identities:
 
 ```sh
 goodvibes-agent profiles templates
@@ -103,4 +103,4 @@ Agent lifecycle commands that would start or mutate runtime posture are blocked
 
 ## Current Baseline Notes
 
-This repository keeps broad TUI-derived foundation code intentionally so Agent can use the mature terminal shell, renderer, input, fullscreen workspace, command registry, and release bones. The active Agent policy is serial/proactive by default, blocks local Agent-owned WRFC/spawn fanout, and delegates explicit build/fix/review work to GoodVibes TUI instead of turning the Agent into a coding TUI.
+This repository keeps broad terminal foundation code intentionally so Agent can use the mature shell, renderer, input, fullscreen workspace, command registry, and release bones. The active Agent policy is serial/proactive by default, blocks local Agent-owned WRFC/spawn fanout, and delegates explicit build/fix/review work to GoodVibes TUI instead of turning the Agent into a coding TUI.

package/docs/release-and-publishing.md

@@ -57,4 +57,4 @@ Do not ship runtime host binaries from this package. If Agent later gets compile
 
 ## Near-Fork Baseline Rule
 
-The public alpha can include copied TUI foundation code, but package-facing behavior must follow Agent product policy. Follow-up work should continue pruning or reshaping copied coding-first surfaces while preserving the TUI-derived renderer, input, fullscreen workspace, command registry, and release bones.
+The public alpha can include copied terminal foundation code, but package-facing behavior must follow Agent product policy. Follow-up work should continue pruning or reshaping copied coding-first surfaces while preserving the renderer, input, fullscreen workspace, command registry, and release bones.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "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/help.ts

@@ -36,7 +36,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  onboarding [status]        Open Agent onboarding, or print onboarding status',
     '  models [provider]          List/use/pin selectable models and recent model history',
     '  providers                  List/inspect/use provider config/auth posture',
-    '  profiles                   Manage isolated Agent runtime profile homes',
+    '  profiles                   Manage isolated Agent profile homes',
     '  routines                   Inspect local routines and explicitly promote one to an external schedule',
     '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
     '  compat                     Inspect Agent SDK pin, runtime version, and Agent knowledge route readiness',
@@ -56,7 +56,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     'Options:',
     '  -m, --model <registryKey>       Override model. provider:model infers --provider',
     '      --provider <id>            Override provider',
-    '      --agent-profile <name>     Use an isolated Agent runtime profile home',
+    '      --agent-profile <name>     Use an isolated Agent profile home',
     '  -C, --cd <dir>                 Set working directory for this launch',
     '      --working-dir <dir>        Alias for --cd',
     '  -c, --config <key=value>       Override a config value for this launch',
@@ -141,7 +141,7 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
   },
   profiles: {
     usage: ['profiles list', 'profiles templates', 'profiles templates export <id> <path> --yes', 'profiles templates import <path> --yes', 'profiles show <name>', 'profiles create <name> [--template <id>] --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
-    summary: 'Create and inspect isolated Agent runtime profile homes, with starter templates for household, research, travel, operations, personal productivity, and local imported starters. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the shared GoodVibes runtime.',
+    summary: 'Create and inspect isolated Agent profile homes, with starter templates for household, research, travel, operations, personal productivity, and local imported starters. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the shared GoodVibes runtime.',
     examples: ['profiles templates', 'profiles templates export research ./research-starter.json --yes', 'profiles templates import ./research-starter.json --yes', 'profiles create household --template household --yes', '--agent-profile household status'],
   },
   routines: {

package/src/cli/management-commands.ts

@@ -328,12 +328,12 @@ export async function buildControlPlaneStatusResult(runtime: CliCommandRuntime):
     restartOnFailure: runtime.configManager.get('service.restartOnFailure'),
   };
   const issues: string[] = [];
-  if (enabled === true && !reachable) issues.push(`Control plane is enabled but not reachable on ${binding.host}:${binding.port}.`);
-  if (enabled === true && service.enabled !== true) issues.push('Control plane is enabled on the external runtime config, but Agent service ownership is disabled.');
-  if (enabled === true && service.autostart !== true) issues.push('Control plane is enabled on the external runtime config, but autostart is off.');
-  if (enabled === true && service.restartOnFailure !== true) issues.push('Control plane is enabled on the external runtime config, but restart-on-failure is off.');
-  if (isNetworkFacing(enabled, binding) && !auth.userStorePresent) issues.push('Network-facing control plane has no local auth user store.');
-  if (isNetworkFacing(enabled, binding) && auth.bootstrapCredentialPresent) issues.push('Network-facing control plane still has a bootstrap credential file.');
+  if (enabled === true && !reachable) issues.push(`Runtime API is enabled but not reachable on ${binding.host}:${binding.port}.`);
+  if (enabled === true && service.enabled !== true) issues.push('Runtime API is enabled on the external runtime config, but Agent service ownership is disabled.');
+  if (enabled === true && service.autostart !== true) issues.push('Runtime API is enabled on the external runtime config, but autostart is off.');
+  if (enabled === true && service.restartOnFailure !== true) issues.push('Runtime API is enabled on the external runtime config, but restart-on-failure is off.');
+  if (isNetworkFacing(enabled, binding) && !auth.userStorePresent) issues.push('Network-facing Runtime API has no local auth user store.');
+  if (isNetworkFacing(enabled, binding) && auth.bootstrapCredentialPresent) issues.push('Network-facing Runtime API still has a bootstrap credential file.');
   return {
     enabled,
     ...binding,
@@ -347,7 +347,7 @@ export async function buildControlPlaneStatusResult(runtime: CliCommandRuntime):
 
 export function formatControlPlaneStatus(runtime: CliCommandRuntime, value: ControlPlaneStatusResult): string {
   return formatJsonOrText(runtime.cli)(value, [
-    'GoodVibes control-plane status',
+    'GoodVibes runtime API status',
     `  enabled: ${yesNo(value.enabled)}`,
     `  bind: ${value.hostMode} ${value.host}:${value.port}`,
     `  bind posture: ${value.posture.label}`,

package/src/cli/profiles-command.ts

@@ -63,9 +63,9 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
   if (!result.ok) return result.error ?? 'Agent profile command failed.';
   if (result.kind === 'agent.profiles.list') {
     const profiles = result.data?.profiles ?? [];
-    if (profiles.length === 0) return 'No Agent runtime profiles. Use: goodvibes-agent profiles create <name> --template <id> --yes';
+    if (profiles.length === 0) return 'No Agent profiles. Use: goodvibes-agent profiles create <name> --template <id> --yes';
     return [
-      `Agent runtime profiles (${profiles.length})`,
+      `Agent profiles (${profiles.length})`,
       ...profiles.map(profileLine),
     ].join('\n');
   }
@@ -103,7 +103,7 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
   if (result.kind === 'agent.profiles.create' && profile) {
     const template = result.data?.appliedTemplate;
     return [
-      `Agent runtime profile created: ${profile.id}`,
+      `Agent profile created: ${profile.id}`,
       `  home: ${profile.homeDirectory}`,
       ...(template ? [
         `  starter: ${template.id} (${template.name})`,
@@ -113,7 +113,7 @@ function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string
     ].join('\n');
   }
   if (result.kind === 'agent.profiles.delete' && profile) {
-    return `Agent runtime profile deleted: ${profile.id}`;
+    return `Agent profile deleted: ${profile.id}`;
   }
   return 'Agent profile command completed.';
 }
@@ -242,7 +242,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         data: { profile: info },
       };
       const starter = info.starterTemplateId ? [`  starter: ${info.starterTemplateId} (${info.starterTemplateName ?? info.starterTemplateId})`] : [];
-      const text = [`Agent runtime profile: ${profile.id}`, `  home: ${profile.homeDirectory}`, ...starter, `  use: goodvibes-agent --agent-profile ${profile.id}`].join('\n');
+      const text = [`Agent profile: ${profile.id}`, `  home: ${profile.homeDirectory}`, ...starter, `  use: goodvibes-agent --agent-profile ${profile.id}`].join('\n');
       return {
         output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(result, null, 2) : text,
         exitCode: 0,
@@ -266,7 +266,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         const result: AgentRuntimeProfileCommandResult = {
           ok: false,
           kind: 'agent.profiles.error',
-          error: `Refusing to create Agent runtime profile ${name} without --yes.`,
+          error: `Refusing to create Agent profile ${name} without --yes.`,
         };
         return {
           output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
@@ -307,7 +307,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         const result: AgentRuntimeProfileCommandResult = {
           ok: false,
           kind: 'agent.profiles.error',
-          error: `Refusing to delete Agent runtime profile ${name} without --yes.`,
+          error: `Refusing to delete Agent profile ${name} without --yes.`,
         };
         return {
           output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
@@ -325,7 +325,7 @@ export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Pr
         : {
           ok: false,
           kind: 'agent.profiles.error',
-          error: `Agent runtime profile not found: ${resolution.id}`,
+          error: `Agent profile not found: ${resolution.id}`,
       };
       return {
         output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),

package/src/cli/routines-command.ts

@@ -62,7 +62,7 @@ function renderRoutineList(title: string, path: string, routines: readonly Agent
     return [
       title,
       '  No local Agent routines yet.',
-      '  Create routines inside the Agent TUI with /routines create, or create a runtime profile from a starter template.',
+      '  Create routines inside the Agent TUI with /routines create, or create an Agent profile from a starter template.',
     ].join('\n');
   }
   return [

package/src/cli/service-posture.ts

@@ -61,7 +61,7 @@ export interface CliServicePosture {
 }
 
 const ENDPOINTS: readonly { readonly id: RuntimeEndpointId; readonly label: string; readonly enabledKey: string }[] = [
-  { id: 'controlPlane', label: 'control plane', enabledKey: 'controlPlane.enabled' },
+  { id: 'controlPlane', label: 'runtime API', enabledKey: 'controlPlane.enabled' },
   { id: 'httpListener', label: 'HTTP listener', enabledKey: 'danger.httpListener' },
   { id: 'web', label: 'web surface', enabledKey: 'web.enabled' },
 ];

package/src/cli/status.ts

@@ -110,7 +110,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
   const marker = options.onboardingMarkers?.effective;
   const serverBackedEnabled = daemonEnabled || controlPlaneEnabled || listenerEnabled || webEnabled;
   const networkFacingSurfaces = [
-    ['control plane', controlPlaneEnabled, controlPlaneBinding],
+    ['runtime API', controlPlaneEnabled, controlPlaneBinding],
     ['HTTP listener', listenerEnabled, httpListenerBinding],
     ['web surface', webEnabled, webBinding],
   ].filter(([, enabled, binding]) => isNetworkFacing(enabled, binding as typeof controlPlaneBinding));
@@ -123,7 +123,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       area: 'service',
       severity: 'warning',
       summary: 'Host-owned surfaces are configured while Agent service ownership is disabled.',
-      cause: 'One or more runtime, control-plane, listener, or web settings are enabled while service.enabled is false.',
+      cause: 'One or more runtime API, listener, or web settings are enabled while service.enabled is false.',
       impact: 'The external GoodVibes runtime must own availability for those surfaces; Agent will not start or enable them.',
       action: 'Manage surface/service posture from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
     });
@@ -162,7 +162,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         severity: 'warning',
         summary: issue,
         cause: 'The service lifecycle inspection found a mismatch between configured service/surface state and observed host state.',
-        impact: 'Runtime, control-plane, listener, or web availability may not match the configuration.',
+        impact: 'Runtime API, listener, or web availability may not match the configuration.',
         action: 'Use goodvibes-agent service check for read-only detail, then manage the runtime from GoodVibes TUI or your host tooling.',
       });
     }

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

@@ -6,7 +6,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     group: 'OPERATE',
     label: 'Home',
     summary: 'Main operator surface for normal assistant work.',
-    detail: 'Use this as the Agent front door: chat in the main conversation, inspect state, choose model/provider, and open setup surfaces without switching into coding-TUI behavior.',
+    detail: 'Use this as the Agent front door: chat in the main conversation, inspect state, choose model/provider, and open setup without switching modes.',
     actions: [
       { id: 'chat', label: 'Continue assistant chat', detail: 'Close this workspace and type a normal message. Agent work stays serial in the main conversation.', kind: 'guidance', safety: 'safe' },
       { id: 'model', label: 'Choose model', detail: 'Open the model/provider workspace for the Agent chat route.', command: '/model', kind: 'command', safety: 'safe' },
@@ -14,7 +14,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'knowledge-home', label: 'Agent Knowledge', detail: 'Jump to isolated Agent Knowledge status, ingest, search, and review flows.', targetCategoryId: 'knowledge', kind: 'workspace', safety: 'read-only' },
       { id: 'memory-home', label: 'Memory, skills, routines', detail: 'Jump to local memory, persona, skill, and routine setup. These are core Agent product features.', targetCategoryId: 'memory', kind: 'workspace', safety: 'safe' },
       { id: 'channels-home', label: 'Channels', detail: 'Jump to companion pairing and channel readiness without changing runtime connectivity.', targetCategoryId: 'channels', kind: 'workspace', safety: 'read-only' },
-      { id: 'voice-home', label: 'Voice and media', detail: 'Jump to voice, TTS, image input, browser, and node posture setup.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
+      { id: 'voice-home', label: 'Voice and media', detail: 'Jump to voice, TTS, image input, browser-tool, and media setup.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
       { id: 'help', label: 'Browse commands', detail: 'Open registry-driven command help.', command: '/help', kind: 'command', safety: 'safe' },
       { id: 'health', label: 'Review health', detail: 'Show the local health review surface without starting or mutating runtime services.', command: '/health review', kind: 'command', safety: 'read-only' },
     ],
@@ -26,11 +26,11 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     summary: 'Configuration, auth, provider, and onboarding surfaces.',
     detail: 'Agent connects to an existing GoodVibes runtime and owns local assistant configuration only. Runtime lifecycle and connectivity posture remain external.',
     actions: [
-      { id: 'config', label: 'Open config workspace', detail: 'Use the TUI-derived fullscreen settings workspace.', command: '/config', kind: 'command', safety: 'safe' },
-      { id: 'onboarding', label: 'Open setup wizard', detail: 'Review Agent runtime settings in the fullscreen setup flow.', command: '/onboarding', kind: 'command', safety: 'safe' },
+      { id: 'config', label: 'Open settings', detail: 'Open the fullscreen Agent settings workspace.', command: '/config', kind: 'command', safety: 'safe' },
+      { id: 'onboarding', label: 'Run setup', detail: 'Review Agent settings in the fullscreen setup flow.', command: '/onboarding', kind: 'command', safety: 'safe' },
       { id: 'setup-provider-model', label: 'Provider and model', detail: 'Choose the provider/model route for normal assistant chat.', command: '/model', kind: 'command', safety: 'safe' },
       { id: 'setup-agent-knowledge', label: 'Agent Knowledge', detail: 'Inspect the isolated Agent Knowledge store before ingesting source-backed material.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
-      { id: 'setup-runtime-profiles', label: 'Runtime profiles', detail: 'Browse starter templates for isolated Agent homes and operator identities.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
+      { id: 'setup-runtime-profiles', label: 'Agent profiles', detail: 'Browse starter templates for isolated Agent homes and operator identities.', command: '/agent-profile templates', kind: 'command', safety: 'read-only' },
       { id: 'setup-personas', label: 'Personas', detail: 'Create or select the active local Agent persona.', targetCategoryId: 'personas', kind: 'workspace', safety: 'safe' },
       { id: 'setup-skills', label: 'Skills', detail: 'Create, review, and enable reusable local Agent skills.', targetCategoryId: 'skills', kind: 'workspace', safety: 'safe' },
       { id: 'setup-routines', label: 'Routines', detail: 'Create, review, and enable local Agent routines before any explicit schedule promotion.', targetCategoryId: 'routines', kind: 'workspace', safety: 'safe' },
@@ -48,7 +48,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     summary: 'Companion pairing, channel posture, and delivery safety.',
     detail: 'Agent uses externally managed channel surfaces. 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 TUI-derived QR pairing surface for companion app setup.', command: '/pair', kind: 'command', safety: 'safe' },
+      { id: 'pair', label: 'Pair companion', detail: 'Open the QR pairing surface 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: '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' },
@@ -65,7 +65,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'knowledge-search', label: 'Search Agent knowledge', detail: 'Search the isolated Agent Knowledge index. Close this workspace and provide an actual query.', command: '/knowledge search <query>', kind: 'command', safety: 'read-only' },
       { id: 'knowledge-ingest-url', label: 'Ingest URL', detail: 'Ingest a URL into Agent Knowledge only. Requires an explicit --yes command with a real URL.', command: '/knowledge ingest-url <url> --yes', kind: 'command', safety: 'safe' },
       { id: 'knowledge-import-bookmarks', label: 'Import bookmarks', detail: 'Import a browser bookmark export into Agent Knowledge only. Requires an explicit --yes command with a real path.', command: '/knowledge import-bookmarks <path> --yes', kind: 'command', safety: 'safe' },
-      { id: 'knowledge-review-queue', label: 'Review queue', detail: 'Inspect source/node/issue review work before accepting, rejecting, or resolving anything.', command: '/knowledge queue', kind: 'command', safety: 'read-only' },
+      { id: 'knowledge-review-queue', label: 'Review queue', detail: 'Inspect source, item, and issue review work before accepting, rejecting, or resolving anything.', command: '/knowledge queue', kind: 'command', safety: 'read-only' },
       { id: 'knowledge-consolidation', label: 'Consolidation review', detail: 'Inspect consolidation candidates and reports before running Agent Knowledge mutations.', command: '/knowledge candidates', kind: 'command', safety: 'read-only' },
       { id: 'knowledge-ask', label: 'Ask Agent knowledge', detail: 'Close this workspace and run /knowledge ask <question> or ask normally in chat.', kind: 'guidance', safety: 'read-only' },
     ],
@@ -73,35 +73,34 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
   {
     id: 'voice-media',
     group: 'SETUP',
-    label: 'Voice, Media & Nodes',
-    summary: 'Voice, TTS, image input, browser surface, and node/remote posture.',
-    detail: 'Voice, media, browser, and node surfaces are first-class operator surfaces. Agent uses the GoodVibes voice/media/provider/browser/remote bones while keeping runtime ownership external and side effects explicit.',
+    label: 'Voice & Media',
+    summary: 'Voice, TTS, image input, browser tools, and media providers.',
+    detail: 'Voice, media, browser tools, and image-capable flows are first-class Agent surfaces. Runtime ownership stays external and side effects stay 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-config', label: 'Configure live TTS', detail: 'Open the settings workspace at the TTS 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' },
       { id: 'tts-speak', label: 'Speak a prompt', detail: 'Submit a normal assistant turn and play the reply through configured live TTS. Close this workspace and provide real prompt text.', command: '/tts <prompt>', kind: 'command', safety: 'safe' },
       { id: 'image-attach', label: 'Attach image input', detail: 'Attach an image to the next assistant turn. Close this workspace and provide a real path and prompt.', command: '/image <path> <prompt>', kind: 'command', safety: 'safe' },
-      { id: 'browser-surface', label: 'Browser surface status', detail: 'Inspect browser/web posture through setup diagnostics without starting inbound endpoints or runtime services.', command: '/setup services', kind: 'command', safety: 'read-only' },
+      { id: 'browser-tools', label: 'Browser tools', detail: 'Inspect browser/tool readiness without starting inbound endpoints or runtime services.', command: '/setup services', kind: 'command', safety: 'read-only' },
       { id: 'mcp-browser', label: 'Browser MCP tools', detail: 'Inspect MCP servers and tools, including browser/automation roles, without mutating server setup.', command: '/mcp servers', kind: 'command', safety: 'read-only' },
-      { id: 'node-posture', label: 'Node/remote posture', detail: 'Inspect remote runner/node posture. Dispatch remains blocked unless the task is explicit build delegation to TUI.', command: '/remote list', kind: 'command', safety: 'read-only' },
     ],
   },
   {
     id: 'profiles',
     group: 'SETUP',
-    label: 'Profiles & Portability',
+    label: 'Profiles',
     summary: 'Isolated Agent homes, config profiles, and setup bundles.',
-    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 shared runtime external.',
+    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.',
     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: '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 TUI command surface.', 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-create', label: 'Create runtime profile', detail: 'Create an isolated Agent runtime profile from a built-in or local starter. Requires a real name and explicit --yes.', command: '/agent-profile create <name> --template <id> --yes', kind: 'command', safety: 'safe' },
+      { id: 'runtime-profile-create', label: 'Create Agent profile', detail: 'Create an isolated Agent profile from a built-in or local starter. Requires a real name and explicit --yes.', command: '/agent-profile create <name> --template <id> --yes', kind: 'command', 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 runtime 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' },
+      { 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' },
     ],
   },
   {
@@ -213,7 +212,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'delegate-guidance', label: 'Delegation rule', detail: 'For build/fix/review work, delegate one request to GoodVibes TUI instead of spawning local Engineer/Reviewer/Tester roots.', kind: 'guidance', safety: 'delegates' },
       { id: 'review-command', label: 'Review delegation command', detail: 'Use /delegate --wrfc <task> only when the user explicitly asks for code review/build execution. Close this workspace and include the actual task text.', kind: 'guidance', safety: 'delegates' },
-      { id: 'remote-policy', label: 'Remote runner policy', detail: 'Remote dispatch/rerun is blocked in Agent; TUI owns runner topology for delegated build work.', command: '/remote dispatch', kind: 'command', safety: 'blocked' },
+      { id: 'delegation-status', label: 'Delegation status', detail: 'Inspect build-delegation receipts and shared-session status without starting coding work.', command: '/delegate status', kind: 'command', safety: 'read-only' },
     ],
   },
 ];

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

@@ -35,9 +35,9 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
   return [
     {
       id: 'runtime',
-      label: 'External runtime',
+      label: 'GoodVibes runtime',
       status: 'ready',
-      detail: `Agent will connect to ${input.daemonBaseUrl}; runtime ownership stays outside this TUI.`,
+      detail: `Agent will connect to ${input.daemonBaseUrl}; runtime ownership stays outside this product.`,
       command: '/status',
     },
     {
@@ -58,10 +58,10 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
     },
     {
       id: 'profile',
-      label: 'Runtime profile',
+      label: 'Agent profile',
       status: setupStatusForCount(input.runtimeProfileCount, 'ready', 'optional'),
       detail: input.runtimeProfileCount > 0
-        ? `${input.runtimeProfileCount} isolated runtime profile(s) are available.`
+        ? `${input.runtimeProfileCount} isolated Agent profile(s) are available.`
         : `${input.runtimeStarterTemplateCount} starter template(s) are available if this machine needs separate operator identities.`,
       command: '/agent-profile templates',
     },

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

@@ -43,12 +43,12 @@ function renderProfiles(homeDirectory: string): string {
   const profiles = listAgentRuntimeProfiles(homeDirectory);
   if (profiles.length === 0) {
     return [
-      'Agent Runtime Profiles',
-      '  No isolated Agent runtime profiles yet.',
+      'Agent Profiles',
+      '  No isolated Agent profiles yet.',
       '  Create one with /agent-profile create <name> --template <id> --yes.',
     ].join('\n');
   }
-  return ['Agent Runtime Profiles', ...profiles.map(profileLine)].join('\n');
+  return ['Agent Profiles', ...profiles.map(profileLine)].join('\n');
 }
 
 function renderTemplates(homeDirectory: string): string {
@@ -80,7 +80,7 @@ function renderGuide(homeDirectory: string): string {
     '3. Edit id, name, description, persona, skills, and routines in that JSON file.',
     '4. Import it into this Agent home:',
     '   /agent-profile template import ./agent-starter.json --yes',
-    '5. Create a runtime profile from the imported starter:',
+    '5. Create an Agent profile from the imported starter:',
     '   /agent-profile create <name> --template <imported-id> --yes',
     '',
     'This writes only Agent-local starter/profile state. It does not mutate the runtime host, default wiki, or non-Agent knowledge segments.',
@@ -107,7 +107,7 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
   registry.register({
     name: 'agent-profile',
     aliases: ['runtime-profile', 'agent-profiles'],
-    description: 'Manage isolated Agent runtime profiles and starter templates',
+    description: 'Manage isolated Agent profiles and starter templates',
     usage: '[list|templates|guide|template show|template export|template import|create|delete]',
     handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
@@ -187,12 +187,12 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
             return;
           }
           if (!parsed.yes) {
-            requireYesFlag(ctx, `create Agent runtime profile ${name}`, '/agent-profile create <name> [--template <id>] --yes');
+            requireYesFlag(ctx, `create Agent profile ${name}`, '/agent-profile create <name> [--template <id>] --yes');
             return;
           }
           const profile = createAgentRuntimeProfile(homeDirectory, name, { templateId });
           ctx.print([
-            `Agent runtime profile created: ${profile.id}`,
+            `Agent profile created: ${profile.id}`,
             `  home: ${profile.homeDirectory}`,
             profile.starterTemplateId ? `  starter: ${profile.starterTemplateId}` : '',
             `  launch: goodvibes-agent --agent-profile ${profile.id}`,
@@ -207,10 +207,10 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
             return;
           }
           if (!parsed.yes) {
-            requireYesFlag(ctx, `delete Agent runtime profile ${name}`, '/agent-profile delete <name> --yes');
+            requireYesFlag(ctx, `delete Agent profile ${name}`, '/agent-profile delete <name> --yes');
             return;
           }
-          ctx.print(deleteAgentRuntimeProfile(homeDirectory, name) ? `Agent runtime profile deleted: ${name}` : `Agent runtime profile not found: ${name}`);
+          ctx.print(deleteAgentRuntimeProfile(homeDirectory, name) ? `Agent profile deleted: ${name}` : `Agent profile not found: ${name}`);
           return;
         }
 

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

@@ -145,14 +145,14 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
   });
 
   registry.register({
-    name: 'runner-pool',
+    name: 'worker-pool',
     aliases: ['pool'],
-    description: 'Dedicated front-door for remote runner pool review and assignment flows',
+    description: 'Dedicated front-door for remote worker pool review flows',
     usage: '[list|show <id>|create <id> <label...>|assign <pool> <runner>|unassign <pool> <runner>]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'list').toLowerCase();
       if (!ctx.executeCommand) {
-        ctx.print('Runner pool controls are not available in this runtime.');
+        ctx.print('Remote worker pool controls are not available in this runtime.');
         return;
       }
       if (sub === 'list') {
@@ -171,7 +171,7 @@ export function registerExperienceRuntimeCommands(registry: CommandRegistry): vo
         await ctx.executeCommand('remote', ['pool', sub, args[1], args[2]]);
         return;
       }
-      ctx.print('Usage: /runner-pool [list|show <id>|create <id> <label...>|assign <pool> <runner>|unassign <pool> <runner>]');
+      ctx.print('Usage: /worker-pool [list|show <id>]');
     },
   });
 

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

@@ -317,7 +317,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
         `  settings conflicts: ${settingsSnapshot.conflicts.length}`,
         `  managed locks: ${settingsSnapshot.managedLockCount}`,
         `  local auth users: ${readModels.localAuth.getSnapshot().userCount}`,
-        `  remote runners: ${snapshot.remoteRunnerCount}`,
+        `  remote workers: ${snapshot.remoteRunnerCount}`,
         ...formatSessionMaintenanceLines(maintenance, 'guided').map((line) => `  ${line}`),
         ...(snapshot.issues.length > 0 ? ['', ...snapshot.issues.map((issue) => `  [${issue.severity.toUpperCase()}] ${issue.area}: ${issue.message}`)] : []),
         ...(snapshot.serviceIssues.length > 0 ? ['', ...snapshot.serviceIssues.map((issue) => `  service: ${issue}`)] : []),

package/src/input/commands/local-setup-review.ts

@@ -89,7 +89,7 @@ export async function buildSetupReviewSnapshot(ctx: CommandContext): Promise<Set
     {
       severity: remoteRunnerCount > 0 ? 'pass' : 'warn',
       area: 'remote',
-      message: remoteRunnerCount > 0 ? `${remoteRunnerCount} remote runner contract(s)` : 'no remote runner contracts registered',
+      message: remoteRunnerCount > 0 ? `${remoteRunnerCount} remote worker contract(s)` : 'no remote worker contracts registered',
     },
   ];
 

package/src/input/commands/local-setup-transfer.ts

@@ -56,7 +56,7 @@ export function inspectSetupTransferBundle(bundle: SetupTransferBundle): string
     `  services: ${bundle.startupReview.serviceCount}`,
     `  plugins: ${bundle.startupReview.pluginCount}`,
     `  skills: ${bundle.startupReview.skillCount}`,
-    `  remote runners: ${bundle.startupReview.remoteRunnerCount}`,
+    `  remote workers: ${bundle.startupReview.remoteRunnerCount}`,
     `  config keys: ${Object.keys(bundle.config ?? {}).length}`,
     `  curated plugins: ${ecosystemPluginCount}`,
     `  curated skills: ${ecosystemSkillCount}`,

package/src/input/commands/local-setup.ts

@@ -57,7 +57,7 @@ export function registerLocalSetupCommands(registry: CommandRegistry): void {
           `  mcp servers known: ${snapshot.mcpServerCount}`,
           `  mcp quarantined: ${snapshot.quarantinedMcpCount}`,
           `  mcp elevated: ${snapshot.elevatedMcpCount}`,
-          `  remote runners: ${snapshot.remoteRunnerCount}`,
+          `  remote workers: ${snapshot.remoteRunnerCount}`,
           '',
           `  service ids: ${snapshot.services.join(', ') || '(none)'}`,
           `  plugin dirs: ${snapshot.pluginDirectories.join(', ') || '(none)'}`,
@@ -111,7 +111,7 @@ export function registerLocalSetupCommands(registry: CommandRegistry): void {
         const runners = ctx.ops.remoteRuntime?.listContracts() ?? [];
         ctx.print([
           'Startup Remote',
-          `  runner contracts: ${snapshot.remoteRunnerCount}`,
+          `  worker contracts: ${snapshot.remoteRunnerCount}`,
           ...runners.map((runner) => `  ${runner.id}  [${runner.trustClass}]  ${runner.label}`),
         ].join('\n'));
         return;

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

@@ -252,7 +252,7 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
 
   registry.register({
     name: 'ops',
-    description: 'Operator Control Plane: view Agent operator posture without local task/agent lifecycle mutations',
+    description: 'Operator runtime status: view Agent posture without local task/agent lifecycle mutations',
     usage: '[view]',
     argsHint: '[view]',
     handler(args, ctx) {
@@ -260,7 +260,7 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
 
       if (sub === 'view' || sub === undefined) {
         if (ctx.openOpsPanel) ctx.openOpsPanel();
-        else ctx.print('Operator Control Plane panel is not available. Enable the operator-control-plane feature flag.');
+        else ctx.print('Operator runtime status panel is not available. Enable the operator-control-plane feature flag.');
         return;
       }
 

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

@@ -131,14 +131,14 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
   });
   registry.register({
     name: 'bridge',
-    description: 'Review and operate self-hosted bridge and remote runner flows',
+    description: 'Review self-hosted bridge and remote worker flows',
     usage: '[status|pools|assign <pool> <runner> --yes|runner <id>|review <artifactId>|export <artifactId> [path] --yes|import <path> --yes]',
     async handler(args, ctx) {
       const parsed = stripYesFlag(args);
       const commandArgs = [...parsed.rest];
       const shellPaths = requireShellPaths(ctx);
       if (!ctx.ops.remoteRuntime) {
-        ctx.print('Remote runner registry is not available in this runtime.');
+        ctx.print('Remote worker registry is not available in this runtime.');
         return;
       }
       const remoteRegistry = ctx.ops.remoteRuntime;
@@ -148,7 +148,7 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         ctx.print([
           'Bridge Status',
           `  remote pools: ${remote.pools.length}`,
-          `  runner contracts: ${remote.contracts.length}`,
+          `  worker contracts: ${remote.contracts.length}`,
           `  review artifacts: ${remote.artifacts.length}`,
         ].join('\n'));
         return;
@@ -157,7 +157,7 @@ export function registerProductRuntimeCommands(registry: CommandRegistry): void
         const pools = remoteRegistry.listPools();
         ctx.print(pools.length > 0
           ? ['Bridge Pools', ...pools.map((pool) => `  ${pool.id}  runners=${pool.runnerIds.length}  trust=${pool.trustClass}`)].join('\n')
-          : 'Bridge Pools\n  No runner pools registered yet.');
+          : 'Bridge Pools\n  No worker pools registered yet.');
         return;
       }
       if (sub === 'assign') {

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

@@ -13,9 +13,6 @@ type RemotePoolLike = {
 type RemoteRegistryLike = {
   listPools(): readonly RemotePoolLike[];
   getPool(id: string): RemotePoolLike | null | undefined;
-  createPool(input: { id: string; label: string }): RemotePoolLike;
-  assignRunnerToPool(poolId: string, runnerId: string): RemotePoolLike | null | undefined;
-  removeRunnerFromPool(poolId: string, runnerId: string): RemotePoolLike | null | undefined;
 };
 
 export function handleRemotePoolCommand(
@@ -29,12 +26,12 @@ export function handleRemotePoolCommand(
   if (mode === 'list') {
     const pools = remoteRegistry.listPools();
     if (pools.length === 0) {
-      ctx.print('No remote runner pools defined yet.');
+      ctx.print('No remote worker pools defined yet.');
       return true;
     }
     ctx.print([
-      `Remote Runner Pools (${pools.length})`,
-      ...pools.map((pool) => `  ${pool.id}  ${pool.runnerIds.length} runners  trust=${pool.trustClass}  template=${pool.preferredTemplate ?? '(none)'}`),
+      `Remote Worker Pools (${pools.length})`,
+      ...pools.map((pool) => `  ${pool.id}  ${pool.runnerIds.length} workers  trust=${pool.trustClass}  template=${pool.preferredTemplate ?? '(none)'}`),
     ].join('\n'));
     return true;
   }
@@ -46,59 +43,45 @@ export function handleRemotePoolCommand(
     }
     const pool = remoteRegistry.getPool(poolId);
     if (!pool) {
-      ctx.print(`Unknown remote runner pool: ${poolId}`);
+      ctx.print(`Unknown remote worker pool: ${poolId}`);
       return true;
     }
     ctx.print([
-      `Remote Runner Pool ${pool.id}`,
+      `Remote Worker Pool ${pool.id}`,
       `  label: ${pool.label}`,
       `  trustClass: ${pool.trustClass}`,
       `  preferredTemplate: ${pool.preferredTemplate ?? '(none)'}`,
-      `  maxRunners: ${pool.maxRunners ?? '(unbounded)'}`,
-      `  runners: ${pool.runnerIds.join(', ') || '(none)'}`,
+      `  maxWorkers: ${pool.maxRunners ?? '(unbounded)'}`,
+      `  workers: ${pool.runnerIds.join(', ') || '(none)'}`,
       `  description: ${pool.description ?? '(none)'}`,
     ].join('\n'));
     return true;
   }
   if (mode === 'create') {
-    const poolId = args[2];
-    if (!poolId) {
-      ctx.print('Usage: /remote pool create <poolId> [label]');
-      return true;
-    }
-    const label = args.slice(3).join(' ').trim() || poolId;
-    const pool = remoteRegistry.createPool({ id: poolId, label });
-    ctx.print(`Created remote runner pool ${pool.id} (${pool.label}).`);
+    ctx.print([
+      'Remote worker pool mutation is blocked in GoodVibes Agent.',
+      '  requested: /remote pool create',
+      '  policy: Agent inspects remote worker pools but does not manage worker topology',
+      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
+    ].join('\n'));
     return true;
   }
   if (mode === 'assign') {
-    const poolId = args[2];
-    const runnerId = args[3];
-    if (!poolId || !runnerId) {
-      ctx.print('Usage: /remote pool assign <poolId> <runnerId>');
-      return true;
-    }
-    const pool = remoteRegistry.assignRunnerToPool(poolId, runnerId);
-    if (!pool) {
-      ctx.print(`Could not assign ${runnerId} to pool ${poolId}.`);
-      return true;
-    }
-    ctx.print(`Assigned remote runner ${runnerId} to pool ${poolId}.`);
+    ctx.print([
+      'Remote worker pool mutation is blocked in GoodVibes Agent.',
+      '  requested: /remote pool assign',
+      '  policy: Agent inspects remote worker pools but does not manage worker topology',
+      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
+    ].join('\n'));
     return true;
   }
   if (mode === 'unassign') {
-    const poolId = args[2];
-    const runnerId = args[3];
-    if (!poolId || !runnerId) {
-      ctx.print('Usage: /remote pool unassign <poolId> <runnerId>');
-      return true;
-    }
-    const pool = remoteRegistry.removeRunnerFromPool(poolId, runnerId);
-    if (!pool) {
-      ctx.print(`Unknown remote runner pool: ${poolId}`);
-      return true;
-    }
-    ctx.print(`Removed remote runner ${runnerId} from pool ${poolId}.`);
+    ctx.print([
+      'Remote worker pool mutation is blocked in GoodVibes Agent.',
+      '  requested: /remote pool unassign',
+      '  policy: Agent inspects remote worker pools but does not manage worker topology',
+      '  next: use the owning GoodVibes runtime or delegated build environment for worker-pool administration',
+    ].join('\n'));
     return true;
   }
   ctx.print('Usage: /remote pool <list|show|create|assign|unassign> ...');

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

@@ -45,7 +45,7 @@ export async function handleRemoteSetupCommand(
       `  acp agent command: ${command.join(' ')}`,
       `  runtime host enabled: ${danger.daemon ? 'yes' : 'no'}`,
       `  inbound listener enabled: ${danger.httpListener ? 'yes' : 'no'}`,
-      `  remote runner contracts: ${remoteRegistry.listContracts().length}`,
+      `  remote worker contracts: ${remoteRegistry.listContracts().length}`,
       `  active acp connections: ${activeConnections.length}`,
       '',
       '  guidance:',

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

@@ -11,11 +11,11 @@ type RemoteCancelContext = Pick<CommandContext, 'print'>;
 
 function printRemoteDelegationBoundary(ctx: Pick<CommandContext, 'print'>, requestedAction: string): void {
   ctx.print([
-    'GoodVibes Agent does not dispatch remote/local coding runners from this surface.',
+    'GoodVibes Agent does not dispatch remote/local coding workers from this surface.',
     `  requested: ${requestedAction}`,
     '  policy: keep ordinary work serial in the main assistant conversation',
     '  build/fix/review: delegate one request to GoodVibes TUI through the public shared-session/build-delegation contract',
-    '  preserve: full original user ask and executionIntent; let TUI own runner/WRFC topology when explicitly requested',
+    '  preserve: full original user ask and executionIntent; let TUI own execution and WRFC chain details when explicitly requested',
   ].join('\n'));
 }
 
@@ -45,8 +45,8 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'remote',
     aliases: [],
-    description: 'Inspect, dispatch, and review self-hosted remote runners and artifacts',
-    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]',
+    description: 'Inspect remote workers, delegated work receipts, and review artifacts',
+    usage: '[list | show [agentId] | supervisor [workerId] | support [workerId] | recover [workerId] | 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> ... | 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) {
@@ -85,8 +85,8 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
         const lines = [
           'Remote Control Surface',
           `  active connections: ${activeConnections.length}`,
-          `  runner contracts: ${contracts.length}`,
-          `  runner pools: ${pools.length}`,
+          `  worker contracts: ${contracts.length}`,
+          `  worker pools: ${pools.length}`,
           `  review artifacts: ${artifacts.length}`,
           `  supervisor sessions: ${supervisor.sessions.length}`,
           `  degraded sessions: ${supervisor.degradedConnections}`,
@@ -131,7 +131,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           `  messageCount: ${selected.messageCount}`,
           `  errorCount: ${selected.errorCount}`,
           ...(selected.lastError ? [`  lastError: ${selected.lastError}`] : []),
-          '  runner support:',
+          '  worker support:',
           ...selected.capabilities.map((capability) => `    ${capability.id}: ${capability.supported ? 'yes' : 'no'} (${capability.detail})`),
           '  recovery:',
           ...selected.recovery.map((action) => `    ${action.command} — ${action.reason}`),
@@ -146,7 +146,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           ? snapshot.sessions.find((entry) => entry.runnerId === runnerId)
           : snapshot.sessions[0];
         if (!selected) {
-          ctx.print(runnerId ? `Unknown remote runner: ${runnerId}` : 'No remote supervisor sessions are currently tracked.');
+          ctx.print(runnerId ? `Unknown remote worker: ${runnerId}` : 'No remote supervisor sessions are currently tracked.');
           return;
         }
         ctx.print([
@@ -157,7 +157,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           `  reviewMode: ${selected.negotiation.reviewMode}`,
           `  communicationLane: ${selected.negotiation.communicationLane}`,
           `  trustClass: ${selected.negotiation.trustClass}`,
-          '  runner support:',
+          '  worker support:',
           ...selected.capabilities.map((capability) => (
             `    ${capability.id}: ${capability.supported ? 'supported' : 'missing'} — ${capability.detail}`
           )),
@@ -172,7 +172,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
           ? snapshot.sessions.find((entry) => entry.runnerId === runnerId)
           : snapshot.sessions.find((entry) => entry.recovery.length > 0) ?? snapshot.sessions[0];
         if (!selected) {
-          ctx.print(runnerId ? `Unknown remote runner: ${runnerId}` : 'No remote supervisor sessions are currently tracked.');
+          ctx.print(runnerId ? `Unknown remote worker: ${runnerId}` : 'No remote supervisor sessions are currently tracked.');
           return;
         }
         const nextSteps = selected.recovery.length > 0
@@ -254,7 +254,7 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
         }
         const pool = remoteRunners.getPool(poolId);
         if (!pool) {
-          ctx.print(`Unknown remote runner pool: ${poolId}`);
+          ctx.print(`Unknown remote worker pool: ${poolId}`);
           return;
         }
         let template = pool.preferredTemplate ?? 'general';
@@ -275,16 +275,16 @@ export function registerRemoteRuntimeCommands(registry: CommandRegistry): void {
       if (subcommand === 'contract') {
         const agentId = args[1] ?? activeConnections[0]?.agentId;
         if (!agentId) {
-          ctx.print('No remote runner contracts are available yet.');
+          ctx.print('No remote worker contracts are available yet.');
           return;
         }
         const contract = remoteRunners.upsertContractForAgent(agentId);
         if (!contract) {
-          ctx.print(`Unknown remote runner: ${agentId}`);
+          ctx.print(`Unknown remote worker: ${agentId}`);
           return;
         }
         ctx.print([
-          `Remote runner contract ${contract.id}`,
+          `Remote worker contract ${contract.id}`,
           `  runnerId: ${contract.runnerId}`,
           `  label: ${contract.label}`,
           `  pool: ${contract.poolId ?? '(none)'}`,

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

@@ -35,7 +35,7 @@ export function registerTeleportRuntimeCommands(registry: CommandRegistry): void
       try {
         peerClient = requirePeerClient(ctx);
       } catch {
-        ctx.print('Remote runner registry is not available in this runtime.');
+        ctx.print('Remote worker registry is not available in this runtime.');
         return;
       }
       const targetPath = shellPaths.resolveWorkspacePath(pathArg);

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

@@ -201,7 +201,7 @@ export function buildAgentSetupStep(controller: OnboardingWizardController): Onb
       {
         kind: 'status',
         id: 'agent-setup.profile-guide',
-        label: 'Runtime profiles',
+        label: 'Agent profiles',
         hint: 'Use /agent-profile guide after setup to create household, research, travel, operations, or custom Agent profiles.',
         defaultValue: 'Local profiles',
       },
@@ -378,7 +378,7 @@ export function buildLocalStateStep(): OnboardingWizardStepDefinition {
     id: 'agent-local-state',
     title: 'Local memory and behavior',
     shortLabel: 'Memory',
-    description: 'Review the Agent-local behavior model. Memory, personas, skills, routines, and runtime profiles stay local until a stable shared registry exists.',
+    description: 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
     summaryTitle: 'Local Agent state',
     summaryLines: [
       'Memory/personas/skills/routines: local Agent registries',
@@ -497,13 +497,6 @@ export function buildVoiceMediaStep(): OnboardingWizardStepDefinition {
         hint: 'Media output uses configured providers and visible command/turn flow; external publication still requires explicit approval.',
         defaultValue: 'Policy gated',
       },
-      {
-        kind: 'status',
-        id: 'agent-voice-media.nodes',
-        label: 'Node and device posture',
-        hint: 'Remote devices and nodes are inspected only when useful. Agent onboarding does not launch runners or background service processes.',
-        defaultValue: 'External',
-      },
     ],
   };
 }

package/src/panels/builtin/operations.ts

@@ -102,7 +102,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
     name: 'Automation',
     icon: 'M',
     category: 'monitoring',
-    description: 'Automation jobs, runs, deliveries, and failure posture across the control plane',
+    description: 'Automation jobs, runs, deliveries, and failure posture across the shared runtime',
     factory: () => new AutomationControlPanel(ui.readModels.automation),
   });
 
@@ -126,7 +126,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
 
   manager.registerType({
     id: 'control-plane',
-    name: 'Control Plane',
+    name: 'Runtime Status',
     icon: 'C',
     category: 'monitoring',
     description: 'Runtime state, clients, approvals, and recent operator activity',

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

@@ -42,7 +42,7 @@ export class ControlPlanePanel extends ScrollableListPanel<ControlPlaneClient> {
   private readonly unsub: (() => void) | null;
 
   public constructor(private readonly readModel?: UiReadModel<UiControlPlaneSnapshot>) {
-    super('control-plane', 'Control Plane', 'C', 'monitoring');
+    super('control-plane', 'Runtime Status', 'C', 'monitoring');
     this.showSelectionGutter = true; // I5: non-color selection affordance
     this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
   }
@@ -72,7 +72,7 @@ export class ControlPlanePanel extends ScrollableListPanel<ControlPlaneClient> {
   }
 
   protected override getEmptyStateMessage(): string {
-    return ' No control-plane activity recorded.';
+    return ' No runtime activity recorded.';
   }
 
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
@@ -83,18 +83,18 @@ export class ControlPlanePanel extends ScrollableListPanel<ControlPlaneClient> {
   }
 
   public render(width: number, height: number): Line[] {
-    const intro = 'Shared runtime state, live clients, approval pressure, and recent omnichannel session posture.';
+    const intro = 'Shared runtime state, live clients, approval pressure, and recent channel session posture.';
 
     if (!this.readModel) {
       const workspace = buildPanelWorkspace(width, height, {
-        title: 'Control Plane',
+        title: 'Runtime Status',
         intro,
         sections: [{
           lines: buildEmptyState(
             width,
             ' Runtime read model not wired.',
-            'This panel needs the shared control-plane read model to inspect clients, requests, and approvals.',
-            [{ command: '/cockpit', summary: 'use the cockpit while control-plane wiring is unavailable' }],
+            'This panel needs the shared runtime read model to inspect clients, requests, and approvals.',
+            [{ command: '/cockpit', summary: 'use the cockpit while runtime wiring is unavailable' }],
             C,
           ),
         }],
@@ -128,9 +128,9 @@ export class ControlPlanePanel extends ScrollableListPanel<ControlPlaneClient> {
 
     if (clients.length === 0 && approvals.length === 0 && sessions.length === 0) {
       return this.renderList(width, height, {
-        title: 'Control Plane',
+        title: 'Runtime Status',
         header: headerLines,
-        emptyMessage: ' No control-plane activity recorded.',
+        emptyMessage: ' No runtime activity recorded.',
       });
     }
 
@@ -203,7 +203,7 @@ export class ControlPlanePanel extends ScrollableListPanel<ControlPlaneClient> {
     footerLines.push(buildPanelLine(width, [['  Up/Down move through connected clients', C.dim]]));
 
     return this.renderList(width, height, {
-      title: 'Control Plane',
+      title: 'Runtime Status',
       header: headerLines,
       footer: footerLines,
     });

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

@@ -1,5 +1,5 @@
 /**
- * OpsControlPanel — operator control plane UI panel.
+ * OpsControlPanel — operator intervention log panel.
  *
  * Renders the ops audit log sourced from the OpsPanel diagnostics subscriber.
  * Each entry shows: seq, timestamp, action, target, outcome, and optional note.
@@ -130,7 +130,7 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
   }
 
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [{ command: '/cockpit', summary: 'open the cockpit and drive runtime interventions from the control rooms' }];
+    return [{ command: '/cockpit', summary: 'open the cockpit and review runtime interventions' }];
   }
 
   public render(width: number, height: number): Line[] {
@@ -142,7 +142,7 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
     ];
 
     return this.renderList(width, height, {
-      title: 'Operator Control Plane',
+      title: 'Operator Interventions',
       header: headerLines,
       footer: footerLines,
     });

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

@@ -63,10 +63,10 @@ export function buildProviderHealthDomainSummaries(
     name: 'settings',
     level: !settings.available ? 'info' : settingIssueCount > 0 ? 'warn' : 'good',
     summary: !settings.available
-      ? 'settings control plane unavailable'
+      ? 'settings runtime API unavailable'
       : settingIssueCount > 0
         ? `${settings.conflictCount} conflicts / ${settings.recentFailureCount} failures${settings.hasStagedManagedBundle ? ' / staged bundle' : ''}`
-        : 'settings control plane clean',
+        : 'settings runtime API clean',
     next: settingIssueCount > 0 ? '/settingssync panel' : '/settingssync show <key>',
     details: [
       settings.conflictCount > 0 ? `${settings.conflictCount} unresolved import conflict(s)` : '',

package/src/renderer/agent-workspace.ts

@@ -153,8 +153,8 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     );
   } else if (category.id === 'setup') {
     base.push(
-      { text: `External runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
-      { text: `Runtime ownership: ${snapshot.daemonOwnership}; Agent never starts or restarts it`, fg: PALETTE.good },
+      { text: `GoodVibes runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
+      { text: `Runtime owner: ${snapshot.daemonOwnership}; Agent connects but never starts or restarts it`, fg: PALETTE.good },
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
       { text: '' },
@@ -166,7 +166,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     const configuredDefaults = snapshot.channels.filter((channel) => channel.defaultTarget === 'configured').length;
     const disabledChannels = snapshot.channels.filter((channel) => !channel.enabled).map((channel) => channel.label).join(', ');
     base.push(
-      { text: `External runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
+      { text: `GoodVibes runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
       { text: `Readiness: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} default target(s) configured.`, fg: PALETTE.info },
       { text: `Disabled channels: ${disabledChannels || 'none'}.`, fg: PALETTE.dim },
       { text: 'Pairing: use /pair or /qrcode for companion setup.', fg: PALETTE.info },
@@ -195,18 +195,18 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: `Voice surface: ${snapshot.voiceSurfaceEnabled ? 'enabled' : 'disabled'}; use /voice review for portable voice posture.`, fg: snapshot.voiceSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
       { text: `TTS config: provider ${snapshot.ttsProvider}; voice ${snapshot.ttsVoice}; response model ${snapshot.ttsResponseModel}.`, fg: PALETTE.info },
       { text: `Media providers: ${snapshot.mediaProviderCount}; understanding: ${snapshot.mediaUnderstandingProviderCount}; generation: ${snapshot.mediaGenerationProviderCount}.`, fg: PALETTE.info },
-      { text: `Browser surface: ${snapshot.browserSurfaceEnabled ? 'enabled' : 'disabled'}; public base URL ${snapshot.browserSurfacePublicBaseUrl}.`, fg: snapshot.browserSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
-      { text: 'Node/remote posture is read-only here; build dispatch remains explicit TUI delegation.', fg: PALETTE.good },
+      { text: `Browser tools: ${snapshot.browserSurfaceEnabled ? 'available' : 'not advertised'}; public base URL ${snapshot.browserSurfacePublicBaseUrl}.`, fg: snapshot.browserSurfaceEnabled ? PALETTE.warn : PALETTE.muted },
+      { text: 'Build dispatch stays out of setup; explicit delegation is handled from the Build Delegation workspace.', fg: PALETTE.good },
       { text: 'Image input uses prompt attachments; media generation/provider setup stays behind explicit commands and configured providers.', fg: PALETTE.muted },
     );
   } else if (category.id === 'profiles') {
     base.push(
-      { text: `Active runtime profile: ${snapshot.activeRuntimeProfile}`, fg: PALETTE.info },
-      { text: `Runtime profiles under this home: ${snapshot.runtimeProfileCount}`, fg: PALETTE.info },
-      { text: `Runtime profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
+      { text: `Active Agent profile: ${snapshot.activeRuntimeProfile}`, fg: PALETTE.info },
+      { text: `Agent profiles under this home: ${snapshot.runtimeProfileCount}`, fg: PALETTE.info },
+      { text: `Agent profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
       { text: `Starter templates: ${snapshot.runtimeStarterTemplateCount}; local custom: ${snapshot.localStarterTemplateCount}`, fg: PALETTE.info },
       { text: `Config profiles: ${snapshot.configProfileCount}`, fg: PALETTE.info },
-      { text: 'Named runtime profiles isolate Agent-local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
+      { text: 'Named Agent profiles isolate local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
       { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace via /agent-profile.', fg: PALETTE.info },
       { text: 'The external GoodVibes runtime remains shared unless the owning host is configured separately.', fg: PALETTE.warn },
       { text: 'Portable bundles require explicit export/import commands with real paths and --yes.', fg: PALETTE.muted },

package/src/renderer/settings-modal-helpers.ts

@@ -87,7 +87,7 @@ export const CATEGORY_LABELS: Record<(typeof SETTINGS_CATEGORIES)[number], strin
   helper: 'Helper',
   tts: 'TTS',
   service: 'Service',
-  controlPlane: 'Control Plane',
+  controlPlane: 'Runtime API',
   httpListener: 'HTTP Listener',
   web: 'Web',
   batch: 'Batch',
@@ -123,18 +123,18 @@ export const SETTING_LABELS: Partial<Record<string, string>> = {
   'helper.enabled': 'Helper Enabled',
   'helper.globalProvider': 'Helper Provider',
   'helper.globalModel': 'Helper Model',
-  // Control Plane
-  'controlPlane.enabled': 'CP Enabled',
-  'controlPlane.hostMode': 'CP Host Mode',
-  'controlPlane.host': 'CP Host',
-  'controlPlane.port': 'CP Port',
-  'controlPlane.baseUrl': 'CP Base URL',
-  'controlPlane.streamMode': 'CP Stream Mode',
-  'controlPlane.allowRemote': 'CP Allow Remote',
-  'controlPlane.trustProxy': 'CP Trust Proxy',
-  'controlPlane.tls.mode': 'CP TLS Mode',
-  'controlPlane.tls.certFile': 'CP TLS Cert',
-  'controlPlane.tls.keyFile': 'CP TLS Key',
+  // Runtime API
+  'controlPlane.enabled': 'Runtime API Enabled',
+  'controlPlane.hostMode': 'Runtime API Host Mode',
+  'controlPlane.host': 'Runtime API Host',
+  'controlPlane.port': 'Runtime API Port',
+  'controlPlane.baseUrl': 'Runtime API Base URL',
+  'controlPlane.streamMode': 'Runtime API Stream Mode',
+  'controlPlane.allowRemote': 'Runtime API Allow Remote',
+  'controlPlane.trustProxy': 'Runtime API Trust Proxy',
+  'controlPlane.tls.mode': 'Runtime API TLS Mode',
+  'controlPlane.tls.certFile': 'Runtime API TLS Cert',
+  'controlPlane.tls.keyFile': 'Runtime API TLS Key',
   // HTTP Listener
   'httpListener.hostMode': 'HTTP Host Mode',
   'httpListener.host': 'HTTP Host',

package/src/renderer/settings-modal.ts

@@ -35,7 +35,7 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   helper: 'Helper model defaults used by helper subsystems when they do not use the main chat route.',
   tts: 'Text-to-speech provider, voice, and optional spoken-turn LLM overrides.',
   service: 'External GoodVibes runtime service posture. Agent shows these compatibility keys for inspection only and does not install, start, stop, restart, or autostart services.',
-  controlPlane: 'External GoodVibes runtime control-plane settings for local admin/API access. Agent connects to that runtime and does not mutate its bind posture.',
+  controlPlane: 'External GoodVibes runtime API settings for local admin/API access. Agent connects to that runtime and does not mutate its bind posture.',
   httpListener: 'External HTTP listener settings for webhook and integration ingress. Agent does not start or expose the listener.',
   web: 'External browser surface settings. Agent does not own the web listener or network bind lifecycle.',
   batch: 'Batch execution settings reported from the external GoodVibes runtime. Agent does not own remote queue provisioning.',
@@ -50,7 +50,7 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   danger: 'High-impact runtime and listener switches. Agent renders host-owned switches read-only; use GoodVibes TUI or the owning host to change them.',
   tools: 'Tool LLM and helper model routing. Empty provider/model values inherit the active chat route unless a specific helper/tool route is set.',
   flags: 'Feature flags are SDK runtime gates. They are separate from normal config keys because they enable or disable staged runtime behavior.',
-  network: 'Read-only view of external GoodVibes runtime control-plane, HTTP listener, and browser web bind posture plus editable Agent network settings.',
+  network: 'Read-only view of external GoodVibes runtime API, HTTP listener, and browser web bind posture plus editable Agent network settings.',
 };
 
 const ENUM_VALUE_DESCRIPTIONS: Record<string, Record<string, string>> = {

package/src/runtime/bootstrap.ts

@@ -552,7 +552,7 @@ export async function bootstrapRuntime(
     },
   };
 
-  // ── Phase 12b: Operator Control Plane wiring (feature-gated) ──────────────
+  // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
   // Wire the OpsControlPlane into CommandContext when the feature flag is enabled.
   // The store and task manager are created unconditionally so they reflect the
   // real runtime state (tasks registered before the flag check are visible).

package/src/runtime/diagnostics/panels/ops.ts

@@ -1,5 +1,5 @@
 /**
- * OpsPanel — diagnostic data provider for the Operator Control Plane.
+ * OpsPanel — diagnostic data provider for operator interventions.
  *
  * Subscribes to OPS_AUDIT events from the UI-facing ops event feed and maintains a
  * bounded buffer of intervention records for display

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