@poodle64/librarian 2026.9.19 → 2026.9.20

package/README.md

@@ -228,7 +228,15 @@ again after sending a message folds only what is new.
 	oncite={(citation) => showPage(citation.document_id)}
 >
 	{#snippet composer()}
-		<Composer bind:value {running} {name} note="It carries on from where it stopped." {onsubmit} {onstop} />
+		<Composer
+			bind:value
+			{running}
+			{name}
+			sendWhileRunning
+			note="It carries on from where it stopped."
+			{onsubmit}
+			{onstop}
+		/>
 	{/snippet}
 </Conversation>
 ```
@@ -244,6 +252,7 @@ end that way.
 | An artefact            | `turn.artefact = { title, summary }` cards under the prose once the turn settles; `isAnswer: true` is an artefact that IS the prose, and replaces it                  |
 | Opening it             | `onopenartefact(turn)` and `showing` (the turn id the host shows). Without a handler, an `isAnswer` artefact opens in `ArtefactPane` and any other offers no action |
 | "Answered without a source" | `copy.notHeld: ''` for a persona that answers from no shelf                                                                                                     |
+| Saying something mid-run | `Composer`'s `sendWhileRunning`: while the session works the box stays open and Send sits beside Stop. For a route that reads a message while the run works; a chat leaves it off and waits for its answer |
 
 ### Citations
 

package/dist/components/composer/composer.svelte

@@ -7,8 +7,10 @@
   chrome grows with the text and nothing else moves.
 
   While Milton is answering the box is disabled and the send button becomes a
-  stop button. Queuing the next message is not built, and a box that takes
-  typing it will then discard is worse than one that plainly waits.
+  stop button: an ask route takes one question per request, and a box that
+  takes typing it will then discard is worse than one that plainly waits. A
+  host whose session reads messages while it works (`sendWhileRunning`) keeps
+  the box open, with Send beside Stop.
 -->
 <script lang="ts">
 	import ArrowUpIcon from '@lucide/svelte/icons/arrow-up';
@@ -52,6 +54,11 @@
 		name?: string;
 		/** Overrides for the package's own words. */
 		copy?: Partial<LibrarianCopy>;
+		/** The session reads a message sent while it works — a job whose
+		 *  route writes it onto the running process — so the box stays open
+		 *  and Send sits beside Stop. Words only: the paperclip still waits for
+		 *  the run. Absent, a chat waits for its answer. */
+		sendWhileRunning?: boolean;
 		/** One quiet line in the box's footer, where a scope choice would
 		 *  sit, in the host's words: what sending does here ("It carries on
 		 *  from where it stopped."). */
@@ -72,9 +79,13 @@
 		onbriefing,
 		name = DEFAULT_PERSONA,
 		copy,
-		note
+		note,
+		sendWhileRunning = false
 	}: Props = $props();
 
+	/** Nothing can be said right now: a chat whose answer is still coming. */
+	const waiting = $derived(running && !sendWhileRunning);
+
 	const words = $derived(resolveCopy(copy, name));
 
 	// What Milton is being asked about — this document, this collection, or
@@ -124,21 +135,23 @@
 	});
 
 	// Focus comes back once Milton is done, so a reader can keep going without
-	// reaching for the mouse. It has to be the transition OUT of `running`: a
+	// reaching for the mouse. It has to be the transition OUT of `waiting`: a
 	// disabled element cannot hold focus, so the focus call in `submit()` below
-	// survives only for a host that never sets `running` — measured, focus lands
-	// on `body` the frame the box disables and comes back here.
+	// survives only for a box that never disables — measured, focus lands on
+	// `body` the frame the box disables and comes back here. A box that stayed
+	// open never lost focus, so it takes none back from wherever the reader
+	// went while the run worked.
 	//
 	// Plain, not `$state`: read and written in the same effect, which would
 	// otherwise re-trigger itself forever.
-	let wasRunning = false;
+	let wasWaiting = false;
 	$effect(() => {
-		if (wasRunning && !running) textarea?.focus();
-		wasRunning = running;
+		if (wasWaiting && !waiting) textarea?.focus();
+		wasWaiting = waiting;
 	});
 
 	function submit() {
-		if (!value.trim() || running) return;
+		if (!value.trim() || waiting) return;
 		onsubmit();
 		textarea?.focus();
 	}
@@ -225,8 +238,8 @@
 			oninput={grow}
 			onkeydown={keydown}
 			rows="1"
-			disabled={running}
-			placeholder={running ? words.answeringPlaceholder : words.askPlaceholder}
+			disabled={waiting}
+			placeholder={waiting ? words.answeringPlaceholder : words.askPlaceholder}
 			class="ds-lib-input"
 		></textarea>
 
@@ -287,7 +300,8 @@
 				<button type="button" class="ds-lib-stop" onclick={onstop} aria-label="Stop">
 					<SquareIcon size={14} fill="currentColor" />
 				</button>
-			{:else}
+			{/if}
+			{#if !waiting}
 				<button
 					type="button"
 					class="ds-lib-send"

package/dist/components/composer/composer.svelte.d.ts

@@ -25,6 +25,11 @@ interface Props {
     name?: string;
     /** Overrides for the package's own words. */
     copy?: Partial<LibrarianCopy>;
+    /** The session reads a message sent while it works — a job whose
+     *  route writes it onto the running process — so the box stays open
+     *  and Send sits beside Stop. Words only: the paperclip still waits for
+     *  the run. Absent, a chat waits for its answer. */
+    sendWhileRunning?: boolean;
     /** One quiet line in the box's footer, where a scope choice would
      *  sit, in the host's words: what sending does here ("It carries on
      *  from where it stopped."). */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poodle64/librarian",
-	"version": "2026.9.19",
+	"version": "2026.9.20",
 	"description": "An agent's conversation surface as a consumable Svelte 5 package: the stream client, transcript state and self-styling chat components (transcript, composer, markdown) every household app renders instead of rebuilding, speaking as whichever persona the app names.",
 	"type": "module",
 	"license": "MIT",