The docs say the errno that fits, Joincol's order, the pane cap, the paste's second Enter, a follower across Restore, and why wc waits

Dogfood round 9's doc findings: ENOENT for a missing pane, file or dump is
right, so the skill says EIO or an errno that fits; Joincol folds into the
column on the right, the joined panes below its own; the skill gives the
64-pane cap; Python's second \r is needed only when the paste lacks a
trailing newline; a log follower loses nothing within a session, but a
Restore hangs it up; and a tag word gets no file argument, as in acme, so
bare wc waits on stdin (pardes has no $%).

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

3 files changed, 24 insertions, 11 deletions

diff --git a/.agents/skills/pardes-9p/SKILL.md b/.agents/skills/pardes-9p/SKILL.md
index 01be232d..9ec46084 100644
--- a/.agents/skills/pardes-9p/SKILL.md
+++ b/.agents/skills/pardes-9p/SKILL.md
@@ -66,7 +66,8 @@ $m/log        recent events, then EOF: new|del|rename|save <serial> <name>, msg
               run <serial> <line>, exit <serial> <N|?>, send <from> <to> <repl-id>,
               dump|restore <path>, err <serial|-> <file>: <why>
               (exec 3<>$m/log; echo follow >&3; cat <&3  waits for new ones; tail -f does not;
-              while read -r line <&3; do ...; done loses nothing)
+              while read -r line <&3; do ...; done loses nothing within a session: a Restore
+              hangs every connection up, so dial again, and restart a 9ns mount)
 $m/screen     the rendered screen as JSON, frozen per open
 $m/listeners  this session's dial addresses
 $m/focus      the serial of the pane with the keyboard (empty while a column/workspace tag has it);
@@ -79,7 +80,8 @@ $m/ctl        the settings, one a line as a write takes them; write a setting or
               word again DISCARDS that text -- not a retry, unlike lock's `file in use`;
               Kill stops a command pane's whole line, `&` jobs included; of a line typed into a
               shell only the foreground job, and the shell decides the rest (of `sleep 30; echo done`
-              fish runs the echo, bash abandons the line); Joincol needs a column to the right of the keyboard's);
+              fish runs the echo, bash abandons the line); Joincol folds the keyboard's column into the one
+              on its right, its panes going below that column's own, in order, and needs such a column);
               a pane's builtins (Del, Save f, Collapse, which folds that pane, and the
               column word Delcol, which closes that pane's column) go to $m/pane/<n>/ctl
 $m/commands   every builtin: `Word`, `Word arg`, then `root` or `pane` (which ctl takes it)
@@ -91,7 +93,8 @@ $m/col/<serial>/ctl  Delcol, Joincol, New, Tty on that column; col/<serial>/exec
 $m/pane/new   open it to make a pane (a scratch named <dir>/+New), read names it; it goes in
               the ACTIVE column (the one last typed or clicked in, or Newcol's), filling it if
               empty, else taking the bottom half of its last pane (ctl `Placement pardes`: the old rules);
-              rmdir $m/pane/<n> closes it; a column's last pane leaves the column EMPTY
+              a session holds 64 panes (16 on the board): past that, every route that opens one
+              fails with `no pane slots: 64 max`; rmdir $m/pane/<n> closes it; a column's last pane leaves the column EMPTY
               (focus reads empty, the log says only del), and the session's LAST pane QUITS it
 $m/pane/<n>/errors  write-only: text appended to the +Errors pane of the pane's directory
 $m/os/        the host filesystem
@@ -158,9 +161,10 @@ REPLs bound for a language an exec asks which, logged `ask <serial> repl a b`
 `echo 'answer a' > $m/pane/<serial>/ctl`, or `answer -` to send nothing (the log says `answer <serial> a|-`). Multi-line code
 written to `pty/data` should be a bracketed paste, `\e[200~<code>\e[201~`,
 then, in a separate write once the REPL has echoed the paste (Python 3.13+
-takes a `\r` read with the paste as part of it, even for one line), `\r`,
-and a second `\r` when the code's last line is indented (a `def` or `for`
-body): one Enter leaves such a block open. Sent line by line, a blank line ends a Python block, and Python
+takes a `\r` read with the paste as part of it, even for one line), `\r`.
+End the pasted code with a newline and that one `\r` runs it; without one, a
+code whose last line is indented (a `def` or `for` body) needs a second
+`\r`, as one Enter leaves such a block open. Sent line by line, a blank line ends a Python block, and Python
 3.14's REPL auto-indents each line it is typed. Every refused 9P write adds an `err <serial|->
 <file>: <why>` record to `$m/log`; through a mount the write itself only says
 `Invalid argument`.
@@ -255,7 +259,7 @@ back every setting in the syntax it takes. A ctl write is checked whole
 first and refused as `unknown control message "X"` (EINVAL) and the like,
 a required argument missing included (`wrong #args ... "Mount"`); then a line
 whose builtin reports an error fails the write with that error and the line
-(EIO), after the lines before it took effect. A `Save` on a scratch fails
+(EIO, or an errno that fits: ENOENT for a missing pane, file or dump), after the lines before it took effect. A `Save` on a scratch fails
 rather than prompt. The lock binds only clients that take it, and is held by the
 open that wrote it, so a shell holds an fd across the edit:
 `exec 3>$pane/ctl; echo lock >&3; ...; exec 3>&-`.
diff --git a/docs/fs.md b/docs/fs.md
index ad9c97ba..8aa9d6bf 100644
--- a/docs/fs.md
+++ b/docs/fs.md
@@ -137,7 +137,8 @@ gives each column's serial and its index left to right, and the log says
 `newcol <serial>` and `delcol <serial>` as columns come and go, and after a
 Restore `restoredcol <old> <new>` for each column as `restored` does for
 panes. Joincol folds a column into the one on its right, which keeps its own
-serial and tag; the joined one's serial is gone (`delcol`). The root ctl
+serial and tag; the joined column's panes go below that column's own, in
+their order, and its serial is gone (`delcol`). The root ctl
 takes no column word: its `Delcol` is refused, pointing at
 `col/<serial>/ctl`.
 
@@ -357,8 +358,9 @@ is no gesture and is never sent: a script writes to the REPL pane's
 `pty/data`, multi-line code as a bracketed paste (`\e[200~<code>\e[201~`,
 then `\r` in a write of its own once the REPL has echoed the paste --
 Python 3.13's REPL takes an Enter read with the paste as part of it, even a
-one-line one -- and a second `\r` when its last line is indented: one Enter
-leaves a block open, pasted or typed; a middle click does all of this
+one-line one -- and, only when the pasted code does not end in a newline
+and its last line is indented, a second `\r`: one Enter leaves such a block
+open; a middle click does all of this
 itself, holding the Enter until the REPL answers the paste), since line by line a blank line ends a Python block and Python
 3.14's REPL auto-indents each line typed into it. The REPL gets the text
 wherever it is -- at a `pdb` or `input()` prompt too. Bindings are not dumped, so a Restore leaves none.
@@ -627,7 +629,10 @@ tag gives offsets into the whole tag as `tag` reads it, the path first.) An
 open freezes the ring's text the way `/screen` freezes a frame: reads walk it
 and end. Writing `follow` to that same open makes reads past it wait for the
 next record, one per read; a follower the ring outran reads `lost N` first.
-Closing the open is the only way back, as with rio's `consctl`.
+Closing the open is the only way back, as with rio's `consctl`. A follower
+misses nothing within a session only: a Restore hangs its connection up
+(and a 9ns mount with it, which must be restarted), so it dials again and
+reads the new log from its `restore <path>`.
 
 A read with nothing to give yet -- a following `log`, `event`, `pty/data`, a
 `pty/run` before its answer -- is held, the way factotum holds its log's reads
diff --git a/docs/tags.md b/docs/tags.md
index bfca4f0e..b8322aa9 100644
--- a/docs/tags.md
+++ b/docs/tags.md
@@ -17,6 +17,10 @@ REPL, its id, `python-a`, beside the Tty word: a middle click or the execute
 key on a `.py` body then types the text into it rather than running it, and
 several bound ask which. The tag's own words, `Exec <text>` by name and a
 command word @`cmd` still run as commands (docs/fs.md).
+A tag word runs as acme's does, in the pane's directory with no file named:
+`wc` alone waits on its stdin. pardes has no `$%` for the pane's file; name
+it (`wc notes.txt`), or select the name and middle-click `wc`, which takes a
+held selection as its argument.
 Pane and column command text leave a small gap after their aligned drag grips.
 GUI pane mode symbols are centered by their visible ink; changing the font or
 its size refreshes the cached measurements.