@pellux/goodvibes-agent 1.0.35 → 1.0.37

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 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.',
-      },
-    } : {}),
+    ...(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}`),
+      }),
   };
 }
 

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

@@ -1,6 +1,7 @@
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { CommandContext } from '../input/command-registry.ts';
 import { resolveAgentConnectedHostConnection } from '../agent/routine-schedule-promotion.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
 
 export interface CommandExecutionPolicy {
   readonly effect: 'read-only' | 'local-state' | 'connected-host-state' | 'external-network' | 'ui-navigation' | 'session-lifecycle' | 'delegated-work' | 'mixed' | 'unknown';
@@ -269,7 +270,7 @@ export function describeCommandPolicy(commandName: string): CommandExecutionPoli
     return {
       effect: 'ui-navigation',
       confirmation,
-      preferredModelTool: root === 'bookmarks' ? agentHarnessModes('open_ui_surface') : agentHarnessModes('run_command'),
+      preferredModelTool: root === 'bookmarks' ? `${agentHarnessModes('open_ui_surface')} or ${agentHarnessModes('run_command')}` : agentHarnessModes('run_command'),
       boundary: 'Conversation display navigation mutates only the visible transcript view or scroll position.',
     };
   }
@@ -331,7 +332,7 @@ export function describeCliCommandPolicy(commandName: string): CommandExecutionP
     return {
       effect: 'unknown',
       confirmation,
-      boundary: 'Blocked package CLI token. Agent can launch its own TUI and use public connected-host routes, but it does not manage connected-host lifecycle, listeners, servers, bridges, remotes, web surfaces, or webhook listeners.',
+      boundary: 'Blocked package CLI token. Agent can launch its own TUI and use public connected-host routes, but it does not manage connected-host lifecycle, listeners, servers, route relays, remotes, web surfaces, or webhook listeners.',
     };
   }
   if (root === 'tui' || root === 'onboarding' || root === 'help' || root === 'version' || root === 'completion') {
@@ -341,7 +342,7 @@ export function describeCliCommandPolicy(commandName: string): CommandExecutionP
       preferredModelTool: root === 'onboarding' || root === 'tui'
         ? agentHarnessModes('workspace', 'workspace_actions', 'workspace_action', 'run_workspace_action')
         : agentHarnessModes('cli_commands', 'cli_command'),
-      boundary: 'Top-level CLI launch, setup, help, version, and completion commands are package entrypoint surfaces; use in-process workspace and slash-command bridges from the model when operating inside the TUI.',
+      boundary: 'Top-level CLI launch, setup, help, version, and completion commands are package entrypoint surfaces; use in-process workspace and slash-command routes from the model when operating inside the TUI.',
     };
   }
   if (root === 'run') {
@@ -405,9 +406,30 @@ function toolIsAvailable(toolRegistry: ToolRegistry, toolName: string): boolean
   return toolRegistry.getToolDefinitions().some((tool) => tool.name === toolName);
 }
 
+function connectedHostCapabilityModelRoute(capability: Record<string, unknown>): string {
+  const modelTools = Array.isArray(capability.modelTools)
+    ? capability.modelTools.filter((tool): tool is string => typeof tool === 'string')
+    : [];
+  if (modelTools.length > 0) return previewHarnessText(modelTools.join(' or '));
+  return 'agent_harness mode:"connected_host_capability"';
+}
+
+function blockedConnectedHostModelRoute(): string {
+  return 'agent_harness mode:"service_posture" or mode:"connected_host_status"';
+}
+
 export function connectedHostCapabilityMap(toolRegistry: ToolRegistry): readonly Record<string, unknown>[] {
   const withAvailability = (capability: Record<string, unknown> & { readonly modelTools: readonly string[] }): Record<string, unknown> => ({
     ...capability,
+    modelRoute: connectedHostCapabilityModelRoute(capability),
+    harnessRoute: 'agent_harness mode:"connected_host_capability"',
+    modelAccess: {
+      inspectCapability: 'agent_harness mode:"connected_host_capability"',
+      liveStatus: 'agent_harness mode:"connected_host_status"',
+      endpointPosture: 'agent_harness mode:"service_posture"',
+      routeFamilies: 'agent_harness mode:"connected_host" includeParameters:true',
+      operate: connectedHostCapabilityModelRoute(capability),
+    },
     available: capability.modelTools.every((toolName) => toolIsAvailable(toolRegistry, toolName)),
   });
   return [
@@ -510,6 +532,7 @@ export function connectedHostRouteFamilies(): readonly Record<string, unknown>[]
       id: 'agent-knowledge',
       prefixes: ['/api/goodvibes-agent/knowledge/*'],
       modelTools: ['agent_knowledge', 'agent_knowledge_ingest'],
+      modelRoute: 'agent_knowledge or agent_knowledge_ingest',
       boundary: 'Agent-owned knowledge segment only; no fallback to default or non-Agent knowledge.',
     },
     {
@@ -522,24 +545,28 @@ export function connectedHostRouteFamilies(): readonly Record<string, unknown>[]
         '/api/runtime/scheduler',
       ],
       modelTools: ['agent_operator_briefing'],
+      modelRoute: 'agent_operator_briefing',
       boundary: 'Read-only public operator briefing routes.',
     },
     {
       id: 'operator-actions',
       routes: ['public operator action methods for approvals, automation jobs, automation runs, and schedules'],
       modelTools: ['agent_operator_action'],
+      modelRoute: 'agent_operator_action',
       boundary: 'Allowlisted confirmed mutations only; no arbitrary route invocation.',
     },
     {
       id: 'delivery',
       routes: ['configured channel, notification, and delivery targets'],
       modelTools: ['agent_channel_send', 'agent_notify'],
+      modelRoute: 'agent_channel_send or agent_notify',
       boundary: 'Explicit user-approved delivery only; no route/account creation.',
     },
     {
       id: 'connected-schedules',
       routes: ['public schedule creation/run routes'],
       modelTools: ['agent_reminder_schedule', 'agent_operator_action'],
+      modelRoute: 'agent_reminder_schedule or agent_operator_action',
       boundary: 'Connected schedules only; no hidden local scheduler or separate Agent job.',
     },
   ];
@@ -582,6 +609,9 @@ function describeConnectedHostCapabilityCandidates(
     capabilityId: typeof entry.capability.id === 'string' ? entry.capability.id : '',
     purpose: typeof entry.capability.purpose === 'string' ? entry.capability.purpose : undefined,
     reason: typeof entry.capability.reason === 'string' ? entry.capability.reason : undefined,
+    modelRoute: entry.status === 'allowed'
+      ? connectedHostCapabilityModelRoute(entry.capability)
+      : blockedConnectedHostModelRoute(),
   }));
 }
 
@@ -590,18 +620,36 @@ function connectedHostCapabilityDetail(entry: { readonly status: 'allowed' | 'bl
     return {
       status: 'allowed',
       capability: entry.capability,
+      modelRoute: connectedHostCapabilityModelRoute(entry.capability),
+      harnessRoute: 'agent_harness mode:"connected_host_capability"',
       relatedRouteFamilies: relatedConnectedHostRouteFamilies(entry.capability),
+      modelAccess: {
+        inspectCapability: 'agent_harness mode:"connected_host_capability"',
+        connectedHostInventory: 'agent_harness mode:"connected_host" includeParameters:true',
+        liveStatus: 'agent_harness mode:"connected_host_status"',
+        endpointPosture: 'agent_harness mode:"service_posture"',
+        operate: connectedHostCapabilityModelRoute(entry.capability),
+      },
       operatorMethodMode: 'Use agent_harness mode:"operator_methods" for the public operator and Agent Knowledge method catalog. Use mode:"operator_method" for one method.',
       servicePostureMode: 'Use agent_harness mode:"service_posture" for endpoint binding, network-facing posture, issue, and redacted-log diagnostics. Use mode:"service_endpoint" for one endpoint.',
-      statusMode: 'Use agent_harness mode:"connected_host_status" for live read-only reachability, SDK compatibility, token posture, and Agent Knowledge route readiness.',
-      boundary: 'Use only the listed first-class model tools, slash-command families, and workspace categories. Mutations still require explicit confirmation through those tools or command bridges.',
+      statusMode: 'Use agent_harness mode:"connected_host_status" for live read-only reachability, token posture, and Agent Knowledge route readiness.',
+      boundary: 'Use only the listed first-class model tools, slash-command families, and workspace categories. Mutations still require explicit confirmation through those tools or command routes.',
     };
   }
   return {
     status: 'blocked',
     capability: entry.capability,
+    modelRoute: blockedConnectedHostModelRoute(),
+    harnessRoute: 'agent_harness mode:"connected_host_capability"',
     allowed: false,
     available: false,
+    modelAccess: {
+      inspectCapability: 'agent_harness mode:"connected_host_capability"',
+      connectedHostInventory: 'agent_harness mode:"connected_host" includeParameters:true',
+      liveStatus: 'agent_harness mode:"connected_host_status"',
+      endpointPosture: 'agent_harness mode:"service_posture"',
+      operate: 'not exposed',
+    },
     boundary: 'This connected-host surface is intentionally not exposed to the model as an Agent operation.',
     servicePostureMode: 'Use agent_harness mode:"service_posture" or mode:"service_endpoint" only for read-only endpoint diagnostics.',
     statusMode: 'Use agent_harness mode:"connected_host_status" only for read-only readiness diagnostics.',
@@ -652,6 +700,17 @@ export function connectedHostSummary(
       operatorMethods: agentHarnessModes('operator_methods', 'operator_method'),
       liveStatus: agentHarnessModes('connected_host_status'),
       capabilityDetail: agentHarnessModes('connected_host_capability'),
+      daemonAliases: agentHarnessModes('daemon', 'daemon_status'),
+    },
+    modelRoute: 'agent_harness mode:"connected_host" or mode:"connected_host_capability"',
+    modelAccess: {
+      inventory: 'agent_harness mode:"connected_host" includeParameters:true',
+      liveStatus: 'agent_harness mode:"connected_host_status"',
+      capabilityDetail: 'agent_harness mode:"connected_host_capability" capabilityId:"..."',
+      servicePosture: 'agent_harness mode:"service_posture"',
+      daemonAliases: 'agent_harness mode:"daemon" or mode:"daemon_status"',
+      daemonStatusAlias: 'agent_harness mode:"daemon_status"',
+      lifecycleBlocked: 'start, stop, restart, install, upgrade, expose-listener, and listener mutation are not exposed through Agent.',
     },
     counts: {
       routeFamilies: routeFamilies.length,
@@ -672,22 +731,54 @@ export function blockedConnectedHostCapabilities(): readonly Record<string, unkn
     {
       id: 'connected-host-lifecycle',
       blocked: ['start', 'stop', 'restart', 'install', 'upgrade', 'expose-listener', 'mutate-listener'],
+      modelRoute: blockedConnectedHostModelRoute(),
+      harnessRoute: 'agent_harness mode:"connected_host_capability"',
+      modelAccess: {
+        inspectCapability: 'agent_harness mode:"connected_host_capability"',
+        liveStatus: 'agent_harness mode:"connected_host_status"',
+        endpointPosture: 'agent_harness mode:"service_posture"',
+        operate: 'not exposed',
+      },
       reason: 'The connected host and listener are externally owned by GoodVibes; Agent can use public operator routes but not manage hosting.',
     },
     {
       id: 'non-agent-knowledge',
       blocked: ['default-knowledge', 'non-agent-knowledge-segments', 'fallback-knowledge'],
+      modelRoute: blockedConnectedHostModelRoute(),
+      harnessRoute: 'agent_harness mode:"connected_host_capability"',
+      modelAccess: {
+        inspectCapability: 'agent_harness mode:"connected_host_capability"',
+        allowedAgentKnowledge: 'agent_knowledge or agent_knowledge_ingest',
+        liveStatus: 'agent_harness mode:"connected_host_status"',
+        operate: 'not exposed',
+      },
       reason: 'Agent model tools must stay inside the isolated Agent Knowledge route family.',
     },
     {
       id: 'hidden-background-work',
       blocked: ['separate-agent-jobs', 'implicit-delegated-review', 'local-schedulers'],
+      modelRoute: blockedConnectedHostModelRoute(),
+      harnessRoute: 'agent_harness mode:"connected_host_capability"',
+      modelAccess: {
+        inspectCapability: 'agent_harness mode:"connected_host_capability"',
+        allowedDelegation: 'agent_harness mode:"delegation_posture"',
+        liveStatus: 'agent_harness mode:"connected_host_status"',
+        operate: 'not exposed',
+      },
       reason: 'All model work is serial and visible unless the user explicitly requests delegation through an exposed surface.',
     },
     {
       id: 'arbitrary-connected-host-mutations',
       blocked: ['route-discovery-mutation', 'account-creation', 'automation-definition-creation'],
-      reason: 'Only the documented allowlisted model tools and slash-command bridges are exposed.',
+      modelRoute: blockedConnectedHostModelRoute(),
+      harnessRoute: 'agent_harness mode:"connected_host_capability"',
+      modelAccess: {
+        inspectCapability: 'agent_harness mode:"connected_host_capability"',
+        allowedActions: 'agent_operator_action for documented allowlisted mutations only',
+        liveStatus: 'agent_harness mode:"connected_host_status"',
+        operate: 'not exposed',
+      },
+      reason: 'Only the documented allowlisted model tools and slash-command routes are exposed.',
     },
   ];
 }