@pellux/goodvibes-agent 1.0.33 → 1.0.34

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

@@ -132,25 +132,25 @@ function describeTarget(
     ...(target.hasQuery !== undefined ? { hasQuery: target.hasQuery } : {}),
     value: '<redacted>',
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    policy: {
-      effect: 'read-only',
-      values: 'Full webhook URLs are not returned because they can contain bearer tokens or secret path/query values.',
-      delivery: 'Use agent_notify only for one explicit, confirmed notification requested by the user.',
-      management: 'Use confirmed /notify mirrors only when the user explicitly asks to add, remove, clear, test, or send notification targets.',
-    },
-    modelAccess: {
-      sendTool: 'agent_notify',
-      listCommand: '/notify list',
-      addCommand: '/notify add <url> --yes',
-      removeCommand: '/notify remove <url> --yes',
-      clearCommand: '/notify clear --yes',
-      testCommand: '/notify test --yes',
-      settingsCategory: 'notifications.webhookUrls',
-      ...(options.includeParameters ? {
+    ...(options.includeParameters ? {
+      policy: {
+        effect: 'read-only',
+        values: 'Full webhook URLs are not returned because they can contain bearer tokens or secret path/query values.',
+        delivery: 'Use agent_notify only for one explicit, confirmed notification requested by the user.',
+        management: 'Use confirmed /notify mirrors only when the user explicitly asks to add, remove, clear, test, or send notification targets.',
+      },
+      modelAccess: {
+        sendTool: 'agent_notify',
+        listCommand: '/notify list',
+        addCommand: '/notify add <url> --yes',
+        removeCommand: '/notify remove <url> --yes',
+        clearCommand: '/notify clear --yes',
+        testCommand: '/notify test --yes',
+        settingsCategory: 'notifications.webhookUrls',
         targetValueRequiredForRemove: true,
         targetValuePolicy: 'Ask the user for the exact webhook URL before removing one target; do not infer it from redacted metadata.',
-      } : {}),
-    },
+      },
+    } : {}),
   };
 }
 

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

@@ -77,7 +77,7 @@ function pairingRoutes(): readonly PairingRoute[] {
       detail: 'Visible companion pairing route that prints QR setup details in the Agent TUI without printing the raw token.',
       effect: 'external-network',
       command: '/pair',
-      harnessRoute: 'agent_harness mode:"run_command" command:"/pair" confirm:true',
+      harnessRoute: 'agent_harness mode:"run_command" command:"/pair" confirm:true explicitUserRequest:"..."',
       requiresConfirmation: true,
     },
     {
@@ -86,7 +86,7 @@ function pairingRoutes(): readonly PairingRoute[] {
       detail: 'Explicitly confirmed fallback route that prints the raw companion token only when the user asks for manual setup.',
       effect: 'confirmation-gated-secret-display',
       command: '/pair --show-token --yes',
-      harnessRoute: 'agent_harness mode:"run_command" command:"/pair --show-token --yes" confirm:true',
+      harnessRoute: 'agent_harness mode:"run_command" command:"/pair --show-token --yes" confirm:true explicitUserRequest:"..."',
       requiresConfirmation: true,
     },
     {
@@ -166,12 +166,12 @@ function describeRoute(route: PairingRoute, options: { readonly includeParameter
     ...(route.capabilityIds ? { capabilityIds: route.capabilityIds } : {}),
     requiresConfirmation: route.requiresConfirmation === true,
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    policy: {
-      effect: route.effect,
-      values: 'Pairing posture returns endpoint binding and token fingerprint only; raw companion tokens and QR payloads are never returned by this read-only mode.',
-      mutation: 'Pairing display, manual token display, companion connection, channel sends, provider/model changes, approval actions, and attachment flows stay explicit visible user flows.',
-    },
     ...(options.includeParameters ? {
+      policy: {
+        effect: route.effect,
+        values: 'Pairing posture returns endpoint binding and token fingerprint only; raw companion tokens and QR payloads are never returned by this read-only mode.',
+        mutation: 'Pairing display, manual token display, companion connection, channel sends, provider/model changes, approval actions, and attachment flows stay explicit visible user flows.',
+      },
       modelAccess: {
         inspectPairing: 'agent_harness mode:"pairing_posture"',
         inspectRoute: 'agent_harness mode:"pairing_route"',

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

@@ -7,6 +7,7 @@ export interface AgentHarnessPanelArgs {
   readonly panelId?: unknown;
   readonly target?: unknown;
   readonly category?: unknown;
+  readonly includeParameters?: unknown;
   readonly limit?: unknown;
   readonly pane?: unknown;
 }
@@ -39,6 +40,11 @@ function readLimit(value: unknown, fallback: number): number {
   return Math.max(1, Math.min(500, Math.trunc(parsed)));
 }
 
+function previewText(value: string, maxLength = 120): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+}
+
 function panelManager(context: CommandContext) {
   return context.workspace.panelManager ?? null;
 }
@@ -50,6 +56,7 @@ function panelMatches(panel: Record<string, unknown>, query: string): boolean {
     panel.name,
     panel.category,
     panel.description,
+    panel.summary,
     panel.workspaceRoute,
   ].map((value) => typeof value === 'object' ? JSON.stringify(value) : String(value ?? '')).join('\n').toLowerCase().includes(query.toLowerCase());
 }
@@ -69,7 +76,7 @@ function panelCandidate(registration: PanelRegistration): Record<string, unknown
     id: registration.id,
     name: registration.name,
     category: registration.category,
-    description: registration.description,
+    summary: previewText(registration.description),
     workspaceRoute: {
       categoryId: agentWorkspaceCategoryForPanel(registration.id),
       command: agentWorkspaceCommandForPanel(registration.id),
@@ -103,7 +110,11 @@ function resolveHarnessPanel(context: CommandContext, args: AgentHarnessPanelArg
   return null;
 }
 
-function describePanelRegistration(context: CommandContext, registration: PanelRegistration, lookup?: PanelLookup): Record<string, unknown> {
+function describePanelRegistration(
+  context: CommandContext,
+  registration: PanelRegistration,
+  options: { readonly includeParameters?: boolean; readonly lookup?: PanelLookup } = {},
+): Record<string, unknown> {
   const manager = panelManager(context);
   const openPanel = manager?.getPanel(registration.id) ?? null;
   const pane = manager?.getPaneOf(registration.id) ?? null;
@@ -113,8 +124,8 @@ function describePanelRegistration(context: CommandContext, registration: PanelR
     name: registration.name,
     icon: registration.icon,
     category: registration.category,
-    description: registration.description,
-    ...(lookup ? { lookup } : {}),
+    ...(options.includeParameters ? { description: registration.description } : { summary: previewText(registration.description) }),
+    ...(options.lookup ? { lookup: options.lookup } : {}),
     preload: registration.preload === true,
     open: openPanel !== null,
     pane,
@@ -124,11 +135,13 @@ function describePanelRegistration(context: CommandContext, registration: PanelR
       categoryId: agentWorkspaceCategoryForPanel(registration.id),
       command: agentWorkspaceCommandForPanel(registration.id),
     },
-    policy: {
-      effect: 'ui-navigation',
-      confirmation: 'agent_harness mode:"open_panel" requires confirm:true and explicitUserRequest.',
-      boundary: 'Panels are Agent/TUI operator views. The model can inspect panel catalog/open state; panel routing uses the existing Agent workspace bridge and does not mutate connected-host lifecycle.',
-    },
+    ...(options.includeParameters ? {
+      policy: {
+        effect: 'ui-navigation',
+        confirmation: 'agent_harness mode:"open_panel" requires confirm:true and explicitUserRequest.',
+        boundary: 'Panels are Agent/TUI operator views. The model can inspect panel catalog/open state; panel routing uses the existing Agent workspace bridge and does not mutate connected-host lifecycle.',
+      },
+    } : {}),
   };
 }
 
@@ -142,8 +155,9 @@ export function listHarnessPanels(context: CommandContext, args: AgentHarnessPan
   const query = readString(args.query);
   const category = readString(args.category);
   const limit = readLimit(args.limit, 200);
+  const includeParameters = args.includeParameters === true;
   return manager.getRegisteredTypes()
-    .map((registration) => describePanelRegistration(context, registration))
+    .map((registration) => describePanelRegistration(context, registration, { includeParameters }))
     .filter((panel) => !category || panel.category === category)
     .filter((panel) => panelMatches(panel, query))
     .sort((a, b) => String(a.id).localeCompare(String(b.id)))
@@ -152,7 +166,7 @@ export function listHarnessPanels(context: CommandContext, args: AgentHarnessPan
 
 export function describeHarnessPanel(context: CommandContext, args: AgentHarnessPanelArgs): Record<string, unknown> | null {
   const resolved = resolveHarnessPanel(context, args);
-  if (resolved?.status === 'found') return describePanelRegistration(context, resolved.registration, resolved.lookup);
+  if (resolved?.status === 'found') return describePanelRegistration(context, resolved.registration, { includeParameters: true, lookup: resolved.lookup });
   if (resolved?.status === 'ambiguous') {
     return { status: 'ambiguous', input: resolved.input, candidates: resolved.candidates };
   }
@@ -171,7 +185,7 @@ export function openHarnessPanel(context: CommandContext, args: AgentHarnessPane
       availablePanels: listHarnessPanels(context, { limit: 50 }).map((entry) => entry.id),
     };
   }
-  const panel = describePanelRegistration(context, resolved.registration, resolved.lookup);
+  const panel = describePanelRegistration(context, resolved.registration, { includeParameters: true, lookup: resolved.lookup });
   const requestedPane = readString(args.pane);
   const pane = requestedPane === 'bottom' || requestedPane === 'top' ? requestedPane : undefined;
   if (!context.showPanel) {

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

@@ -97,42 +97,44 @@ function describeAccount(
     ...(account.fallbackRisk ? { fallbackRisk: account.fallbackRisk } : {}),
     ...(account.expiresAt ? { expiresAt: new Date(account.expiresAt).toISOString() } : {}),
     ...(account.tokenType ? { tokenType: account.tokenType } : {}),
-    routeRecords: account.routeRecords.map((route) => ({
-      route: route.route,
-      usable: route.usable,
-      freshness: route.freshness,
-      detail: route.detail,
-      issues: route.issues,
-    })),
-    usageWindows: account.usageWindows,
-    issues: account.issues,
-    notes: account.notes,
-    recommendedActions: account.recommendedActions,
+    issueCount: account.issues.length,
+    recommendedActionCount: account.recommendedActions.length,
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    policy: {
-      effect: 'read-only',
-      values: 'Provider account posture reports route and freshness metadata only; raw tokens, authorization codes, and secret values are never returned.',
-      mutation: 'Provider login, logout, subscription bundle export, and account repair actions stay explicit confirmation-gated workspace or slash-command flows.',
-    },
-    modelAccess: {
-      reviewCommand: '/accounts review',
-      showCommand: `/accounts show ${account.providerId}`,
-      routesCommand: `/accounts routes ${account.providerId}`,
-      repairCommand: `/accounts repair ${account.providerId}`,
-      subscriptionInspectCommand: `/subscription inspect ${account.providerId}`,
-      workspaceActions: [
-        'provider-accounts',
-        'provider-account-repair',
-        'subscription-review',
-        'subscription-inspect',
-      ],
-      ...(options.includeParameters ? {
+    ...(options.includeParameters ? {
+      routeRecords: account.routeRecords.map((route) => ({
+        route: route.route,
+        usable: route.usable,
+        freshness: route.freshness,
+        detail: route.detail,
+        issues: route.issues,
+      })),
+      usageWindows: account.usageWindows,
+      issues: account.issues,
+      notes: account.notes,
+      recommendedActions: account.recommendedActions,
+      policy: {
+        effect: 'read-only',
+        values: 'Provider account posture reports route and freshness metadata only; raw tokens, authorization codes, and secret values are never returned.',
+        mutation: 'Provider login, logout, subscription bundle export, and account repair actions stay explicit confirmation-gated workspace or slash-command flows.',
+      },
+      modelAccess: {
+        reviewCommand: '/accounts review',
+        showCommand: `/accounts show ${account.providerId}`,
+        routesCommand: `/accounts routes ${account.providerId}`,
+        repairCommand: `/accounts repair ${account.providerId}`,
+        subscriptionInspectCommand: `/subscription inspect ${account.providerId}`,
+        workspaceActions: [
+          'provider-accounts',
+          'provider-account-repair',
+          'subscription-review',
+          'subscription-inspect',
+        ],
         loginStartCommand: `/subscription login ${account.providerId} start --yes`,
         loginFinishCommand: `/subscription login ${account.providerId} finish <code-or-url> --yes`,
         logoutCommand: `/subscription logout ${account.providerId} --yes`,
         confirmationRequired: true,
-      } : {}),
-    },
+      },
+    } : {}),
   };
 }
 

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

@@ -166,11 +166,13 @@ function describeFinding(finding: SecurityFinding, includeParameters: boolean, l
     route: finding.route,
     ...(lookup ? { lookup } : {}),
     ...(includeParameters && finding.detail ? { detail: finding.detail } : {}),
-    policy: {
-      effect: 'read-only',
-      values: 'Security posture returns counts, labels, policy ids, route names, and redacted bundle summaries only; token values, secret values, and raw config values are never returned.',
-      mutation: 'Token rotation, policy changes, MCP trust changes, bundle export/import, auth repair, and voice enable/disable stay explicit confirmation-gated workspace or slash-command flows.',
-    },
+    ...(includeParameters ? {
+      policy: {
+        effect: 'read-only',
+        values: 'Security posture returns counts, labels, policy ids, route names, and redacted bundle summaries only; token values, secret values, and raw config values are never returned.',
+        mutation: 'Token rotation, policy changes, MCP trust changes, bundle export/import, auth repair, and voice enable/disable stay explicit confirmation-gated workspace or slash-command flows.',
+      },
+    } : {}),
   };
 }
 
@@ -463,7 +465,7 @@ export async function securityPostureSummary(context: CommandContext, args: Agen
     returned: filtered.length,
     total: findings.length,
     policy: 'Read-only security posture. Token rotation, policy changes, MCP trust changes, bundle export/import, auth repair, and voice enable/disable remain confirmation-gated workspace or slash-command flows.',
-    modelAccess: {
+    ...(args.includeParameters === true ? { modelAccess: {
       reviewCommand: '/security review',
       tokensCommand: '/security tokens',
       attackPathsCommand: '/security attack-paths',
@@ -471,7 +473,7 @@ export async function securityPostureSummary(context: CommandContext, args: Agen
       authReviewCommand: '/auth review',
       bundleCatalogMode: 'support_bundles',
       singleFindingMode: 'security_finding',
-    },
+    } } : {}),
   };
 }
 

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

@@ -65,7 +65,10 @@ function summarizeLog(posture: CliServicePosture, includeTail: boolean): Record<
   };
 }
 
-function describeEndpoint(endpoint: CliServiceEndpointPosture, lookup?: Record<string, unknown>): Record<string, unknown> {
+function describeEndpoint(
+  endpoint: CliServiceEndpointPosture,
+  options: { readonly includeParameters?: boolean; readonly lookup?: Record<string, unknown> } = {},
+): Record<string, unknown> {
   return {
     id: endpoint.id,
     label: endpoint.label,
@@ -74,13 +77,15 @@ function describeEndpoint(endpoint: CliServiceEndpointPosture, lookup?: Record<s
     bindPosture: endpoint.bindPosture,
     networkFacing: endpoint.networkFacing,
     ...(endpoint.reachable !== undefined ? { reachable: endpoint.reachable } : {}),
-    ...(lookup ? { lookup } : {}),
-    policy: {
-      effect: 'read-only',
-      modelOperation: 'Inspect endpoint binding, network-facing posture, and optional reachability only.',
-      lifecycle: 'GoodVibes Agent does not start, stop, restart, install, expose, or mutate connected-host listeners.',
-      settings: 'Use agent_harness settings/get_setting for read-only inspection of endpoint settings; connected-host lifecycle/listener settings stay locked in Agent.',
-    },
+    ...(options.lookup ? { lookup: options.lookup } : {}),
+    ...(options.includeParameters ? {
+      policy: {
+        effect: 'read-only',
+        modelOperation: 'Inspect endpoint binding, network-facing posture, and optional reachability only.',
+        lifecycle: 'GoodVibes Agent does not start, stop, restart, install, expose, or mutate connected-host listeners.',
+        settings: 'Use agent_harness settings/get_setting for read-only inspection of endpoint settings; connected-host lifecycle/listener settings stay locked in Agent.',
+      },
+    } : {}),
   };
 }
 
@@ -118,6 +123,7 @@ function endpointSearchText(endpoint: CliServiceEndpointPosture): string {
 function resolveEndpoint(
   posture: CliServicePosture,
   args: AgentHarnessServicePostureArgs,
+  options: { readonly includeParameters?: boolean } = {},
 ): ServiceEndpointResolution {
   const lookup = endpointLookupFromArgs(args);
   if (!lookup) {
@@ -130,19 +136,19 @@ function resolveEndpoint(
   const normalized = lookup.input.toLowerCase();
   const exact = endpoints.find((endpoint) => endpoint.id === lookup.input);
   if (exact) {
-    return { status: 'found', endpoint: describeEndpoint(exact, { ...lookup, resolvedBy: 'id' }) };
+    return { status: 'found', endpoint: describeEndpoint(exact, { includeParameters: options.includeParameters, lookup: { ...lookup, resolvedBy: 'id' } }) };
   }
   const insensitive = endpoints.find((endpoint) => endpoint.id.toLowerCase() === normalized);
   if (insensitive) {
-    return { status: 'found', endpoint: describeEndpoint(insensitive, { ...lookup, resolvedBy: 'case-insensitive-id' }) };
+    return { status: 'found', endpoint: describeEndpoint(insensitive, { includeParameters: options.includeParameters, lookup: { ...lookup, resolvedBy: 'case-insensitive-id' } }) };
   }
   const label = endpoints.find((endpoint) => endpoint.label.toLowerCase() === normalized);
   if (label) {
-    return { status: 'found', endpoint: describeEndpoint(label, { ...lookup, resolvedBy: 'label' }) };
+    return { status: 'found', endpoint: describeEndpoint(label, { includeParameters: options.includeParameters, lookup: { ...lookup, resolvedBy: 'label' } }) };
   }
   const searched = endpoints.filter((endpoint) => endpointSearchText(endpoint).includes(normalized));
   if (searched.length === 1) {
-    return { status: 'found', endpoint: describeEndpoint(searched[0]!, { ...lookup, resolvedBy: 'search' }) };
+    return { status: 'found', endpoint: describeEndpoint(searched[0]!, { includeParameters: options.includeParameters, lookup: { ...lookup, resolvedBy: 'search' } }) };
   }
   if (searched.length > 1) {
     return {
@@ -178,14 +184,14 @@ export async function servicePostureSummary(
     lifecycle: 'GoodVibes Agent reports connected-host/service posture but does not start, stop, restart, install, expose, or mutate host listeners.',
     config: posture.config,
     managed: posture.managed,
-    endpoints: posture.endpoints.map((endpoint) => describeEndpoint(endpoint)),
+    endpoints: posture.endpoints.map((endpoint) => describeEndpoint(endpoint, { includeParameters: includeDetails })),
     log: summarizeLog(posture, includeDetails),
     issues: posture.issues,
-    modelAccess: {
+    ...(includeDetails ? { modelAccess: {
       endpointLookup: 'Use mode:"service_endpoint" with endpointId, target, or query to inspect one endpoint.',
       settings: 'Use mode:"settings" with includeHidden:true for endpoint setting descriptors. Host-owned listener settings remain read-only.',
       liveHostStatus: 'Use mode:"connected_host_status" for SDK compatibility, token posture, and Agent Knowledge route readiness.',
-    },
+    } } : {}),
   };
 }
 
@@ -197,5 +203,5 @@ export async function describeHarnessServiceEndpoint(
     ...servicePostureOptions(args),
     probe: true,
   });
-  return resolveEndpoint(posture, args);
+  return resolveEndpoint(posture, args, { includeParameters: true });
 }

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

@@ -129,11 +129,13 @@ function describeSession(
       },
     } : {}),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    policy: {
-      effect: 'read-only',
-      values: 'Session posture returns saved-session metadata, search counts, optional snippets, return-context counts, bookmark counts, and saved bookmark file counts.',
-      mutation: 'Session save, rename, fork, resume, export, delete, bookmark toggles, and bookmark file writes remain visible workspace or slash-command flows with confirmation where mutating.',
-    },
+    ...(options.includeParameters ? {
+      policy: {
+        effect: 'read-only',
+        values: 'Session posture returns saved-session metadata, search counts, optional snippets, return-context counts, bookmark counts, and saved bookmark file counts.',
+        mutation: 'Session save, rename, fork, resume, export, delete, bookmark toggles, and bookmark file writes remain visible workspace or slash-command flows with confirmation where mutating.',
+      },
+    } : {}),
   };
 }
 
@@ -176,9 +178,9 @@ function bookmarkSummary(context: CommandContext): Record<string, unknown> {
     bookmarks: manager.list().length,
     savedFiles: manager.listSavedFiles().length,
     modelRoutes: {
-      visibleBookmarkPicker: 'agent_harness open_ui_surface surfaceId:"bookmarks"',
+      visibleBookmarkPicker: 'agent_harness mode:"open_ui_surface" surfaceId:"bookmarks" confirm:true explicitUserRequest:"..."',
       command: '/bookmarks',
-      importIntoKnowledge: 'agent_knowledge_ingest sourceKind:"bookmarks_file" with confirm:true',
+      importIntoKnowledge: 'agent_knowledge_ingest sourceKind:"bookmarks_file" confirm:true explicitUserRequest:"..."',
     },
   };
 }

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

@@ -178,16 +178,16 @@ function describeItem(
     detail: item.detail,
     signals: signalsForItem(item, snapshot),
     ...(options.lookup ? { lookup: options.lookup } : {}),
-    policy: {
-      effect: 'read-only',
-      values: 'Setup posture returns onboarding readiness, counts, safe setting keys, and route metadata only; secret values and raw provider tokens are never returned.',
-      mutation: 'Setup apply, provider auth, local behavior import/create, channel delivery, and starter profile changes stay visible workspace, settings, slash-command, or first-class tool flows.',
-    },
     ...(options.includeParameters ? {
+      policy: {
+        effect: 'read-only',
+        values: 'Setup posture returns onboarding readiness, counts, safe setting keys, and route metadata only; secret values and raw provider tokens are never returned.',
+        mutation: 'Setup apply, provider auth, local behavior import/create, channel delivery, and starter profile changes stay visible workspace, settings, slash-command, or first-class tool flows.',
+      },
       modelAccess: {
         inspectSetup: 'agent_harness mode:"setup_posture"',
         inspectSetupItem: 'agent_harness mode:"setup_item"',
-        openOnboarding: 'agent_harness mode:"open_ui_surface" surfaceId:"onboarding" confirm:true',
+        openOnboarding: 'agent_harness mode:"open_ui_surface" surfaceId:"onboarding" confirm:true explicitUserRequest:"..."',
         setupWorkspace: 'agent_harness mode:"workspace_action" target:"setup"',
         settings: 'agent_harness modes settings/get_setting/set_setting/reset_setting',
         providerRouting: 'agent_harness mode:"model_routing"',

package/src/tools/agent-harness-tool-schema.ts

@@ -18,6 +18,7 @@ export const AGENT_HARNESS_MODES = [
   'operator_methods', 'operator_method',
   'service_posture', 'service_endpoint',
   'connected_host', 'connected_host_status', 'connected_host_capability',
+  'daemon', 'daemon_status',
 ] as const;
 
 const KEY_COMBO_PARAMETER_SCHEMA = {

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

@@ -127,6 +127,67 @@ function output(value: unknown): { readonly success: true; readonly output: stri
 
 function error(message: string): { readonly success: false; readonly error: string } { return { success: false, error: message }; }
 
+function compactHarnessModeGuide(): Record<string, unknown> {
+  return {
+    discover: [
+      'cli_commands', 'panels', 'ui_surfaces', 'shortcuts', 'keybindings',
+      'commands', 'channels', 'notifications', 'provider_accounts', 'mcp_servers',
+      'setup_posture', 'model_routing', 'pairing_posture', 'delegation_posture',
+      'security_posture', 'support_bundles', 'media_posture', 'sessions',
+      'settings', 'workspace', 'workspace_categories', 'workspace_actions',
+      'tools', 'release_evidence', 'release_readiness', 'operator_methods',
+      'service_posture', 'connected_host', 'daemon',
+    ],
+    inspect: [
+      'cli_command', 'panel', 'ui_surface', 'keybinding', 'command', 'channel',
+      'notification_target', 'provider_account', 'mcp_server', 'setup_item',
+      'model_route', 'pairing_route', 'delegation_route', 'security_finding',
+      'support_bundle', 'media_provider', 'session', 'get_setting',
+      'workspace_action', 'tool', 'release_evidence_artifact',
+      'release_readiness_item', 'operator_method', 'service_endpoint',
+      'connected_host_capability', 'connected_host_status', 'daemon_status',
+    ],
+    effects: [
+      'open_panel', 'open_ui_surface', 'run_keybinding', 'set_keybinding',
+      'reset_keybinding', 'run_command', 'set_setting', 'reset_setting',
+      'run_workspace_action',
+    ],
+    pattern: 'Use query|target for search, exact ids for inspect modes, and confirm:true plus explicitUserRequest for effects.',
+  };
+}
+
+function detailedHarnessModelAccessGuide(): Record<string, string> {
+  return {
+    cliCommands: 'List mode:"cli_commands"; inspect mode:"cli_command" with cliCommand|commandName|query. Discovery only.',
+    panels: 'List mode:"panels"; inspect mode:"panel"; navigate mode:"open_panel" with confirm:true and explicitUserRequest.',
+    uiSurfaces: 'List mode:"ui_surfaces"; inspect mode:"ui_surface"; navigate mode:"open_ui_surface" with confirmation.',
+    shortcuts: 'List mode:"shortcuts"; inspect mode:"keybinding"; run mode:"run_keybinding"; edit with set_keybinding/reset_keybinding and confirmation.',
+    slashCommands: 'List mode:"commands"; inspect mode:"command"; execute mode:"run_command" with confirmation.',
+    channels: 'List mode:"channels"; inspect mode:"channel"; deliver with agent_channel_send and confirmation.',
+    notifications: 'List mode:"notifications"; inspect mode:"notification_target"; deliver with agent_notify and confirmation.',
+    providerAccounts: 'List mode:"provider_accounts"; inspect mode:"provider_account"; auth changes stay confirmed workspace/command flows.',
+    mcpServers: 'List mode:"mcp_servers"; inspect mode:"mcp_server"; trust/server changes stay confirmed workspace/command flows.',
+    setupPosture: 'List mode:"setup_posture"; inspect mode:"setup_item"; setup mutations stay confirmed visible flows.',
+    modelRouting: 'List mode:"model_routing"; inspect mode:"model_route"; selection and provider edits stay confirmed visible flows.',
+    pairingPosture: 'List mode:"pairing_posture"; inspect mode:"pairing_route"; raw token/QR and pairing effects stay visible user flows.',
+    delegationPosture: 'List mode:"delegation_posture"; inspect mode:"delegation_route"; delegated submission stays confirmed visible flow.',
+    securityPosture: 'List mode:"security_posture"; inspect mode:"security_finding"; mutate only through confirmed security routes.',
+    supportBundles: 'List mode:"support_bundles"; inspect mode:"support_bundle"; export/import stays confirmation-gated.',
+    mediaPosture: 'List mode:"media_posture"; inspect mode:"media_provider"; generate with agent_media_generate and confirmation.',
+    sessions: 'List mode:"sessions"; inspect mode:"session"; save/resume/export/delete stays visible confirmed flow.',
+    workspace: 'List mode:"workspace" or mode:"workspace_categories"; actions via workspace_actions/workspace_action/run_workspace_action; includeParameters:true inlines editor schemas.',
+    settings: 'List mode:"settings" with category|prefix|query|includeHidden:true; get_setting/set_setting/reset_setting use key|target|query and confirmation for writes.',
+    tools: 'List mode:"tools" with query|limit|includeParameters:true; inspect mode:"tool" with toolName|target|query.',
+    releaseEvidence: 'List mode:"release_evidence"; inspect mode:"release_evidence_artifact"; includeParameters:true inlines artifact detail.',
+    releaseReadiness: 'List mode:"release_readiness"; inspect mode:"release_readiness_item"; includeParameters:true inlines item detail.',
+    operatorMethods: 'List mode:"operator_methods"; inspect mode:"operator_method"; execute only through the returned first-class tool.',
+    servicePosture: 'List mode:"service_posture"; inspect mode:"service_endpoint"; includeParameters:true adds probes and redacted log tail.',
+    connectedHost: 'Map mode:"connected_host"; inspect mode:"connected_host_capability"; no lifecycle control.',
+    connectedHostStatus: 'Live read-only mode:"connected_host_status" for host reachability, SDK compatibility, token posture, and Knowledge readiness.',
+    daemon: 'Daemon aliases route to mode:"connected_host" and mode:"connected_host_status"; lifecycle control is not exposed.',
+  };
+}
+
 function requireConfirmedAction(args: AgentHarnessToolArgs, action: string): string | null {
   const explicitUserRequest = readString(args.explicitUserRequest);
   if (!explicitUserRequest) return `${action} requires explicitUserRequest with the user's exact request or a short faithful summary.`;
@@ -348,11 +409,7 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
   return {
     definition: {
       name: 'agent_harness',
-      description: [
-        'Inspect or operate the GoodVibes Agent harness.',
-        'Use summary for mode help.',
-        'Effects require confirm:true plus explicitUserRequest; no host lifecycle or raw secrets.',
-      ].join(' '),
+      description: 'Inspect or operate GoodVibes Agent harness surfaces.',
       parameters: {
         type: 'object',
         properties: AGENT_HARNESS_PARAMETER_PROPERTIES,
@@ -407,36 +464,12 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             releaseReadiness: releaseReadinessInventoryStatus(),
             operatorMethods: operatorMethodCatalogStatus(),
             servicePosture: servicePostureCatalogStatus(),
-            modelAccess: {
-              cliCommands: 'List mode:"cli_commands"; inspect mode:"cli_command" with cliCommand|commandName|query. Discovery only.',
-              panels: 'List mode:"panels"; inspect mode:"panel"; navigate mode:"open_panel" with confirm:true and explicitUserRequest.',
-              uiSurfaces: 'List mode:"ui_surfaces"; inspect mode:"ui_surface"; navigate mode:"open_ui_surface" with confirmation.',
-              shortcuts: 'List mode:"shortcuts"; inspect mode:"keybinding"; run mode:"run_keybinding"; edit with set_keybinding/reset_keybinding and confirmation.',
-              slashCommands: 'List mode:"commands"; inspect mode:"command"; execute mode:"run_command" with confirmation.',
-              channels: 'List mode:"channels"; inspect mode:"channel"; deliver with agent_channel_send and confirmation.',
-              notifications: 'List mode:"notifications"; inspect mode:"notification_target"; deliver with agent_notify and confirmation.',
-              providerAccounts: 'List mode:"provider_accounts"; inspect mode:"provider_account"; auth changes stay confirmed workspace/command flows.',
-              mcpServers: 'List mode:"mcp_servers"; inspect mode:"mcp_server"; trust/server changes stay confirmed workspace/command flows.',
-              setupPosture: 'List mode:"setup_posture"; inspect mode:"setup_item"; setup mutations stay confirmed visible flows.',
-              modelRouting: 'List mode:"model_routing"; inspect mode:"model_route"; selection and provider edits stay confirmed visible flows.',
-              pairingPosture: 'List mode:"pairing_posture"; inspect mode:"pairing_route"; raw token/QR and pairing effects stay visible user flows.',
-              delegationPosture: 'List mode:"delegation_posture"; inspect mode:"delegation_route"; delegated submission stays confirmed visible flow.',
-              securityPosture: 'List mode:"security_posture"; inspect mode:"security_finding"; mutate only through confirmed security routes.',
-              supportBundles: 'List mode:"support_bundles"; inspect mode:"support_bundle"; export/import stays confirmation-gated.',
-              mediaPosture: 'List mode:"media_posture"; inspect mode:"media_provider"; generate with agent_media_generate and confirmation.',
-              sessions: 'List mode:"sessions"; inspect mode:"session"; save/resume/export/delete stays visible confirmed flow.',
-              workspace: 'List mode:"workspace" or mode:"workspace_categories"; actions via workspace_actions/workspace_action/run_workspace_action; includeParameters:true inlines editor schemas.',
-              settings: 'List mode:"settings" with category|prefix|query|includeHidden:true; get_setting/set_setting/reset_setting use key|target|query and confirmation for writes.',
-              tools: 'List mode:"tools" with query|limit|includeParameters:true; inspect mode:"tool" with toolName|target|query.',
-              releaseEvidence: 'List mode:"release_evidence"; inspect mode:"release_evidence_artifact"; includeParameters:true inlines artifact detail.',
-              releaseReadiness: 'List mode:"release_readiness"; inspect mode:"release_readiness_item"; includeParameters:true inlines item detail.',
-              operatorMethods: 'List mode:"operator_methods"; inspect mode:"operator_method"; execute only through the returned first-class tool.',
-              servicePosture: 'List mode:"service_posture"; inspect mode:"service_endpoint"; includeParameters:true adds probes and redacted log tail.',
-              connectedHost: 'Map mode:"connected_host"; inspect mode:"connected_host_capability"; no lifecycle control.',
-              connectedHostStatus: 'Live read-only mode:"connected_host_status" for host reachability, SDK compatibility, token posture, and Knowledge readiness.',
-            },
+            modeGuide: compactHarnessModeGuide(),
+            ...(args.includeParameters === true ? { modelAccess: detailedHarnessModelAccessGuide() } : {}),
             settingsPolicy: settingsPolicySummary(),
-            connectedHost: connectedHostSummary(deps.commandContext, deps.toolRegistry),
+            connectedHost: connectedHostSummary(deps.commandContext, deps.toolRegistry, {
+              includeParameters: args.includeParameters === true,
+            }),
           });
         }
         if (args.mode === 'cli_commands') {
@@ -603,6 +636,8 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             query: readString(args.query) || undefined,
             includeHidden: args.includeHidden === true,
             limit: readLimit(args.limit, 100),
+          }, {
+            includeParameters: args.includeParameters === true,
           });
           return output({ settings, returned: settings.length, policy: settingsPolicySummary() });
         }
@@ -714,7 +749,11 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved.status === 'ambiguous') return error(`Ambiguous service endpoint ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(resolved.usage);
         }
-        if (args.mode === 'connected_host') return output(connectedHostSummary(deps.commandContext, deps.toolRegistry));
+        if (args.mode === 'connected_host' || args.mode === 'daemon') {
+          return output(connectedHostSummary(deps.commandContext, deps.toolRegistry, {
+            includeParameters: args.includeParameters === true,
+          }));
+        }
         if (args.mode === 'connected_host_capability') {
           const query = readString(args.capabilityId || args.target || args.query);
           const resolved = describeConnectedHostCapability(deps.toolRegistry, query);
@@ -722,7 +761,11 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           if (resolved?.status === 'ambiguous') return error(`Ambiguous connected-host capability ${resolved.input}. Candidates: ${JSON.stringify(resolved.candidates)}`);
           return error(`Unknown connected-host capability ${query || '<missing>'}. Use mode:"connected_host" to inspect allowed and blocked capability ids.`);
         }
-        if (args.mode === 'connected_host_status') return output(await connectedHostStatusSummary(deps.commandContext, deps.toolRegistry));
+        if (args.mode === 'connected_host_status' || args.mode === 'daemon_status') {
+          return output(await connectedHostStatusSummary(deps.commandContext, deps.toolRegistry, {
+            includeParameters: args.includeParameters === true,
+          }));
+        }
         return error(`Unhandled agent_harness mode: ${args.mode}`);
       } catch (err) {
         return error(formatHarnessError(err));