The docs say sel is writable, Edit blocks may span writes, and sig INT stops a REPL

sel's write was documented in fs.md only; the skill says it now. With
command lines held per open, an Edit block may come in several writes (a
shell's line-at-a-time printf), so the heredoc advice goes. Kill never
stopped what a REPL runs, since pardes did not start it; the docs point at
pty/ctl sig INT.

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

2 files changed, 14 insertions, 8 deletions

diff --git a/.agents/skills/pardes-9p/SKILL.md b/.agents/skills/pardes-9p/SKILL.md
index 0cd52715..037f2d83 100644
--- a/.agents/skills/pardes-9p/SKILL.md
+++ b/.agents/skills/pardes-9p/SKILL.md
@@ -162,7 +162,10 @@ record written back from such a file's body goes to its REPL, as the click
 would. `Repl -` unbinds; a bare `Repl` says the binding. With several
 REPLs bound for a language an exec asks which, logged `ask <serial> repl a b`
 (Del's side from the keyboard is `ask <serial> del k j`): answer with
-`echo 'answer a' > $m/pane/<serial>/ctl`, or `answer -` to send nothing (the log says `answer <serial> a|-`). Multi-line code
+`echo 'answer a' > $m/pane/<serial>/ctl`, or `answer -` to send nothing (the
+log says `answer <serial> a|-`). Kill does not stop what a REPL runs (it was
+typed, not started by pardes): `echo 'sig INT' > $m/pane/<repl>/pty/ctl`
+interrupts it. 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`.
@@ -182,10 +185,11 @@ Rename everywhere, or any sam edit, is one write: `echo 'Edit ,x/foo/c/bar/'
 v c a i d s p = m t u` and `{ }` (commands in braces one to a line, so from
 exec or a tag, not a one-line ctl write). Its changes are one undo step, and
 one that fails changes nothing and fails the write with acme's words (`Edit:
-no substitution`), logged as `err`. A block goes in one write to the pane's
-`ctl`, the root `ctl` (the active pane) or `exec`: an `Edit` line takes the
-lines after it until its `{` closes or its `a`/`c`/`i` text ends with `.`.
-bash's builtin `printf` writes line by line, so use a heredoc or `env printf`:
+no substitution`), logged as `err`. A block goes to the pane's `ctl`, the
+root `ctl` (the active pane) or `exec` on one open, in one write or several
+(bash's `printf` writes line by line): an `Edit` line takes the lines after it
+until its `{` closes or its `a`/`c`/`i` text ends with `.`, and runs then. `sel`
+reads the selected text, and a write to it replaces the selection:
 
 ```sh
 cat > $pane/ctl <<'END'
diff --git a/docs/fs.md b/docs/fs.md
index e81ea18d..c95a45db 100644
--- a/docs/fs.md
+++ b/docs/fs.md
@@ -368,7 +368,9 @@ 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.
+wherever it is -- at a `pdb` or `input()` prompt too. `Kill` does not stop
+what a REPL runs, since pardes did not start it; `sig INT` on the REPL
+pane's `pty/ctl` interrupts it as Ctrl-C would. Bindings are not dumped, so a Restore leaves none.
 
 The root's pair clicks at the active pane and `/pane/<n>/look` and
 `/pane/<n>/exec` at that pane; `/tagexec` and `/col/<n>/exec` click in the
@@ -487,8 +489,8 @@ nothing. A write is one message a line, except that an `Edit` line takes
 the lines after it while its `{` group is open or its `a`, `c` or `i` text
 block waits for its `.` line, on a pane's `ctl`, the root's (at the active
 pane) and `exec` alike; an unclosed group is refused (``unmatched `{'``).
-bash's builtin `printf` writes a line at a time, so write a block with a
-heredoc or `env printf`.
+A block may come in several writes on one open (bash's builtin `printf`
+writes a line at a time): the open holds it until it ends (below).
 
 A line number counts newlines as sam's lineaddr does (editors/sam/
 address.c:180), so the empty line just past a text's last newline is an