@pellux/goodvibes-agent 1.0.34 → 1.0.36

package/src/tools/agent-harness-channel-metadata.ts

@@ -1,6 +1,7 @@
 import type { CommandContext } from '../input/command-registry.ts';
 import type { AgentWorkspaceChannelStatus } from '../input/agent-workspace-channels.ts';
 import { buildAgentWorkspaceChannels } from '../input/agent-workspace-channels.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessChannelArgs {
   readonly channelId?: unknown;
@@ -59,9 +60,14 @@ function describeChannelCandidate(channel: AgentWorkspaceChannelStatus): Record<
     setupState: channel.setupState,
     ready: channel.ready,
     delivery: channel.delivery,
+    modelRoute: channelModelRoute(),
   };
 }
 
+function channelModelRoute(): string {
+  return 'agent_channel_send or agent_harness mode:"channel"';
+}
+
 function describeChannel(
   channel: AgentWorkspaceChannelStatus,
   options: { readonly includeParameters?: boolean; readonly lookup?: Record<string, unknown> } = {},
@@ -82,32 +88,37 @@ function describeChannel(
     missingConfigKeys: channel.missingRequiredKeys,
     defaultTargetKeys: channel.defaultTargetKeys,
     configuredDefaultTargetKeys: channel.configuredDefaultTargetKeys,
+    modelRoute: channelModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    ...(options.includeParameters ? {
-      policy: {
-        effect: 'read-only',
-        values: 'Config key names and target key names are shown; secret values and stored target values are never returned.',
-        delivery: 'Use agent_channel_send only for one explicit, confirmed delivery target requested by the user.',
-        setup: 'Use connected-host setup/account/policy routes only as read-only diagnostics unless another confirmed first-class tool owns the mutation.',
-      },
-      modelAccess: {
-        sendTool: 'agent_channel_send',
-        notificationTool: 'agent_notify',
-        reminderTool: 'agent_reminder_schedule',
-        slashCommandDetail: `/channels show ${channel.id}`,
-        readOnlyConnectedRoutes: [
-          '/channels accounts',
-          '/channels policies',
-          '/channels status',
-          `/channels doctor ${channel.id}`,
-          `/channels setup ${channel.id}`,
-        ],
-        settingsFilter: `agent_harness mode:"settings" prefix:"surfaces.${channel.id}" includeHidden:true`,
-        connectedHostBoundary: 'agent_harness mode:"connected_host_capability" query:"delivery"',
-        deliveryTargetShape: 'surface[:route[:label]]',
-        exampleTarget: `${channel.id}:route:Label`,
-      },
-    } : {}),
+    ...(options.includeParameters
+      ? {
+        policy: {
+          effect: 'read-only',
+          values: 'Config key names and target key names are shown; secret values and stored target values are never returned.',
+          delivery: 'Use agent_channel_send only for one explicit, confirmed delivery target requested by the user.',
+          setup: 'Use connected-host setup/account/policy routes only as read-only diagnostics unless another confirmed first-class tool owns the mutation.',
+        },
+        modelAccess: {
+          sendTool: 'agent_channel_send',
+          notificationTool: 'agent_notify',
+          reminderTool: 'agent_reminder_schedule',
+          slashCommandDetail: `/channels show ${channel.id}`,
+          readOnlyConnectedRoutes: [
+            '/channels accounts',
+            '/channels policies',
+            '/channels status',
+            `/channels doctor ${channel.id}`,
+            `/channels setup ${channel.id}`,
+          ],
+          settingsFilter: `agent_harness mode:"settings" prefix:"surfaces.${channel.id}" includeHidden:true`,
+          connectedHostBoundary: 'agent_harness mode:"connected_host_capability" query:"delivery"',
+          deliveryTargetShape: 'surface[:route[:label]]',
+          exampleTarget: `${channel.id}:route:Label`,
+        },
+      }
+      : {
+        summary: previewHarnessText(channel.nextStep || `${channel.label} channel ${channel.setupState}`),
+      }),
   };
 }
 

package/src/tools/agent-harness-cli-metadata.ts

@@ -34,6 +34,11 @@ function readLimit(value: unknown, fallback: number): number {
   return Math.max(1, Math.min(500, Math.trunc(parsed)));
 }
 
+function previewText(value: string, maxLength = 56): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
+}
+
 function redactCliLookupInput(input: string): string {
   return input
     .replace(/(--config=)([^=\s]+)=\S+/g, '$1$2=<redacted>')
@@ -58,6 +63,8 @@ function fallbackCliSummary(command: GoodVibesCliCommand): string {
 function describeCliCommand(command: GoodVibesCliCommand, lookup?: CliCommandLookup): Record<string, unknown> {
   const help = describeGoodVibesCommandHelp(command);
   const tokens = cliCommandTokens(command);
+  const policy = describeCliCommandPolicy(command);
+  const modelRoute = previewText(policy.preferredModelTool ?? 'agent_harness mode:"cli_command"');
   return {
     name: command,
     tokens,
@@ -69,7 +76,13 @@ function describeCliCommand(command: GoodVibesCliCommand, lookup?: CliCommandLoo
     aliases: help?.aliases ?? tokens.filter((token) => token !== command),
     subcommands: help?.subcommands ?? [],
     examples: help?.examples ?? [],
-    policy: describeCliCommandPolicy(command),
+    modelRoute,
+    modelAccess: {
+      inspect: `agent_harness mode:"cli_command" cliCommand:"${command}"`,
+      executeEquivalent: policy.preferredModelTool ?? 'Use the current conversation or an explicit user-requested shell command.',
+      preferred: modelRoute,
+    },
+    policy,
   };
 }
 
@@ -88,11 +101,16 @@ function cliCommandMatches(command: Record<string, unknown>, query: string): boo
 }
 
 function cliCommandCandidate(command: Record<string, unknown>): Record<string, unknown> {
+  const policy = typeof command.policy === 'object' && command.policy !== null
+    ? command.policy as { readonly effect?: unknown; readonly preferredModelTool?: unknown }
+    : {};
   return {
     name: command.name,
     tokens: command.tokens,
     invocation: command.invocation,
     summary: command.summary,
+    effect: typeof policy.effect === 'string' ? policy.effect : 'unknown',
+    ...(typeof policy.preferredModelTool === 'string' ? { modelRoute: previewText(policy.preferredModelTool) } : {}),
   };
 }
 

package/src/tools/agent-harness-command-catalog.ts

@@ -39,9 +39,9 @@ function readStringArray(value: unknown): readonly string[] {
   return value.map((entry) => typeof entry === 'string' ? entry : String(entry));
 }
 
-function previewText(value: string, maxLength = 120): string {
+function previewText(value: string, maxLength = 56): string {
   const normalized = value.replace(/\s+/g, ' ').trim();
-  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 3).trimEnd()}...`;
 }
 
 function commandMatches(command: SlashCommand, query: string): boolean {
@@ -57,6 +57,8 @@ function commandMatches(command: SlashCommand, query: string): boolean {
 }
 
 function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): Record<string, unknown> {
+  const policy = describeCommandPolicy(command.name);
+  const modelRoute = previewText(policy.preferredModelTool ?? 'agent_harness mode:"command", mode:"run_command"');
   return {
     name: command.name,
     slash: `/${command.name}`,
@@ -64,6 +66,12 @@ function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): R
     description: command.description,
     usage: command.usage ?? '',
     argsHint: command.argsHint ?? command.usage ?? '',
+    modelRoute,
+    modelAccess: {
+      inspect: `agent_harness mode:"command" commandName:"${command.name}"`,
+      run: `agent_harness mode:"run_command" commandName:"${command.name}" confirm:true explicitUserRequest:"..."`,
+      preferred: modelRoute,
+    },
     ...(lookup ? {
       lookup: {
         source: lookup.source,
@@ -73,16 +81,19 @@ function describeCommand(command: SlashCommand, lookup?: CommandDetailLookup): R
         resolvedBy: lookup.resolvedBy,
       },
     } : {}),
-    policy: describeCommandPolicy(command.name),
+    policy,
   };
 }
 
 function describeCommandCandidate(command: SlashCommand): Record<string, unknown> {
+  const policy = describeCommandPolicy(command.name);
   return {
     name: command.name,
     slash: `/${command.name}`,
     aliases: command.aliases ?? [],
     summary: previewText(command.description),
+    effect: policy.effect,
+    modelRoute: previewText(policy.preferredModelTool ?? 'agent_harness mode:"command", mode:"run_command"'),
     ...(command.argsHint ? { argsHint: command.argsHint } : {}),
   };
 }
@@ -170,7 +181,7 @@ export function resolveHarnessCommandDetail(commandRegistry: CommandRegistry, ar
 
 export function listHarnessCommands(commandRegistry: CommandRegistry, args: AgentHarnessCommandCatalogArgs): readonly Record<string, unknown>[] {
   const query = readString(args.query);
-  const limit = readLimit(args.limit, 200);
+  const limit = readLimit(args.limit, 500);
   const includeParameters = args.includeParameters === true;
   return commandRegistry.list()
     .filter((command) => commandMatches(command, query))

package/src/tools/agent-harness-connected-host-status.ts

@@ -39,11 +39,11 @@ function connectedHostFindings(
     });
   } else if (!runtime.compatible) {
     findings.push({
-      id: 'connected-host-version-mismatch',
+      id: 'connected-host-incompatible',
       severity: 'warning',
-      summary: 'Connected host SDK version does not match Agent.',
-      cause: `Connected host reports SDK ${runtime.version}; Agent expects ${runtime.expectedVersion}.`,
-      action: 'Update the owning GoodVibes host so its /status route reports the Agent SDK pin.',
+      summary: 'Connected host compatibility does not satisfy Agent readiness.',
+      cause: 'Connected host is reachable, but at least one public Agent route is unavailable or incompatible.',
+      action: 'Update the owning GoodVibes host so its public Agent routes are compatible.',
     });
   }
 
@@ -88,6 +88,7 @@ export async function connectedHostStatusSummary(
   return {
     ownership: 'external-connected-host',
     readOnly: true,
+    modelRoute: 'agent_harness mode:"connected_host_status" or mode:"service_posture"',
     timeoutMs: CONNECTED_HOST_STATUS_TIMEOUT_MS,
     lifecycle: 'GoodVibes Agent can inspect connected-host readiness and use public operator routes, but does not start, stop, restart, install, expose, or mutate the host listener.',
     paths: {
@@ -122,8 +123,6 @@ export async function connectedHostStatusSummary(
         route: '/status',
         reachable: runtime.reachable,
         statusCode: runtime.statusCode,
-        sdkVersion: runtime.version,
-        expectedSdkVersion: runtime.expectedVersion,
         compatible: runtime.compatible,
       },
       {
@@ -142,6 +141,8 @@ export async function connectedHostStatusSummary(
     },
     ...(options.includeParameters ? { modelAccess: {
       diagnostics: 'Use mode:"connected_host_status" for live read-only host readiness, mode:"service_posture" for endpoint posture, mode:"service_endpoint" for one endpoint, and mode:"connected_host" for capability and boundary inventory.',
+      daemonAliases: 'mode:"daemon_status" is an alias for mode:"connected_host_status"; mode:"daemon" is an alias for mode:"connected_host".',
+      lifecycleBlocked: 'Start, stop, restart, install, expose, and listener mutation are not exposed through Agent.',
       cliMirrors: ['goodvibes-agent status --json', 'goodvibes-agent doctor', 'goodvibes-agent compat'],
       tuiMirrors: ['Agent Workspace -> Home -> Host compatibility', 'Agent Workspace -> Home -> Doctor diagnostics', 'Agent Workspace -> Home -> Review health'],
     },

package/src/tools/agent-harness-delegation-posture.ts

@@ -1,4 +1,5 @@
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessDelegationArgs {
   readonly delegationRouteId?: unknown;
@@ -113,9 +114,16 @@ function describeCandidate(route: DelegationRoute): Record<string, unknown> {
     label: route.label,
     effect: route.effect,
     confirmationRequired: route.confirmationRequired === true,
+    modelRoute: delegationRouteModelRoute(route),
   };
 }
 
+function delegationRouteModelRoute(route: DelegationRoute): string {
+  if (route.workspaceActionId) return 'agent_harness mode:"run_workspace_action"';
+  if (route.command || route.commandTemplate) return 'agent_harness mode:"run_command"';
+  return route.effect === 'main-conversation' ? 'main conversation' : 'agent_harness mode:"delegation_route"';
+}
+
 function describeRoute(
   context: CommandContext,
   route: DelegationRoute,
@@ -124,17 +132,20 @@ function describeRoute(
   return {
     delegationRouteId: route.id,
     label: route.label,
-    detail: route.detail,
+    ...(options.includeParameters ? { detail: route.detail } : { summary: previewHarnessText(route.detail) }),
     effect: route.effect,
-    ...(route.command ? { command: route.command } : {}),
-    ...(route.commandTemplate ? { commandTemplate: route.commandTemplate } : {}),
-    ...(route.workspaceActionId ? { workspaceActionId: route.workspaceActionId } : {}),
     confirmationRequired: route.confirmationRequired === true,
     reviewPolicy: route.reviewPolicy ?? 'not-applicable',
+    modelRoute: delegationRouteModelRoute(route),
     runtime: {
       sessionId: context.session.runtime.sessionId,
       operatorClientAttached: Boolean(context.clients?.operator),
     },
+    ...(options.includeParameters ? {
+      ...(route.command ? { command: route.command } : {}),
+      ...(route.commandTemplate ? { commandTemplate: route.commandTemplate } : {}),
+      ...(route.workspaceActionId ? { workspaceActionId: route.workspaceActionId } : {}),
+    } : {}),
     ...(options.lookup ? { lookup: options.lookup } : {}),
     ...(options.includeParameters ? {
       policy: {

package/src/tools/agent-harness-keybinding-metadata.ts

@@ -222,6 +222,8 @@ function bindingCandidate(manager: KeybindingsManager | null, entry: KeybindingE
     action: entry.action,
     description: entry.description,
     labels: entry.combos.map((combo) => formatCombo(manager, combo)),
+    modelRoute: keybindingModelRoute(entry.action),
+    inspectRoute: `agent_harness mode:"keybinding" actionId:"${entry.action}"`,
   };
 }
 
@@ -246,9 +248,30 @@ function resolveHarnessKeybinding(context: CommandContext, args: HarnessKeybindi
   return null;
 }
 
+function keybindingModelRoute(action: KeyAction): string {
+  const route = keybindingOperationRoute(action);
+  if (route.preferredMode === 'run_keybinding') return `agent_harness mode:"run_keybinding" actionId:"${action}"`;
+  if (route.preferredMode === 'open_ui_surface' && route.surfaceId) return `agent_harness mode:"open_ui_surface" surfaceId:"${route.surfaceId}"`;
+  if (route.preferredMode === 'open_ui_surface') return 'agent_harness mode:"open_ui_surface"';
+  if (route.preferredMode === 'run_command' && route.command) return `agent_harness mode:"run_command" command:"${route.command}"`;
+  if (route.preferredMode === 'run_command') return 'agent_harness mode:"run_command"';
+  return 'direct-user-interaction';
+}
+
+function keybindingModelAccess(action: KeyAction, operation: KeybindingOperationRoute): Record<string, unknown> {
+  return {
+    inspect: `agent_harness mode:"keybinding" actionId:"${action}"`,
+    run: operation.supported ? `agent_harness mode:"run_keybinding" actionId:"${action}" confirm:true explicitUserRequest:"..."` : 'not exposed',
+    set: `agent_harness mode:"set_keybinding" actionId:"${action}" combo:{...} confirm:true explicitUserRequest:"..."`,
+    reset: `agent_harness mode:"reset_keybinding" actionId:"${action}" confirm:true explicitUserRequest:"..."`,
+    preferred: keybindingModelRoute(action),
+  };
+}
+
 function describeBinding(manager: KeybindingsManager | null, action: KeyAction, combos: KeyCombo[], lookup?: KeybindingLookup): Record<string, unknown> {
   const defaults = DEFAULT_KEYBINDINGS[action];
   const customized = !combosEqual(combos, defaults);
+  const modelOperation = keybindingOperationRoute(action);
   return {
     action,
     description: ACTION_DESCRIPTIONS[action],
@@ -258,7 +281,10 @@ function describeBinding(manager: KeybindingsManager | null, action: KeyAction,
     defaultBindings: defaults.map((combo) => describeCombo(manager, combo)),
     customized,
     source: manager ? (customized ? 'custom' : 'default') : 'default-fallback',
-    modelOperation: keybindingOperationRoute(action),
+    modelRoute: keybindingModelRoute(action),
+    inspectRoute: `agent_harness mode:"keybinding" actionId:"${action}"`,
+    modelAccess: keybindingModelAccess(action, modelOperation),
+    modelOperation,
   };
 }
 
@@ -270,7 +296,7 @@ function keybindingOperationRoute(action: KeyAction): KeybindingOperationRoute {
         effect: 'shell-action',
         preferredMode: 'run_keybinding',
         confirmation: 'agent_harness mode:"run_keybinding" requires confirm:true and explicitUserRequest.',
-        note: 'Routes the cancel-generation side of this shortcut through commandContext.cancelGeneration. Prompt clearing and double-press exit remain direct user interaction.',
+        note: 'Runs the available cancel-generation route. Prompt clearing and double-press exit remain direct user interaction.',
       };
     case 'screen-clear':
       return {
@@ -278,7 +304,7 @@ function keybindingOperationRoute(action: KeyAction): KeybindingOperationRoute {
         effect: 'shell-action',
         preferredMode: 'run_keybinding',
         confirmation: 'agent_harness mode:"run_keybinding" requires confirm:true and explicitUserRequest.',
-        note: 'Routes through commandContext.clearScreen.',
+        note: 'Runs the available clear-screen route.',
       };
     case 'panel-picker':
       return {
@@ -295,7 +321,7 @@ function keybindingOperationRoute(action: KeyAction): KeybindingOperationRoute {
         effect: 'visible-ui-navigation',
         preferredMode: 'run_keybinding',
         confirmation: 'agent_harness mode:"run_keybinding" requires confirm:true and explicitUserRequest.',
-        note: 'Dismisses the active Agent workspace first. If no Agent workspace is active, closes the active legacy panel if present, then focuses the prompt when the shell bridge exposes focusPrompt.',
+        note: 'Dismisses Agent workspace first. If it is not active, closes the active panel and focuses the prompt when focus is available.',
       };
     case 'panel-close-all':
       return {
@@ -303,7 +329,7 @@ function keybindingOperationRoute(action: KeyAction): KeybindingOperationRoute {
         effect: 'visible-ui-navigation',
         preferredMode: 'run_keybinding',
         confirmation: 'agent_harness mode:"run_keybinding" requires confirm:true and explicitUserRequest.',
-        note: 'Dismisses the active Agent workspace first. If no Agent workspace is active, closes all legacy panels if present, hides the panel manager, then focuses the prompt when the shell bridge exposes focusPrompt.',
+        note: 'Dismisses Agent workspace first. If it is not active, closes open panels and focuses the prompt when focus is available.',
       };
     case 'history-search':
       return {
@@ -330,7 +356,7 @@ function keybindingOperationRoute(action: KeyAction): KeybindingOperationRoute {
         preferredMode: 'run_keybinding',
         command: '/paste',
         confirmation: 'agent_harness mode:"run_keybinding" requires confirm:true and explicitUserRequest.',
-        note: 'Routes through commandContext.pasteFromClipboard and reports whether text, image, or nothing was pasted.',
+        note: 'Runs the paste route and reports whether text, image, or nothing was pasted.',
       };
     case 'block-copy':
     case 'bookmark':
@@ -408,13 +434,38 @@ export function totalHarnessShortcuts(context: CommandContext): number {
   return totalHarnessKeybindings(context) + FIXED_SHORTCUTS.length;
 }
 
+function fixedShortcutModelRoute(shortcut: Record<string, string>): string {
+  if (shortcut.key.includes('/shortcuts')) return 'agent_harness mode:"shortcuts"';
+  if (shortcut.key.includes('/keybindings')) return 'agent_harness mode:"keybindings"';
+  if (shortcut.key.includes('?') || shortcut.key.includes('F1')) return 'agent_harness mode:"open_ui_surface" surfaceId:"help-overlay"';
+  if (shortcut.key.includes('F2')) return 'agent_harness mode:"open_ui_surface" surfaceId:"process-monitor"';
+  if (shortcut.key.includes('Esc')) return 'direct-user-interaction';
+  if (shortcut.key.includes('Tab')) return 'agent_harness mode:"commands"';
+  if (shortcut.key.includes('Enter')) return 'main conversation';
+  return 'direct-user-interaction';
+}
+
+function describeFixedShortcut(shortcut: Record<string, string>): Record<string, unknown> {
+  return {
+    ...shortcut,
+    source: 'fixed',
+    userEditable: false,
+    modelRoute: fixedShortcutModelRoute(shortcut),
+    modelAccess: {
+      inspectShortcuts: 'agent_harness mode:"shortcuts"',
+      inspectKeybindings: 'agent_harness mode:"keybindings"',
+      preferred: fixedShortcutModelRoute(shortcut),
+    },
+  };
+}
+
 export function listHarnessShortcuts(context: CommandContext, args: HarnessKeybindingArgs): Record<string, unknown> {
   const keybindings = listHarnessKeybindings(context, args);
   const query = readString(args.query).toLowerCase();
   const fixed = FIXED_SHORTCUTS
     .filter((shortcut) => !query || `${shortcut.key}\n${shortcut.description}`.toLowerCase().includes(query))
     .slice(0, readLimit(args.limit, 200))
-    .map((shortcut) => ({ ...shortcut, source: 'fixed', userEditable: false }));
+    .map(describeFixedShortcut);
   const degraded = keybindings.status === 'degraded';
   return {
     status: degraded ? 'degraded' : 'available',
@@ -496,11 +547,11 @@ export function runHarnessKeybinding(context: CommandContext, args: HarnessKeybi
 
   switch (resolved.action) {
     case 'clear-cancel':
-      if (!context.cancelGeneration) return runUnavailable(resolved.action, route, 'commandContext.cancelGeneration is unavailable.');
+      if (!context.cancelGeneration) return runUnavailable(resolved.action, route, 'Cancel-generation route is unavailable.');
       context.cancelGeneration();
       return { status: 'executed', action: resolved.action, effect: 'cancel-generation', keybinding: descriptor };
     case 'screen-clear':
-      if (!context.clearScreen) return runUnavailable(resolved.action, route, 'commandContext.clearScreen is unavailable.');
+      if (!context.clearScreen) return runUnavailable(resolved.action, route, 'Clear-screen route is unavailable.');
       context.clearScreen();
       return { status: 'executed', action: resolved.action, effect: 'screen-clear', keybinding: descriptor };
     case 'panel-picker':
@@ -512,7 +563,7 @@ export function runHarnessKeybinding(context: CommandContext, args: HarnessKeybi
         context.openAgentWorkspace('home');
         return { status: 'executed', action: resolved.action, effect: 'agent-workspace-opened', route: 'openAgentWorkspace', categoryId: 'home', keybinding: descriptor };
       }
-      return runUnavailable(resolved.action, route, 'No panel picker or Agent workspace opener is available.');
+      return runUnavailable(resolved.action, route, 'No panel picker or Agent workspace route is available.');
     case 'panel-close': {
       const dismissedAgentWorkspace = context.dismissAgentWorkspace?.() ?? false;
       if (dismissedAgentWorkspace) {
@@ -526,7 +577,7 @@ export function runHarnessKeybinding(context: CommandContext, args: HarnessKeybi
       }
       const active = context.workspace.panelManager?.getActivePanel() ?? null;
       if (active) context.workspace.panelManager?.close(active.id);
-      if (!active && !context.focusPrompt) return runUnavailable(resolved.action, route, 'No active Agent workspace, active legacy panel, or prompt focus route is available.');
+      if (!active && !context.focusPrompt) return runUnavailable(resolved.action, route, 'No active Agent workspace, active panel, or prompt focus route is available.');
       if (context.focusPrompt) context.focusPrompt();
       context.renderRequest();
       return {
@@ -552,7 +603,7 @@ export function runHarnessKeybinding(context: CommandContext, args: HarnessKeybi
       const openPanels = managerPanel?.getAllOpen() ?? [];
       for (const panel of openPanels) managerPanel?.close(panel.id);
       managerPanel?.hide();
-      if (openPanels.length === 0 && !context.focusPrompt) return runUnavailable(resolved.action, route, 'No active Agent workspace, open legacy panels, or prompt focus route is available.');
+      if (openPanels.length === 0 && !context.focusPrompt) return runUnavailable(resolved.action, route, 'No active Agent workspace, open panels, or prompt focus route is available.');
       if (context.focusPrompt) context.focusPrompt();
       context.renderRequest();
       return {
@@ -564,26 +615,26 @@ export function runHarnessKeybinding(context: CommandContext, args: HarnessKeybi
       };
     }
     case 'history-search': {
-      if (!context.openPromptHistorySearch) return runUnavailable(resolved.action, route, 'commandContext.openPromptHistorySearch is unavailable.');
+      if (!context.openPromptHistorySearch) return runUnavailable(resolved.action, route, 'Prompt history search route is unavailable.');
       const query = readString(args.value);
       context.openPromptHistorySearch(query || undefined);
       return { status: 'executed', action: resolved.action, effect: 'prompt-history-search-opened', query, keybinding: descriptor };
     }
     case 'search': {
-      if (!context.openConversationSearch) return runUnavailable(resolved.action, route, 'commandContext.openConversationSearch is unavailable.');
+      if (!context.openConversationSearch) return runUnavailable(resolved.action, route, 'Conversation search route is unavailable.');
       const query = readString(args.value);
       context.openConversationSearch(query || undefined);
       return { status: 'executed', action: resolved.action, effect: 'conversation-search-opened', query, keybinding: descriptor };
     }
     case 'paste': {
-      if (!context.pasteFromClipboard) return runUnavailable(resolved.action, route, 'commandContext.pasteFromClipboard is unavailable.');
+      if (!context.pasteFromClipboard) return runUnavailable(resolved.action, route, 'Paste route is unavailable.');
       const pasted = context.pasteFromClipboard();
       return { status: 'executed', action: resolved.action, effect: 'paste-from-clipboard', pasted, keybinding: descriptor };
     }
     case 'block-copy':
     case 'bookmark':
     case 'block-save': {
-      if (!context.openBlockActions) return runUnavailable(resolved.action, route, 'commandContext.openBlockActions is unavailable.');
+      if (!context.openBlockActions) return runUnavailable(resolved.action, route, 'Block action surface route is unavailable.');
       const opened = context.openBlockActions();
       return opened
         ? {

package/src/tools/agent-harness-mcp-metadata.ts

@@ -1,4 +1,5 @@
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessMcpArgs {
   readonly mcpServerId?: unknown;
@@ -76,9 +77,14 @@ function describeCandidate(server: McpServerRecord): Record<string, unknown> {
     trustMode: server.trustMode,
     role: server.role,
     schemaFreshness: server.schemaFreshness,
+    modelRoute: mcpServerModelRoute(),
   };
 }
 
+function mcpServerModelRoute(): string {
+  return 'agent_harness mode:"mcp_server" or mode:"run_command"';
+}
+
 function toolsByServer(tools: readonly McpToolRecord[]): ReadonlyMap<string, readonly McpToolRecord[]> {
   const grouped = new Map<string, McpToolRecord[]>();
   for (const tool of tools) {
@@ -108,6 +114,7 @@ function describeServer(
     allowedHostCount: server.allowedHosts.length,
     ...(server.quarantineReason ? { quarantineReason: server.quarantineReason } : {}),
     ...(server.quarantineDetail ? { quarantineDetail: server.quarantineDetail } : {}),
+    modelRoute: mcpServerModelRoute(),
     ...(options.lookup ? { lookup: options.lookup } : {}),
     ...(options.includeParameters ? {
       tools: tools.map((tool) => ({
@@ -115,8 +122,6 @@ function describeServer(
         ...(tool.description ? { description: tool.description } : {}),
       })),
       toolCount: tools.length,
-    } : { toolCount: tools.length }),
-    ...(options.includeParameters ? {
       policy: {
         effect: 'read-only',
         values: 'Server posture returns trust, role, connection, quarantine, and tool metadata; env values and secret config values are never returned.',
@@ -145,7 +150,10 @@ function describeServer(
           `/mcp remove ${server.name} --yes`,
         ],
       },
-    } : {}),
+    } : {
+      toolCount: tools.length,
+      summary: previewHarnessText(`${server.connected ? 'connected' : 'disconnected'} ${server.trustMode} ${server.schemaFreshness}`),
+    }),
   };
 }
 

package/src/tools/agent-harness-media-posture.ts

@@ -1,6 +1,7 @@
 import { buildAgentWorkspaceVoiceMediaReadiness } from '../input/agent-workspace-voice-media.ts';
 import type { AgentWorkspaceVoiceMediaProviderStatus } from '../input/agent-workspace-voice-media.ts';
 import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface AgentHarnessMediaArgs {
   readonly mediaProviderId?: unknown;
@@ -77,9 +78,14 @@ function describeProviderCandidate(provider: AgentWorkspaceVoiceMediaProviderSta
     label: provider.label,
     setupState: provider.setupState,
     selected: provider.selected,
+    modelRoute: mediaProviderModelRoute(),
   };
 }
 
+function mediaProviderModelRoute(): string {
+  return 'agent_media_generate or agent_harness mode:"media_provider"';
+}
+
 function statusMap(statuses: readonly RuntimeProviderStatus[]): ReadonlyMap<string, RuntimeProviderStatus> {
   return new Map(statuses.map((status) => [status.id, status]));
 }
@@ -103,27 +109,32 @@ function describeProvider(
     configuredSecretKeyNames: provider.configuredSecretKeys,
     missingSecretKeyNames: provider.missingSecretKeyOptions,
     nextStep: provider.nextStep,
+    modelRoute: mediaProviderModelRoute(),
     ...(runtimeStatus ? {
       runtimeStatus: {
         state: runtimeStatus.state,
         configured: runtimeStatus.configured,
-        ...(runtimeStatus.detail ? { detail: runtimeStatus.detail } : {}),
+        ...(options.includeParameters && runtimeStatus.detail ? { detail: runtimeStatus.detail } : {}),
       },
     } : {}),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    ...(options.includeParameters ? {
-      modelRoutes: {
-        inspectPosture: 'agent_harness mode:"media_posture"',
-        inspectProvider: 'agent_harness mode:"media_provider"',
-        generateMedia: 'agent_media_generate with confirm:true and explicitUserRequest',
-        ttsSettings: 'agent_harness settings/get_setting/set_setting for tts.provider, tts.voice, tts.llmProvider, and tts.llmModel',
-      },
-      policy: {
-        effect: 'read-only',
-        values: 'Provider posture returns capability, setup, selected, health, and safe environment key names only; secret values and media payloads are never returned.',
-        mutation: 'Media generation, voice enable/disable, TTS setting changes, and bundle export stay explicit confirmation-gated tool, setting, workspace, or slash-command flows.',
-      },
-    } : {}),
+    ...(options.includeParameters
+      ? {
+        modelRoutes: {
+          inspectPosture: 'agent_harness mode:"media_posture"',
+          inspectProvider: 'agent_harness mode:"media_provider"',
+          generateMedia: 'agent_media_generate with confirm:true and explicitUserRequest',
+          ttsSettings: 'agent_harness mode:"settings", mode:"get_setting", mode:"set_setting" for tts.provider, tts.voice, tts.llmProvider, and tts.llmModel',
+        },
+        policy: {
+          effect: 'read-only',
+          values: 'Provider posture returns capability, setup, selected, health, and safe environment key names only; secret values and media payloads are never returned.',
+          mutation: 'Media generation, voice enable/disable, TTS setting changes, and bundle export stay explicit confirmation-gated tool, setting, workspace, or slash-command flows.',
+        },
+      }
+      : {
+        summary: previewHarnessText(provider.nextStep || `${provider.domain} provider ${provider.setupState}`),
+      }),
   };
 }