fix(mcp): keep REMAINDER flags from swallowing later flags in kwargs_to_argv

The MCP server re-encodes tool-call kwargs into an argv list that is fed to
the same argparse parser the REPL uses, so the two paths must parse to the
same Namespace. Two argv-marshalling bugs broke that parity:

* _argv.py: an append action with nargs=REMAINDER (commit -m, lock -c) was
  emitted into the flag list. A flag declared *after* it -- notably
  -T/--template added by _add_template_arg for commit/lock -- was then
  emitted behind it and swallowed by the REMAINDER, corrupting the
  message/comment and leaving template=None (a wrong fan-out across every
  loaded template). Route append+REMAINDER into the positional tail, exactly
  as the optional-REMAINDER path already does, so later flags stay safe
  regardless of parser._actions declaration order.

* session.py start_jobs: a fanned-out job was scoped with
  [*argv, "-T", rrid]. For a positional nargs=REMAINDER command (run) the
  trailing -T rrid was swallowed into command, so template stayed None and
  -T <RRID> leaked into the remote shell command. Prepend the scope flag
  (["-T", rrid, *argv]) so it is always parsed as a real flag.

Add tests/test_mcp_repl_parity.py: a reusable parity assertion parametrised
across the command matrix (both paths must parse to equal Namespaces),
dedicated regressions for both fixes (commit/lock -m/-c with a template, and
start_jobs scoping for a REMAINDER run plus a nargs='+' slow command), and a
safety check that a smuggled force kwarg cannot reach approve/reject.

Author: plusky

CHANGELOG.md

@@ -213,6 +213,12 @@ and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.ht
 
 ### Fixed
 
+- `mtui-mcp` no longer corrupts a `commit`/`lock` call that also carries a
+  `template` argument, nor a backgrounded `run` that fans out across several
+  loaded templates. A `-m`/`-c` message or a `run` command line no longer
+  swallows the template-scoping flag, so the message stays intact, the call
+  is scoped to the intended template (instead of silently fanning out to
+  every one), and no stray `-T <RRID>` leaks into the remote command.
 - An unscoped multi-template fan-out of a host-phase command (e.g. `lock`,
   `run`) no longer fails the whole fan-out — or, for `lock`, pretends to
   succeed — when a loaded template has no connected host. A host-less template

mtui/mcp/_argv.py

@@ -12,7 +12,9 @@
   when the action's ``nargs`` consumes a remainder/multi
   (``REMAINDER``/``*``/``+``/integer ``N`` — e.g. ``commit -m``, ``lock -c``):
   there the flag is emitted once followed by every token, so argparse rebuilds
-  ``[[v1, v2, ...]]`` instead of swallowing a repeated flag as a value.
+  ``[[v1, v2, ...]]`` instead of swallowing a repeated flag as a value — and,
+  like the optional-REMAINDER case below, **into the positional tail** so a
+  later flag (e.g. ``-T/--template``) declared after it cannot be swallowed.
 * Positional ``nargs=REMAINDER``/``*``/``+`` → append elements verbatim
   at the end (after every flag-shaped argument), preserving order.
 * Optional ``nargs=REMAINDER`` (e.g. ``reject --message``) → emit the
@@ -194,8 +196,20 @@ def kwargs_to_argv(
                 # argparse rebuilds ``[[v1, v2, ...]]``; ``--flag v1 --flag v2``
                 # would let REMAINDER swallow the second ``--flag`` as a value,
                 # producing ``[[v1, '--flag', v2]]`` and a corrupted message.
-                flag_tokens.append(flag)
-                flag_tokens.extend(str(item) for item in value)
+                #
+                # Route into the positional tail (not ``flag_tokens``) for the
+                # same reason as the optional-REMAINDER branch below: a
+                # REMAINDER/multi append consumes every token after its flag, so
+                # any flag declared *after* it (e.g. ``-T/--template`` added by
+                # ``_add_template_arg`` for ``commit``/``lock``) would be
+                # swallowed into the message/comment and lost. Emitting after
+                # every other flag keeps later flags safe regardless of
+                # ``parser._actions`` declaration order. (Assumes at most one
+                # REMAINDER-shaped tail contributor per command: no current
+                # command declares a real positional *after* an append+REMAINDER
+                # flag, which would be emitted ahead of it here and swallowed.)
+                positional_tail.append(flag)
+                positional_tail.extend(str(item) for item in value)
             else:
                 for item in value:
                     flag_tokens.extend([flag, str(item)])

mtui/mcp/session.py

@@ -1012,7 +1012,12 @@ async def start_jobs(
             self._job_counter += 1
             token = rrid.replace(":", "_")
             job_id = f"{cmd_cls.command}-{token}-{self._job_counter}"
-            scoped_argv = [*argv, "-T", rrid]
+            # Prepend the scope flag: a positional ``nargs=REMAINDER`` command
+            # (``run``) or an append-REMAINDER flag at the tail of ``argv``
+            # would swallow a trailing ``-T <rrid>`` into its own value,
+            # leaving ``template=None`` (wrong fan-out) and leaking ``-T`` into
+            # the remote command. Emitting it first keeps it a real flag.
+            scoped_argv = ["-T", rrid, *argv]
             job_ids.append(self._mint_job(cmd_cls, scoped_argv, job_id))
         return job_ids