@poodle64/librarian 2026.9.19 → 2026.9.21

package/README.md

@@ -187,7 +187,10 @@ is watched rather than asked. `watch()` GETs its stream; `Session` folds it
 into turns: the prompt and every later message on the reader's side (the CLI
 echoes each one back under `--replay-user-messages`), each run's answer on the
 persona's, each settled by its own `result`. A stream without deltas is folded
-from its whole messages. Events are deduped by `uuid`, so opening the watch
+from its whole messages. A run under `--json-schema` hands in its answer by
+calling the CLI's `StructuredOutput` tool: that call is no step of the work,
+the words before it stay the answer, and what it handed in is the run's
+`outcome.structuredOutput`, the natural source of the host's `artefact`. Events are deduped by `uuid`, so opening the watch
 again after sending a message folds only what is new.
 
 ```svelte
@@ -228,7 +231,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 +255,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
 
@@ -404,7 +416,7 @@ pnpm run test         # build + vitest
 pnpm run screenshots  # the state grid, real engine (see below)
 ```
 
-`docs/screenshots/` is sixteen states x three widths x both themes, taken by
+`docs/screenshots/` is seventeen states x three widths x both themes, taken by
 `scripts/screenshots.mjs` against the console's `/librarian` lab route
 running from its own static build. The same script asserts what a screenshot
 cannot: that nothing scrolls sideways at any width, that the source pane

package/dist/components/agent-transcript/agent-transcript.svelte

@@ -186,9 +186,11 @@
 			: (outcome?.error ?? (outcome?.isError ? words.answerFailed : null))
 	);
 
-	// A failed turn settles too, and "Ask again" is the one thing a reader wants
-	// from it — there is just nothing to copy.
-	const settled = $derived(!running && (hasAnswer || Boolean(failure)));
+	// A run that ended has settled, whatever it said: a failed one, where "Ask
+	// again" is the one thing a reader wants, and one that handed in its answer
+	// under a schema and said nothing at all, whose artefact is the answer. A
+	// turn read back from history has no outcome and settles on its prose.
+	const settled = $derived(!running && (hasAnswer || outcome !== null));
 
 	/**
 	 * The persona answered and cited nothing, and we WATCHED it happen.

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/dist/session.svelte.js

@@ -55,6 +55,12 @@ export class Session {
         }
         if (!FOLDED.has(event.type))
             return;
+        // A user frame that is neither a replayed message nor a tool's result is
+        // the CLI nudging its own model (`isSynthetic`: "[structured-output-
+        // enforce] You MUST call the StructuredOutput tool…"): neither side of
+        // the conversation.
+        if (event.type === 'user' && !contentOf(event).some((b) => b.type === 'tool_result'))
+            return;
         // Settled by its own `result`. A stream that broke mid-run is not: the
         // run goes on, and a watch opened again folds the rest onto it.
         const last = this.turns.at(-1);

package/dist/transcript.svelte.js

@@ -366,9 +366,11 @@ export function segment(blocks, describeTool) {
     let current = null;
     let lastTool = -1;
     for (let i = 0; i < blocks.length; i += 1)
-        if (blocks[i].kind === 'tool')
+        if (isStep(blocks[i]))
             lastTool = i;
     for (const [i, block] of blocks.entries()) {
+        if (block.kind === 'tool' && !isStep(block))
+            continue;
         if (block.kind === 'text' && i > lastTool) {
             current = null;
             out.push(block);
@@ -397,6 +399,18 @@ export function segment(blocks, describeTool) {
     }
     return out;
 }
+/**
+ * The tool the CLI adds under `--json-schema`. Calling it hands in the run's
+ * answer, which arrives again whole on the `result` (`structured_output`): it
+ * is not a step of the work, and the words before it are the answer, not
+ * narration ahead of more work. Measured on Claude Code 2.1.283, where a run
+ * with a schema always ends in this call.
+ */
+const HANDS_IN = 'StructuredOutput';
+/** A call that is part of the work, rather than the handing-in of its answer. */
+function isStep(block) {
+    return block.kind === 'tool' && block.name !== HANDS_IN;
+}
 function sameStep(last, block, words) {
     if (last.block.kind !== block.kind)
         return false;
@@ -436,7 +450,7 @@ export function summariseActivity(group) {
 export function readFrom(blocks, describeTool) {
     const out = [];
     for (const block of blocks) {
-        if (block.kind !== 'tool' || block.result === undefined || block.isError)
+        if (block.kind !== 'tool' || !isStep(block) || block.result === undefined || block.isError)
             continue;
         const source = wordsFor(block, describeTool).source;
         if (!source || out.some((c) => c.document_id === source.id))

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poodle64/librarian",
-	"version": "2026.9.19",
+	"version": "2026.9.21",
 	"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",