A command line runs as its own command pane unless it is clicked at a shell's prompt

A middle click, an exec write or a tag word that no builtin knows was typed
into some terminal for the pane's directory, sharing whatever state that
shell was in and answering nothing, so a misspelling vanished into a shell.
Now only a line clicked at an interactive terminal's prompt is typed there.
From anywhere else it runs as a command pane: a terminal whose child is
$SHELL -c the line in the pane's directory, full emulation, which shows its
output and then exit N from the host's reaping of the child, and stays. A
finished command pane is the next command's for its directory, which runs
below what it showed after a '% line' line (acme appends to +Errors and never
clears it, util.c:213); a running one gets a second pane. Kill ends a command
pane's whole process group, the log records run and exit, exec reads back the
command pane's serial, and a line is at most 1 KB, read off the pane as the
host forks rather than carried in every spawn effect. ttyForDir's search for
a free shell is gone. The goldens of chordcut, cmdword and layout-open change
where a file's exec now opens a command pane, and ttytaken is rewritten to
exec from the terminal itself; docs/open-questions.md records the decision.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

1 files changed, 12 insertions, 10 deletions

diff --git a/test/snapshots/cmdword.snap b/test/snapshots/cmdword.snap
index 361e37ba..631fab8b 100644
--- a/test/snapshots/cmdword.snap
+++ b/test/snapshots/cmdword.snap
@@ -7,9 +7,10 @@
 # whole run instead, which is what makes a single CLICK the way you invoke one
 # (acme does the same for its own `<`/`|`/`>` command words).
 #
-# EXECUTE runs it and leaves you where you were; LOOK runs it and lands you in
-# the shell that answered — looking at a thing means being shown it, and a
-# directory's look has always been exactly that (a shell there, ls'd).
+# EXECUTE runs it, as a command pane, and leaves you where you were; LOOK runs
+# it and lands you in the pane that answered — looking at a thing means being
+# shown it, and a directory's look has always been exactly that (a shell
+# there, ls'd).
 #
 # And Look and Exec are ORDINARY BUILTINS now, so their names are executable
 # words like Save or Grep: `Look p.txt` run off the page is the same look a
@@ -28,14 +29,15 @@ wait 8000 cmds.txt
 stable 700 20000
 snap opened
 # a single middle CLICK inside the run (col 11 is inside `echo`) expands to the
-# whole `@`echo ZZ''E`` and executes it in a shell; focus stays on the file
+# whole `@`echo ZZ''E`` and runs it as a command pane; focus stays on the file
 press middle 11 4
 release middle 11 4
 wait 10000 ZZE
 stable 700 15000
 snap atexec
-# LOOK on the second one (col 24, inside its `echo`) runs it too AND focuses
-# the shell that answered — that is the whole difference between the two verbs
+# LOOK on the second one (col 24, inside its `echo`) runs it too, in the same
+# command pane now its first is done, below it, AND focuses it — that is the
+# whole difference between the two verbs
 press right 24 4
 release right 24 4
 wait 10000 ZZL
@@ -49,16 +51,16 @@ wait 10000 just text
 stable 700 15000
 snap lookword
 # nesting: `@`Look .`` — Exec unwraps it, `Look .` is parsed as the ordinary
-# Look builtin with an argument, and Look opens the directory (an existing
-# shell there, ls'd — zzmark.txt is only ever in that listing)
+# Look builtin with an argument, and Look opens the directory (a shell there,
+# ls'd — zzmark.txt is only ever in that listing; a command pane is no shell)
 press middle 49 4
 release middle 49 4
 wait 10000 zzmark.txt
 stable 700 15000
 snap nested
 # the same syntax typed into a TAG — the other place the expansion has to know
-# about backticks. The look above left the shell focused, so `:` opens ITS
-# tag; `A` appends at the end of it, Esc and `h` put the normal-mode cursor on
+# about backticks. The look above left that shell focused, so `:` opens ITS
+# tag, and the word run from a shell's own tag is typed into it; `A` appends at the end of it, Esc and `h` put the normal-mode cursor on
 # the last character typed, and the execute key runs the word under it
 # exactly as the body's does.
 key :