You're making it a lot more complicated than it is. Just use map() and |=:

jq 'map(.tags |= split(" "))' file.json

Edit:

If you want to handle entries without tags:

jq 'map(try(.tags |= split(" ")))' file.json

Alternatively, if you want to keep unchanged all entries without tags:

jq 'map(try(.tags |= split(" ")) // .)' file.json

Result:

[
  {
    "tags": [
      "tagA",
      "tag-B",
      "tagC"
    ],
    "title": "Some Title"
  },
  {
    "tags": [
      "tagA",
      "tagC"
    ],
    "title": "Some Title 2"
  }
]

There are two main ways to create a valid JSON array from arbitrary lists of strings. One is using jq with its --args option:

jq -c -n '$ARGS.positional' --args "${mylist[@]}"

or, if the elements are not to be encoded as strings (they may be plain numbers, for example, or previously prepared JSON strings or whole JSON objects),

jq -c -n '$ARGS.positional' --jsonargs "${mylist[@]}"

Note that --args and --jsonargs and its arguments need to be the last thing on the command line of jq.

I'm using -n to disable reading any external input and -c to create JSON in the "compact" output format, as shown in the question.

The other way is using jo, a tool specifically made to make it easy to generate JSON on the command line:

jo -a "${mylist[@]}"

The -a option to jo generates an array from the given arguments.

The jo tool infers the type of the object itself, so a list like

mylist=(1 2 3 4 5 b)

would be turned into the JSON array

[1,2,3,4,5,"b"]

If your jq has inputs then the simplest would probably be to use it:

jq -ncR '[inputs]' <<< "$groups"
["group1","group2","group3"]

Otherwise, here are three alternatives:

jq -c -n --arg groups "$groups" '$groups | split("\n")' 

echo -n "$groups" | jq -cRs 'split("\n")'

echo "$groups" | jq -R -s -c 'split("\n") | map(select(length>0))'

In any case, the array can easily be incorporated into a JSON object, e.g. by extending the filter with | {groups: .}

If you really want to produce invalid JSON, consider:

printf "%s" "$groups" | jq -Rrsc 'split("\n") | "{ \(.) }"'

Output:

{ ["group_1","group_2","group_3"] }

Note on select(length>0)

Consider:

 jq -Rsc 'split("\n")' <<< $'a\nb'
 ["a","b",""]

The reason for including select(length>0) is to avoid the trailing "".

If $groups contains consecutive newlines, and if it is important to retain the empty strings, then you might want to use [:-1], e.g.

jq -cRs 'split("\n")[:-1]' <<< "$groups"
["group1","group2","group3"]

If your jq does not support [:-1], make the 0 explicit: [0:-1]

Assuming that the input is given on stdin, the following command solves the problem:

jq -Rn '[inputs]'

The flag -R reads the input as "raw" (i.e. unquoted strings) and -n hands over stdin to inputs (slurping with -s doesn't work because when combined with -R, it reads the whole input a single string). Add -c to print the JSON on one line like in the question.

Any empty lines (like a trailing newline) may be skipped by adding a little filter:

jq -Rn '[inputs|select(length>0)]'

If the strings are separated by other characters like ,, the string may be split with

jq -R 'split(",")'

This could be used to split on \n as well for solving the above case, but my (unverified) assumption is that the above solution is more portable with systems using other line terminators.

This trick with the jq 1.5 inputs streaming filter seems to do it

... | jq -n '.items |= [inputs]'

Ex.

$ find ~/ -maxdepth 1 -name "D*" | 
    while read line; do 
      jq -n --arg name "$(basename "$line")" \
            --arg path "$line" \
        '{name: $name, path: $path}'
    done | jq -n '.items |= [inputs]'
{
  "items": [
    {
      "name": "Downloads",
      "path": "/home/steeldriver/Downloads"
    },
    {
      "name": "Desktop",
      "path": "/home/steeldriver/Desktop"
    },
    {
      "name": "Documents",
      "path": "/home/steeldriver/Documents"
    }
  ]
}