cd completion doesn't work

[achampion]

After installing this plugin cd A<tab> no longer completes. When pressing <tab> a new prompt is generated but the text stays the same (subsequent <tab>s do not create new prompts unless you have typed additional characters). Uninstall plugin and cd completes again.

complete | grep cd => complete --no-files --command cd --arguments '(__fish_complete_plugin_cd)'

[SanCoder-Q]

Thanks for letting me know. I will try to identify the issue.

[SanCoder-Q]

@achampion I cannot reproduce your issue. Could you provide the info as follows:

• fish version
• oh-my-fish version
• Operating system
• What is the current behavior? (Please provide the context of the file structure and dir history if necessary)
• What is the expected behavior?

[BarbzYHOOL]

it's working fine for me, I use it all the time and didn't see any problem with tab

[SanCoder-Q]

I will close this issue since no details provided in a month. Feel free to raise another one anytime.

[achampion]

Sorry I've been traveling. I've just reinstalled cd and it still doesn't work.

Fish version: fish, version 2.7.1 OMF version: Oh My Fish version 6 OS: MacOS High Sierra

Sample directory structure:

home
  |-> test

In the ~/home directory:

~/home $ cd te<tab>

Result - a new prompt, still only te:

~/home $
~/home $ cd te

Other information that might help Binding mode - vi CDPATH set to home and projects directory

If I uninstall cd:

~/home $ cd te<tab>

Result (no extra prompt line and prompt suggestions):

~/home $ cd te<tab>
techradar/  (CDPATH ~/Projects)  test/

If I retest with no matches within the CDPATH I also get the same result as above, with the plugin not installed it just completes.

[SanCoder-Q]

I just reopen it and try to fix it when I got time. Thanks.

[BarbzYHOOL]

lol sorry I really didn't understand the issue the first time I posted :D

[SanCoder-Q]

Hi @achampion, I had a hard time to reproduce the issue you have. I have the screenshot which shows the cd works fine in my end.

---

Could you please give the results of omf list when you have plugin cd installed? Also, could you please do the following things to help me get more info about this issue:

cd ~
omf install cd
fish -d4
cd te<tab>

Could you provide the outputs after press tab when you have the exact folder context you described?

Thanks.

[achampion]

Here's my omf list:

[0]# omf list                                                                                                                                                
Plugins
aws             cd              docker-machine  fish-spec       omf             osx             thefuck         vundle

Themes
default

Here's the output from hitting tab:

[0]# cd te<3> fish: path_get_path( 'cd' )                                                                                                                     11:05:36
<4> fish: trying to match mapping \e\[1\;2C
<4> fish: trying to match mapping \e\[1\;2D
<4> fish: trying to match mapping \e\[3\;2\~
<4> fish: trying to match mapping \e\[200\~
<4> fish: trying to match mapping \e\[1\;9B
<4> fish: trying to match mapping \e\[1\;9A
<4> fish: trying to match mapping \e\[1\;3B
<4> fish: trying to match mapping \e\[1\;3A
<4> fish: trying to match mapping \e\[1\;9D
<4> fish: trying to match mapping \e\[1\;9C
<4> fish: trying to match mapping \e\[1\;3D
<4> fish: trying to match mapping \e\[1\;3C
<4> fish: trying to match mapping \e\[3\~
<4> fish: trying to match mapping \e\[4\~
<4> fish: trying to match mapping \e\[1\~
<4> fish: trying to match mapping \e\[3B
<4> fish: trying to match mapping \e\[3A
<4> fish: trying to match mapping \eO3B
<4> fish: trying to match mapping \eO3A
<4> fish: trying to match mapping \e\e\[B
<4> fish: trying to match mapping \e\e\[A
<4> fish: trying to match mapping \e\eOB
<4> fish: trying to match mapping \e\eOA
<4> fish: trying to match mapping \e\[3D
<4> fish: trying to match mapping \e\[3C
<4> fish: trying to match mapping \eO3D
<4> fish: trying to match mapping \eO3C
<4> fish: trying to match mapping \e\e\[D
<4> fish: trying to match mapping \e\e\[C
<4> fish: trying to match mapping \e\eOD
<4> fish: trying to match mapping \e\eOC
<4> fish: trying to match mapping \e\[6\~
<4> fish: trying to match mapping \e\[5\~
<4> fish: trying to match mapping \eOP
<4> fish: trying to match mapping \e\[H
<4> fish: trying to match mapping \e\[F
<4> fish: trying to match mapping \e\[B
<4> fish: trying to match mapping \e\[A
<4> fish: trying to match mapping \eOA
<4> fish: trying to match mapping \eOB
<4> fish: trying to match mapping \e\[Z
<4> fish: trying to match mapping \e\[D
<4> fish: trying to match mapping \e\[C
<4> fish: trying to match mapping \eOD
<4> fish: trying to match mapping \eOC
<4> fish: trying to match mapping \ef
<4> fish: trying to match mapping \eb
<4> fish: trying to match mapping \e\#
<4> fish: trying to match mapping \ep
<4> fish: trying to match mapping \eh
<4> fish: trying to match mapping \ed
<4> fish: trying to match mapping \ew
<4> fish: trying to match mapping \el
<4> fish: trying to match mapping \e.
<4> fish: trying to match mapping \e\r
<4> fish: trying to match mapping \e\n
<4> fish: trying to match mapping \ey
<4> fish: trying to match mapping 
<4> fish: trying to match mapping \b
<4> fish: trying to match mapping \n
<4> fish: trying to match mapping \r
<4> fish: trying to match mapping \cd
<4> fish: trying to match mapping \cw
<4> fish: trying to match mapping \cu
<4> fish: trying to match mapping \cc
<4> fish: trying to match mapping \cl
<4> fish: trying to match mapping \t
<3> fish: path_get_path( 'cd' )
<4> fish: Created pipe using fds 7 and 8
<4> fish: Exec job '__fish_complete_plugin_cd' with id 1
<4> fish: Created pipe using fds 9 and 10
<4> fish: Exec job 'commandline -ct' with id 3
<3> fish: Skipping fork: buffered output for internal builtin 'commandline'
<3> fish: Set status of commandline -ct to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 3, gid -2 (commandline -ct), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('commandline -ct')
<4> fish: io_buffer_t::read: blocking read on fd 9
<4> fish: Exec job 'set -l token (commandline -ct)' with id 2
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l token (commandline -ct) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 2, gid -2 (set -l token (commandline -ct)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l token (commandline -ct)')
<4> fish: Exec job '__complete_omf_cd $token' with id 3
<3> fish: unregister: EVENT_ANY: "__resolve_dot_path"
<3> fish: unregister: EVENT_ANY: "__resolve_home_path"
<3> fish: unregister: EVENT_ANY: "__resolve_fancy_path"
<3> fish: unregister: EVENT_ANY: "__get_basepath"
<3> fish: unregister: EVENT_ANY: "__get_filename"
<3> fish: unregister: EVENT_ANY: "__filter_directory"
<3> fish: unregister: EVENT_ANY: "__list_and_filter"
<3> fish: unregister: EVENT_ANY: "__list_all_candidate"
<3> fish: unregister: EVENT_ANY: "__list_all"
<3> fish: path_get_path( 'sort' )
<4> fish: Exec job '__list_all $argv | sort -u' with id 2
<4> fish: Created pipe using fds 9 and 10
<4> fish: Created pipe using fds 11 and 12
<4> fish: Exec job 'set -l token $argv' with id 4
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l token $argv to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 4, gid -2 (set -l token $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l token $argv')
<4> fish: Exec job 'test "$token" = "~"' with id 5
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test "$token" = "~" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (test "$token" = "~"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test "$token" = "~"')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__get_basepath $token' with id 4
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'rev' )
<3> fish: path_get_path( 'cut' )
<3> fish: path_get_path( 'rev' )
<4> fish: Exec job 'echo $argv | rev | cut -d/ -s -f2- | rev' with id 7
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #211, pid 52236: internal builtin for 'echo'
<4> fish: Created pipe using fds 18 and 19
<2> fish: Fork #212, pid 52237: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 17 and 19
<2> fish: Fork #213, pid 52238: spawn external command '/usr/bin/cut' from '<no file>'
<2> fish: Fork #214, pid 52239: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 7, gid 51874 (echo $argv | rev | cut -d/ -s -f2- | rev), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: select_try on 15
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)' with id 6
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 6, gid -2 (set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)')
<4> fish: Exec job 'string match -qr '^/' "$argv"' with id 7
<3> fish: Skipping fork: no output for internal builtin 'string'
<3> fish: Set status of string match -qr '^/' "$argv" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 7, gid -2 (string match -qr '^/' "$argv"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('string match -qr '^/' "$argv"')
<4> fish: Exec job 'echo $__base' with id 7
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo $__base to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 7, gid -2 (echo $__base), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo $__base')
<3> fish: Job is constructed
<4> fish: Continue job 4, gid -2 (__get_basepath $token), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__get_basepath $token')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l basepath (__get_basepath $token)' with id 5
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l basepath (__get_basepath $token) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (set -l basepath (__get_basepath $token)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l basepath (__get_basepath $token)')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__resolve_fancy_path $token' with id 5
<4> fish: Created pipe using fds 15 and 16
<4> fish: Exec job '__resolve_home_path $argv' with id 7
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv |\
      sed -e "s@^~@$HOME@"' with id 8
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #215, pid 52240: internal builtin for 'echo'
<2> fish: Fork #216, pid 52241: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 8, gid 51874 (echo $argv |\
      sed -e "s@^~@$HOME@"), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: Job is constructed
<4> fish: Continue job 7, gid -2 (__resolve_home_path $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_home_path $argv')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job '__resolve_dot_path (__resolve_home_path $argv)' with id 6
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'' with id 7
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #217, pid 52242: internal builtin for 'echo'
<2> fish: Fork #218, pid 52243: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 7, gid 51874 (echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'')
<3> fish: select_try on 13
<3> fish: select_try hit timeout
<3> fish: proc::read_try('echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'')
<3> fish: Job is constructed
<4> fish: Continue job 6, gid -2 (__resolve_dot_path (__resolve_home_path $argv)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_dot_path (__resolve_home_path $argv)')
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (__resolve_fancy_path $token), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_fancy_path $token')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l resolved_path (__resolve_fancy_path $token)' with id 4
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l resolved_path (__resolve_fancy_path $token) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 4, gid -2 (set -l resolved_path (__resolve_fancy_path $token)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l resolved_path (__resolve_fancy_path $token)')
<4> fish: Exec job 'test -d $resolved_path' with id 5
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $resolved_path to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (test -d $resolved_path), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $resolved_path')
<4> fish: Exec job 'test -z "$basepath"' with id 5
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -z "$basepath" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (test -z "$basepath"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -z "$basepath"')
<4> fish: Exec job '__list_all_candidate $resolved_path' with id 6
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__get_basepath $argv' with id 7
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'rev' )
<3> fish: path_get_path( 'cut' )
<3> fish: path_get_path( 'rev' )
<4> fish: Exec job 'echo $argv | rev | cut -d/ -s -f2- | rev' with id 9
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #219, pid 52244: internal builtin for 'echo'
<4> fish: Created pipe using fds 18 and 19
<2> fish: Fork #220, pid 52245: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 17 and 19
<2> fish: Fork #221, pid 52246: spawn external command '/usr/bin/cut' from '<no file>'
<2> fish: Fork #222, pid 52247: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 9, gid 51874 (echo $argv | rev | cut -d/ -s -f2- | rev), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)' with id 8
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)')
<4> fish: Exec job 'string match -qr '^/' "$argv"' with id 9
<3> fish: Skipping fork: no output for internal builtin 'string'
<3> fish: Set status of string match -qr '^/' "$argv" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (string match -qr '^/' "$argv"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('string match -qr '^/' "$argv"')
<4> fish: Exec job 'echo $__base' with id 9
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo $__base to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (echo $__base), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo $__base')
<3> fish: Job is constructed
<4> fish: Continue job 7, gid -2 (__get_basepath $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__get_basepath $argv')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l __basepath (__get_basepath $argv)' with id 5
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l __basepath (__get_basepath $argv) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (set -l __basepath (__get_basepath $argv)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l __basepath (__get_basepath $argv)')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__get_filename $argv' with id 5
<3> fish: path_get_path( 'rev' )
<3> fish: path_get_path( 'cut' )
<3> fish: path_get_path( 'rev' )
<4> fish: Exec job 'echo $argv | rev | cut -d/ -f1 | rev' with id 8
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #223, pid 52248: internal builtin for 'echo'
<4> fish: Created pipe using fds 16 and 17
<2> fish: Fork #224, pid 52249: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 15 and 17
<2> fish: Fork #225, pid 52250: spawn external command '/usr/bin/cut' from '<no file>'
<2> fish: Fork #226, pid 52251: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 8, gid 51874 (echo $argv | rev | cut -d/ -f1 | rev), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv | rev | cut -d/ -f1 | rev')
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv | rev | cut -d/ -f1 | rev')
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (__get_filename $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__get_filename $argv')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l __filename (__get_filename $argv)' with id 7
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l __filename (__get_filename $argv) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 7, gid -2 (set -l __filename (__get_filename $argv)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l __filename (__get_filename $argv)')
<4> fish: Exec job 'test -n "$__basepath"' with id 5
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -n "$__basepath" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (test -n "$__basepath"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -n "$__basepath"')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__list_and_filter . $__filename' with id 5
<4> fish: Exec job 'test -d $argv[1]' with id 9
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $argv[1] to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (test -d $argv[1]), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $argv[1]')
<3> fish: path_get_path( 'ls' )
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'' with id 9
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #227, pid 52252: internal builtin for 'echo'
<2> fish: Fork #228, pid 52253: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 9, gid 51874 (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')' with id 10
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #229, pid 52254: spawn external command '/opt/local/libexec/gnubin/ls' from '<no file>'
<4> fish: Created pipe using fds 16 and 17
<4> fish: Created pipe using fds 18 and 19
<4> fish: Exec job 'read -l __name' with id 9
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 12
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 12, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 9
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 12
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 12, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 9
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 12
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 12, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 9
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 12
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 12, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 9
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: io_buffer_t::read: blocking read on fd 18
<2> fish: Fork #230, pid 52255: internal block or function for '__filter_directory'
<3> fish: path_get_path( 'grep' )
<4> fish: Exec job 'command grep --color=auto -inIF $argv' with id 9
<2> fish: Fork #231, pid 52256: spawn external command '/usr/bin/grep' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 9, gid 51874 (command grep --color=auto -inIF $argv), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('command grep --color=auto -inIF $argv')
<3> fish: Job is constructed
<4> fish: Continue job 10, gid 51874 (command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')')
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (__list_and_filter . $__filename), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__list_and_filter . $__filename')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set __candidate (__list_and_filter . $__filename)' with id 8
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set __candidate (__list_and_filter . $__filename) to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (set __candidate (__list_and_filter . $__filename)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set __candidate (__list_and_filter . $__filename)')
<4> fish: Exec job 'test -n "$CDPATH"' with id 5
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -n "$CDPATH" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 5, gid -2 (test -n "$CDPATH"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -n "$CDPATH"')
<4> fish: Exec job 'not string match -qr '^/' $argv' with id 8
<3> fish: Skipping fork: no output for internal builtin 'string'
<3> fish: Set status of not string match -qr '^/' $argv to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (not string match -qr '^/' $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('not string match -qr '^/' $argv')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__resolve_home_path $cdpath' with id 8
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv |\
      sed -e "s@^~@$HOME@"' with id 10
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #232, pid 52257: internal builtin for 'echo'
<2> fish: Fork #233, pid 52258: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 10, gid 51874 (echo $argv |\
      sed -e "s@^~@$HOME@"), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__resolve_home_path $cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_home_path $cdpath')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l resolved_cdpath (__resolve_home_path $cdpath)' with id 9
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l resolved_cdpath (__resolve_home_path $cdpath) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (set -l resolved_cdpath (__resolve_home_path $cdpath)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l resolved_cdpath (__resolve_home_path $cdpath)')
<4> fish: Exec job 'test -d $resolved_cdpath' with id 8
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $resolved_cdpath to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (test -d $resolved_cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $resolved_cdpath')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__list_and_filter "$resolved_cdpath/$__basepath" $__filename' with id 8
<4> fish: Exec job 'test -d $argv[1]' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $argv[1] to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d $argv[1]), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $argv[1]')
<3> fish: path_get_path( 'ls' )
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'' with id 11
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #234, pid 52259: internal builtin for 'echo'
<2> fish: Fork #235, pid 52260: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')' with id 12
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #236, pid 52261: spawn external command '/opt/local/libexec/gnubin/ls' from '<no file>'
<4> fish: Created pipe using fds 16 and 17
<4> fish: Created pipe using fds 18 and 19
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: io_buffer_t::read: blocking read on fd 18
<2> fish: Fork #237, pid 52262: internal block or function for '__filter_directory'
<3> fish: path_get_path( 'grep' )
<4> fish: Exec job 'command grep --color=auto -inIF $argv' with id 11
<2> fish: Fork #238, pid 52263: spawn external command '/usr/bin/grep' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (command grep --color=auto -inIF $argv), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('command grep --color=auto -inIF $argv')
<3> fish: Job is constructed
<4> fish: Continue job 12, gid 51874 (command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__list_and_filter "$resolved_cdpath/$__basepath" $__filename), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__list_and_filter "$resolved_cdpath/$__basepath" $__filename')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)' with id 10
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename) to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 10, gid -2 (set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)')
<4> fish: Exec job 'not string match -qr '^/' $argv' with id 8
<3> fish: Skipping fork: no output for internal builtin 'string'
<3> fish: Set status of not string match -qr '^/' $argv to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (not string match -qr '^/' $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('not string match -qr '^/' $argv')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__resolve_home_path $cdpath' with id 8
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv |\
      sed -e "s@^~@$HOME@"' with id 10
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #239, pid 52264: internal builtin for 'echo'
<2> fish: Fork #240, pid 52265: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 10, gid 51874 (echo $argv |\
      sed -e "s@^~@$HOME@"), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__resolve_home_path $cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_home_path $cdpath')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l resolved_cdpath (__resolve_home_path $cdpath)' with id 9
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l resolved_cdpath (__resolve_home_path $cdpath) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (set -l resolved_cdpath (__resolve_home_path $cdpath)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l resolved_cdpath (__resolve_home_path $cdpath)')
<4> fish: Exec job 'test -d $resolved_cdpath' with id 8
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $resolved_cdpath to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (test -d $resolved_cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $resolved_cdpath')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__list_and_filter "$resolved_cdpath/$__basepath" $__filename' with id 8
<4> fish: Exec job 'test -d $argv[1]' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $argv[1] to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d $argv[1]), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $argv[1]')
<3> fish: path_get_path( 'ls' )
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'' with id 11
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #241, pid 52266: internal builtin for 'echo'
<2> fish: Fork #242, pid 52267: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')' with id 12
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #243, pid 52268: spawn external command '/opt/local/libexec/gnubin/ls' from '<no file>'
<4> fish: Created pipe using fds 16 and 17
<4> fish: Created pipe using fds 18 and 19
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: io_buffer_t::read: blocking read on fd 18
<2> fish: Fork #244, pid 52269: internal block or function for '__filter_directory'
<3> fish: path_get_path( 'grep' )
<4> fish: Exec job 'command grep --color=auto -inIF $argv' with id 11
<2> fish: Fork #245, pid 52270: spawn external command '/usr/bin/grep' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (command grep --color=auto -inIF $argv), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('command grep --color=auto -inIF $argv')
<3> fish: Job is constructed
<4> fish: Continue job 12, gid 51874 (command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__list_and_filter "$resolved_cdpath/$__basepath" $__filename), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__list_and_filter "$resolved_cdpath/$__basepath" $__filename')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)' with id 10
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename) to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 10, gid -2 (set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)')
<4> fish: Exec job 'not string match -qr '^/' $argv' with id 8
<3> fish: Skipping fork: no output for internal builtin 'string'
<3> fish: Set status of not string match -qr '^/' $argv to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (not string match -qr '^/' $argv), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('not string match -qr '^/' $argv')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__resolve_home_path $cdpath' with id 8
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv |\
      sed -e "s@^~@$HOME@"' with id 10
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #246, pid 52271: internal builtin for 'echo'
<2> fish: Fork #247, pid 52272: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 10, gid 51874 (echo $argv |\
      sed -e "s@^~@$HOME@"), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: select_try on 13
<3> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__resolve_home_path $cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__resolve_home_path $cdpath')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set -l resolved_cdpath (__resolve_home_path $cdpath)' with id 9
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set -l resolved_cdpath (__resolve_home_path $cdpath) to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 9, gid -2 (set -l resolved_cdpath (__resolve_home_path $cdpath)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set -l resolved_cdpath (__resolve_home_path $cdpath)')
<4> fish: Exec job 'test -d $resolved_cdpath' with id 8
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $resolved_cdpath to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (test -d $resolved_cdpath), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $resolved_cdpath')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Exec job '__list_and_filter "$resolved_cdpath/$__basepath" $__filename' with id 8
<4> fish: Exec job 'test -d $argv[1]' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d $argv[1] to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d $argv[1]), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d $argv[1]')
<3> fish: path_get_path( 'ls' )
<4> fish: Created pipe using fds 15 and 16
<3> fish: path_get_path( 'sed' )
<4> fish: Exec job 'echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'' with id 11
<4> fish: Created pipe using fds 17 and 18
<2> fish: Fork #248, pid 52273: internal builtin for 'echo'
<2> fish: Fork #249, pid 52274: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<3> fish: select_try on 15
<3> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Exec job 'command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')' with id 12
<4> fish: Created pipe using fds 15 and 16
<2> fish: Fork #250, pid 52275: spawn external command '/opt/local/libexec/gnubin/ls' from '<no file>'
<4> fish: Created pipe using fds 16 and 17
<4> fish: Created pipe using fds 18 and 19
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 11
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 11
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: Exec job 'test -d "$argv/$__name"' with id 13
<3> fish: Skipping fork: no output for internal builtin 'test'
<3> fish: Set status of test -d "$argv/$__name" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Exec job 'echo "$__name/"' with id 14
<3> fish: Skipping fork: buffered output for internal builtin 'echo'
<3> fish: Set status of echo "$__name/" to 0 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 14, gid -2 (echo "$__name/"), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('echo "$__name/"')
<4> fish: Exec job 'read -l __name' with id 13
<3> fish: Skipping fork: no output for internal builtin 'read'
<3> fish: Set status of read -l __name to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 13, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('read -l __name')
<4> fish: io_buffer_t::read: blocking read on fd 18
<2> fish: Fork #251, pid 52276: internal block or function for '__filter_directory'
<3> fish: path_get_path( 'grep' )
<4> fish: Exec job 'command grep --color=auto -inIF $argv' with id 11
<2> fish: Fork #252, pid 52277: spawn external command '/usr/bin/grep' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 11, gid 51874 (command grep --color=auto -inIF $argv), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 13
<3> fish: proc::read_try('command grep --color=auto -inIF $argv')
<3> fish: Job is constructed
<4> fish: Continue job 12, gid 51874 (command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('command ls -a $argv[1] | __filter_directory $argv[1] | grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')')
<3> fish: Job is constructed
<4> fish: Continue job 8, gid -2 (__list_and_filter "$resolved_cdpath/$__basepath" $__filename), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__list_and_filter "$resolved_cdpath/$__basepath" $__filename')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Exec job 'set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)' with id 10
<3> fish: Skipping fork: no output for internal builtin 'set'
<3> fish: Set status of set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename) to 1 using short circuit
<3> fish: Job is constructed
<4> fish: Continue job 10, gid -2 (set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('set __candidate $__candidate (__list_and_filter "$resolved_cdpath/$__basepath" $__filename)')
<3> fish: Job is constructed
<4> fish: Continue job 6, gid -2 (__list_all_candidate $resolved_path), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__list_all_candidate $resolved_path')
<4> fish: io_buffer_t::read: blocking read on fd 11
<2> fish: Fork #253, pid 52278: spawn external command '/opt/local/libexec/gnubin/sort' from '<no file>'
<3> fish: Job is constructed
<4> fish: Continue job 2, gid 51874 (__list_all $argv | sort -u), UNCOMPLETED, NON-INTERACTIVE
<3> fish: select_try on 7
<3> fish: proc::read_try('__list_all $argv | sort -u')
<3> fish: Job is constructed
<4> fish: Continue job 3, gid -2 (__complete_omf_cd $token), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__complete_omf_cd $token')
<3> fish: Job is constructed
<4> fish: Continue job 1, gid -2 (__fish_complete_plugin_cd), COMPLETED, NON-INTERACTIVE
<3> fish: proc::read_try('__fish_complete_plugin_cd')
<4> fish: io_buffer_t::read: blocking read on fd 7
[I] 11:05 ~/home
[I] 11:05 ~/home                                                                                                                         
[0]# cd te<3> fish: path_get_path( 'cd' )                                                                                                                     11:05:36

[SanCoder-Q]

@achampion Just identified the issue and published a fix. Could you please try it again?

[SanCoder-Q]

@achampion FYI, the CDPATH has its own issue. I would use it carefully since this issue hasn't been fixed.

[achampion]

Thank you, I can confirm the complete now works.

[SanCoder-Q]

I'm glad to hear that. Close this issue. 😉

[adealoe]

Unfortunately I'm having this same issue, cd tab completion doesn't work. I did try uninstalling cd & reinstalling it with no luck. When I remove the cd plugin, it works fine again.

Here are the same details you you requested from achampion in previous posts:

omf list:

Plugins
brew        cd      fish-spec   grc     omf     osx

Themes
bira    default

Fish version 3.0.1 OMF Version 6 OS X 10.11.6 (Same issue on my other mac, 10.14.3) iTerm 2 (build 3.1.7)

I do have a custom .config/omf/init.fish:

export CLICOLOR=1
export CLICOLOR_FORCE=1
alias ls="grc --colour=auto ls -alh"

Here's the debug info when I hit tab on cd vi<tab> (should detect directory "vince" but flashes & does nothing)

╭─Adam@Serenity /Users/Adam  ‹system›
╰─$ cd vin<4> fish: Created pipe using fds 7 and 8
<4> fish: Created pipe using fds 9 and 10
<4> fish: Skipping fork: buffered output for internal builtin 'commandline'
<4> fish: Set status of job 3 (commandline ...) to 0 using short circuit
<3> fish: Created job 3 from command 'commandline -ct' with pgrp -2
<4> fish: Start job 3, gid -2 (commandline -ct), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('commandline -ct')
<4> fish: io_buffer_t::read: blocking read on fd 9
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 2 (set ...) to 0 using short circuit
<3> fish: Created job 2 from command 'set -l token (commandline -ct)' with pgrp -2
<4> fish: Start job 2, gid -2 (set -l token (commandline -ct)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l token (commandline -ct)')
<4> fish: Created pipe using fds 9 and 10
<4> fish: Created pipe using fds 11 and 12
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 4 (set ...) to 0 using short circuit
<3> fish: Created job 4 from command 'set -l token $argv' with pgrp -2
<4> fish: Start job 4, gid -2 (set -l token $argv), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l token $argv')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 5 (test ...) to 1 using short circuit
<3> fish: Created job 5 from command 'test "$token" = "~"' with pgrp -2
<4> fish: Start job 5, gid -2 (test "$token" = "~"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test "$token" = "~"')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Created pipe using fds 15 and 16
<4> fish: Created pipe using fds 17 and 18
<4> fish: Fork #30, pid 11135: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Created pipe using fds 18 and 19
<4> fish: Fork #31, pid 11136: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 17 and 19
<4> fish: Fork #32, pid 11137: spawn external command '/usr/bin/cut' from '<no file>'
<4> fish: Fork #33, pid 11138: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Created job 7 from command 'echo $argv | rev | cut -d/ -s -f2- | rev' with pgrp 11077
<4> fish: Start job 7, gid 11077 (echo $argv | rev | cut -d/ -s -f2- | rev), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11135
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11136
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11137
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11138
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 6 (set ...) to 0 using short circuit
<3> fish: Created job 6 from command 'set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)' with pgrp -2
<4> fish: Start job 6, gid -2 (set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)')
<4> fish: Skipping fork: no output for internal builtin 'string'
<4> fish: Set status of job 7 (string ...) to 1 using short circuit
<3> fish: Created job 7 from command 'string match -qr '^/' "$argv"' with pgrp -2
<4> fish: Start job 7, gid -2 (string match -qr '^/' "$argv"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('string match -qr '^/' "$argv"')
<4> fish: Skipping fork: buffered output for internal builtin 'echo'
<4> fish: Set status of job 6 (echo ...) to 0 using short circuit
<3> fish: Created job 6 from command 'echo $__base' with pgrp -2
<4> fish: Start job 6, gid -2 (echo $__base), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('echo $__base')
<3> fish: Created job 5 from command '__get_basepath $token' with pgrp -2
<4> fish: Start job 5, gid -2 (__get_basepath $token), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__get_basepath $token')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 4 (set ...) to 0 using short circuit
<3> fish: Created job 4 from command 'set -l basepath (__get_basepath $token)' with pgrp -2
<4> fish: Start job 4, gid -2 (set -l basepath (__get_basepath $token)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l basepath (__get_basepath $token)')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Created pipe using fds 15 and 16
<4> fish: Created pipe using fds 17 and 18
<4> fish: Fork #34, pid 11139: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Fork #35, pid 11140: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Created job 8 from command 'echo $argv |\
      sed -e "s@^~@$HOME@"' with pgrp 11077
<4> fish: Start job 8, gid 11077 (echo $argv |\
      sed -e "s@^~@$HOME@"), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11139
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv |\
      sed -e "s@^~@$HOME@"')
<4> fish: Reaped PID 11140
<3> fish: Created job 7 from command '__resolve_home_path $argv' with pgrp -2
<4> fish: Start job 7, gid -2 (__resolve_home_path $argv), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__resolve_home_path $argv')
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Created pipe using fds 15 and 16
<4> fish: Fork #36, pid 11141: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Fork #37, pid 11142: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Created job 7 from command 'echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'' with pgrp 11077
<4> fish: Start job 7, gid 11077 (echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11141
<4> fish: select_try on fd 13
<4> fish: proc::read_try('echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'')
<4> fish: select_try on fd 13
<4> fish: proc::read_try('echo $argv |                                                   \
      sed -e 's@^\.$@:@;s@^\.\([^\.]\)@:\1@g;s@\([^\.]\)\.$@\1:@g' \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\([^\.]\)\.\([^\.]\)@\1:\2@g'                          \
      -e 's@\.\{2\}\(\.*\)@::\1@g'                                 \
      -e 's@\.@\/\.\.@g'                                           \
      -e 's@:@\.@g'')
<4> fish: Reaped PID 11142
<3> fish: Created job 6 from command '__resolve_dot_path (__resolve_home_path $argv)' with pgrp -2
<4> fish: Start job 6, gid -2 (__resolve_dot_path (__resolve_home_path $argv)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__resolve_dot_path (__resolve_home_path $argv)')
<3> fish: Created job 4 from command '__resolve_fancy_path $token' with pgrp -2
<4> fish: Start job 4, gid -2 (__resolve_fancy_path $token), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__resolve_fancy_path $token')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 5 (set ...) to 0 using short circuit
<3> fish: Created job 5 from command 'set -l resolved_path (__resolve_fancy_path $token)' with pgrp -2
<4> fish: Start job 5, gid -2 (set -l resolved_path (__resolve_fancy_path $token)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l resolved_path (__resolve_fancy_path $token)')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 4 (test ...) to 1 using short circuit
<3> fish: Created job 4 from command 'test -d $resolved_path' with pgrp -2
<4> fish: Start job 4, gid -2 (test -d $resolved_path), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d $resolved_path')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 5 (test ...) to 0 using short circuit
<3> fish: Created job 5 from command 'test -z "$basepath"' with pgrp -2
<4> fish: Start job 5, gid -2 (test -z "$basepath"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -z "$basepath"')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Created pipe using fds 15 and 16
<4> fish: Created pipe using fds 17 and 18
<4> fish: Fork #38, pid 11143: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Created pipe using fds 18 and 19
<4> fish: Fork #39, pid 11144: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 17 and 19
<4> fish: Fork #40, pid 11145: spawn external command '/usr/bin/cut' from '<no file>'
<4> fish: Fork #41, pid 11146: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Created job 9 from command 'echo $argv | rev | cut -d/ -s -f2- | rev' with pgrp 11077
<4> fish: Start job 9, gid 11077 (echo $argv | rev | cut -d/ -s -f2- | rev), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11143
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11144
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11145
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -s -f2- | rev')
<4> fish: Reaped PID 11146
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 8 (set ...) to 0 using short circuit
<3> fish: Created job 8 from command 'set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)' with pgrp -2
<4> fish: Start job 8, gid -2 (set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l __base (echo $argv | rev | cut -d/ -s -f2- | rev)')
<4> fish: Skipping fork: no output for internal builtin 'string'
<4> fish: Set status of job 9 (string ...) to 1 using short circuit
<3> fish: Created job 9 from command 'string match -qr '^/' "$argv"' with pgrp -2
<4> fish: Start job 9, gid -2 (string match -qr '^/' "$argv"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('string match -qr '^/' "$argv"')
<4> fish: Skipping fork: buffered output for internal builtin 'echo'
<4> fish: Set status of job 8 (echo ...) to 0 using short circuit
<3> fish: Created job 8 from command 'echo $__base' with pgrp -2
<4> fish: Start job 8, gid -2 (echo $__base), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('echo $__base')
<3> fish: Created job 7 from command '__get_basepath $argv' with pgrp -2
<4> fish: Start job 7, gid -2 (__get_basepath $argv), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__get_basepath $argv')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 6 (set ...) to 0 using short circuit
<3> fish: Created job 6 from command 'set -l __basepath (__get_basepath $argv)' with pgrp -2
<4> fish: Start job 6, gid -2 (set -l __basepath (__get_basepath $argv)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l __basepath (__get_basepath $argv)')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Created pipe using fds 15 and 16
<4> fish: Fork #42, pid 11147: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Created pipe using fds 16 and 17
<4> fish: Fork #43, pid 11148: spawn external command '/usr/bin/rev' from '<no file>'
<4> fish: Created pipe using fds 15 and 17
<4> fish: Fork #44, pid 11149: spawn external command '/usr/bin/cut' from '<no file>'
<4> fish: Fork #45, pid 11150: spawn external command '/usr/bin/rev' from '<no file>'
<3> fish: Created job 8 from command 'echo $argv | rev | cut -d/ -f1 | rev' with pgrp 11077
<4> fish: Start job 8, gid 11077 (echo $argv | rev | cut -d/ -f1 | rev), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11147
<4> fish: select_try on fd 13
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -f1 | rev')
<4> fish: Reaped PID 11148
<4> fish: select_try on fd 13
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -f1 | rev')
<4> fish: Reaped PID 11149
<4> fish: select_try on fd 13
<4> fish: proc::read_try('echo $argv | rev | cut -d/ -f1 | rev')
<4> fish: Reaped PID 11150
<3> fish: Created job 6 from command '__get_filename $argv' with pgrp -2
<4> fish: Start job 6, gid -2 (__get_filename $argv), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__get_filename $argv')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 7 (set ...) to 0 using short circuit
<3> fish: Created job 7 from command 'set -l __filename (__get_filename $argv)' with pgrp -2
<4> fish: Start job 7, gid -2 (set -l __filename (__get_filename $argv)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set -l __filename (__get_filename $argv)')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 6 (test ...) to 1 using short circuit
<3> fish: Created job 6 from command 'test -n "$__basepath"' with pgrp -2
<4> fish: Start job 6, gid -2 (test -n "$__basepath"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -n "$__basepath"')
<4> fish: Created pipe using fds 13 and 14
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 9 (test ...) to 0 using short circuit
<3> fish: Created job 9 from command 'test -d $argv[1]' with pgrp -2
<4> fish: Start job 9, gid -2 (test -d $argv[1]), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d $argv[1]')
<4> fish: Created pipe using fds 15 and 16
<4> fish: Created pipe using fds 17 and 18
<4> fish: Fork #46, pid 11151: internal builtin for 'echo'
<4> fish: env_export_arr() recalc
<4> fish: Fork #47, pid 11152: spawn external command '/usr/bin/sed' from '<no file>'
<3> fish: Created job 11 from command 'echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'' with pgrp 11077
<4> fish: Start job 11, gid 11077 (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11151
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: select_try on fd 15
<4> fish: proc::read_try('echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@'')
<4> fish: Reaped PID 11152
<4> fish: io_buffer_t::read: blocking read on fd 15
<4> fish: Created pipe using fds 15 and 16
<4> fish: Fork #48, pid 11153: spawn external command '/bin/ls' from '<no file>'
<4> fish: Created pipe using fds 16 and 17
<4> fish: Created pipe using fds 18 and 19
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 0 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 12 (test ...) to 1 using short circuit
<3> fish: Created job 12 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 12, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 12 (read ...) to 0 using short circuit
<3> fish: Created job 12 from command 'read -l __name' with pgrp -2
<4> fish: Start job 12, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 11 (test ...) to 1 using short circuit
<3> fish: Created job 11 from command 'test -d "$argv/$__name"' with pgrp -2
<4> fish: Start job 11, gid -2 (test -d "$argv/$__name"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -d "$argv/$__name"')
<4> fish: Skipping fork: no output for internal builtin 'read'
<4> fish: Set status of job 11 (read ...) to 1 using short circuit
<3> fish: Created job 11 from command 'read -l __name' with pgrp -2
<4> fish: Start job 11, gid -2 (read -l __name), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('read -l __name')
<4> fish: io_buffer_t::read: blocking read on fd 18
<4> fish: env_export_arr() recalc
<4> fish: Fork #49, pid 11154: spawn external command '/usr/bin/grep' from '<no file>'
<3> fish: Created job 10 from command 'command ls -a $argv[1] | __filter_directory $argv[1] | \
      command grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')' with pgrp 11077
<4> fish: Start job 10, gid 11077 (command ls -a $argv[1] | __filter_directory $argv[1] | \
      command grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')), UNCOMPLETED, NON-INTERACTIVE
<4> fish: Reaped PID 11153
<4> fish: select_try on fd 13
<4> fish: proc::read_try('command ls -a $argv[1] | __filter_directory $argv[1] | \
      command grep -e (echo $argv[2] | sed -e 's@\.@\\\.@g' -e 's@^@\^@')')
<4> fish: Reaped PID 11154
<3> fish: Created job 8 from command '__list_and_filter . $__filename' with pgrp -2
<4> fish: Start job 8, gid -2 (__list_and_filter . $__filename), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__list_and_filter . $__filename')
<4> fish: io_buffer_t::read: blocking read on fd 13
<4> fish: Skipping fork: no output for internal builtin 'set'
<4> fish: Set status of job 7 (set ...) to 1 using short circuit
<3> fish: Created job 7 from command 'set __candidate (__list_and_filter . $__filename)' with pgrp -2
<4> fish: Start job 7, gid -2 (set __candidate (__list_and_filter . $__filename)), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('set __candidate (__list_and_filter . $__filename)')
<4> fish: Skipping fork: no output for internal builtin 'test'
<4> fish: Set status of job 7 (test ...) to 1 using short circuit
<3> fish: Created job 7 from command 'test -n "$CDPATH"' with pgrp -2
<4> fish: Start job 7, gid -2 (test -n "$CDPATH"), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('test -n "$CDPATH"')
<3> fish: Created job 4 from command '__list_all_candidate $resolved_path' with pgrp -2
<4> fish: Start job 4, gid -2 (__list_all_candidate $resolved_path), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__list_all_candidate $resolved_path')
<4> fish: io_buffer_t::read: blocking read on fd 11
<4> fish: env_export_arr() recalc
<4> fish: Fork #50, pid 11155: spawn external command '/usr/bin/sort' from '<no file>'
<3> fish: Created job 2 from command '__list_all $argv | sort -u' with pgrp 11077
<4> fish: Start job 2, gid 11077 (__list_all $argv | sort -u), UNCOMPLETED, NON-INTERACTIVE
<4> fish: select_try on fd 7
<4> fish: proc::read_try('__list_all $argv | sort -u')
<4> fish: Reaped PID 11155
<3> fish: Created job 3 from command '__complete_omf_cd $token' with pgrp -2
<4> fish: Start job 3, gid -2 (__complete_omf_cd $token), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__complete_omf_cd $token')
<3> fish: Created job 1 from command '__fish_complete_plugin_cd' with pgrp -2
<4> fish: Start job 1, gid -2 (__fish_complete_plugin_cd), COMPLETED, NON-INTERACTIVE
<4> fish: proc::read_try('__fish_complete_plugin_cd')
<4> fish: io_buffer_t::read: blocking read on fd 7