@poodle64/librarian 2026.9.9 → 2026.9.11

package/README.md

@@ -28,7 +28,7 @@ src/lib/
     markdown/              sanitised, streaming-safe markdown + highlighting
     activity-group/        a whole investigation, as one quiet line
     tool-row/              one tool call
-    thinking-row/          one thinking block
+    thinking-row/          one thought, or one line of between-tool narration
     working/               the pre-first-token "something is happening" indicator
 ```
 
@@ -231,6 +231,23 @@ one asks it through `onsuggest` and takes the whole row with it — the moment
 between the click and the new turn arriving is otherwise long enough to ask a
 second question by mistake.
 
+### Where the answer starts
+
+Milton narrates between tool calls — "Let me also check whether…" — and the
+caller stream gives that nowhere to arrive: it carries no `thinking` blocks
+at all, so narration is an ordinary `text` block, identical to the answer
+except in POSITION. `segment()` reads that position: a text block with any
+tool call still to come in the turn is narration and folds into the activity
+group as a thinking-shaped row; the run of text after the LAST tool call is
+the answer. While a turn streams the judgement is provisional — a block that
+is currently last renders as prose, and a tool call arriving after it
+re-homes it — which is why `segment()` is pure and re-derived per event
+rather than deciding once.
+
+The cost is an answer Milton interrupts to go back to the shelf: its first
+half folds away. Position is the only signal the stream gives, and a rule
+read off the prose itself would be unexplainable the first time it misfired.
+
 ### Changing the words
 
 Every user-visible string this package renders lives in
@@ -271,15 +288,16 @@ pnpm run test         # build + vitest
 pnpm run screenshots  # the state grid, real engine (see below)
 ```
 
-`docs/screenshots/` is ten states x three widths x both themes, taken by
+`docs/screenshots/` is eleven 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
 opens and closes from the keyboard with focus returning to the chip and is
 really draggable, that the scope statement folds once there is a
-conversation over it and reopens from that line, and that a follow-up chip
-asks its question and takes the rest of the row with it. It exits non-zero
-on any of them.
+conversation over it and reopens from that line, that a follow-up chip asks
+its question and takes the rest of the row with it, and that Milton's
+between-tool narration is nowhere in the answer prose before the activity
+line is opened. It exits non-zero on any of them.
 
 ```bash
 pnpm --filter @poodle64/console run build

package/dist/citations.js

@@ -119,7 +119,10 @@ export function formatVerified(iso) {
     const [, year, month, day] = match;
     const index = Number(month) - 1;
     const date = Number(day);
-    if (index < 0 || index > 11 || date < 1 || date > 31)
+    // Round-tripped rather than bounds-checked: 1-31 admits "31 Apr 2026",
+    // and a mark that shows a day that never happened is worse than no mark.
+    const made = new Date(Date.UTC(Number(year), index, date));
+    if (made.getUTCMonth() !== index || made.getUTCDate() !== date)
         return null;
     return `${date} ${MONTHS[index]} ${year}`;
 }

package/dist/components/activity-group/activity-group.svelte

@@ -7,6 +7,11 @@
   to mention. So there is exactly one row in every state — "Working…" while it
   runs, a count of what was done once it settles — and the steps are behind a
   disclosure for the reader who wants them.
+
+  That commentary is a step in here too. It reaches the caller as an ordinary
+  `text` block, not a `thinking` one, so `segment()` re-homes any text with a
+  tool call still to come into this group; it renders as a ThinkingRow beside
+  the tools, folded like the rest.
 -->
 <script lang="ts">
 	import ChevronRightIcon from '@lucide/svelte/icons/chevron-right';

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

@@ -105,9 +105,28 @@
 	);
 
 	const hasAnswer = $derived(texts.length > 0);
+
+	/**
+	 * What went wrong, if anything did — in words, whether or not the run gave
+	 * any.
+	 *
+	 * Two different failures reach a turn and only one of them carries a
+	 * message. `library_error` (the stream never opened) sets `error`; a run
+	 * that opened and then failed sets `is_error` on its terminal frame and
+	 * says nothing at all — Claude Code's own `error_max_turns` and
+	 * `error_during_execution` are exactly that shape. Reading only `error`
+	 * left the second kind rendering as a clean, complete answer: no banner,
+	 * a duration badge, and — worse — the "he holds nothing on this" line,
+	 * which is a claim about the shelf made off a run that never finished
+	 * looking.
+	 */
+	const failure = $derived(
+		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(outcome?.error)));
+	const settled = $derived(!running && (hasAnswer || Boolean(failure)));
 
 	/**
 	 * Milton answered and cited nothing, and we WATCHED him do it.
@@ -120,7 +139,7 @@
 	 * here knows whether there were any.
 	 */
 	const notHeld = $derived(
-		settled && hasAnswer && sources.length === 0 && Boolean(outcome) && !outcome?.error
+		settled && hasAnswer && sources.length === 0 && Boolean(outcome) && !failure
 	);
 
 	// A follow-up is offered once. Clicking it asks the question, which puts a
@@ -248,12 +267,12 @@
 		</section>
 	{/if}
 
-	{#if outcome?.error}
+	{#if failure}
 		<p
 			class="border-status-error/40 bg-status-error/10 text-foreground max-w-[72ch] rounded-lg border px-3 py-2 text-sm"
 			role="alert"
 		>
-			{outcome.error}
+			{failure}
 		</p>
 	{/if}
 
@@ -281,7 +300,7 @@
 					<span>{words.askAgain}</span>
 				</button>
 			{/if}
-			{#if outcome && !outcome.error}
+			{#if outcome && !failure}
 				<span class="pl-1 font-mono text-xs tabular-nums opacity-70">
 					{((outcome.durationMs ?? 0) / 1000).toFixed(1)}s
 				</span>

package/dist/components/thinking-row/thinking-row.svelte

@@ -1,9 +1,20 @@
+<!--
+  One line of Milton's working-out, behind a chevron.
+
+  Two different blocks render as this row and deliberately read the same. A
+  real `thinking` block is one; the other is a `text` block Milton wrote
+  BETWEEN two tool calls — "Let me also check whether…" — which the caller
+  stream gives no way to tell from the answer except by position, and which
+  read as answer prose on production until `segment()` started re-homing it
+  here. To a reader both are the same thing: what he was working through, not
+  what he concluded. So both fold, and both fold by default.
+-->
 <script lang="ts">
 	import ChevronRightIcon from '@lucide/svelte/icons/chevron-right';
-	import type { ThinkingBlock } from '../../transcript.svelte';
+	import type { TextBlock, ThinkingBlock } from '../../transcript.svelte';
 
 	interface Props {
-		block: ThinkingBlock;
+		block: ThinkingBlock | TextBlock;
 		active: boolean;
 	}
 

package/dist/components/thinking-row/thinking-row.svelte.d.ts

@@ -1,6 +1,6 @@
-import type { ThinkingBlock } from '../../transcript.svelte';
+import type { TextBlock, ThinkingBlock } from '../../transcript.svelte';
 interface Props {
-    block: ThinkingBlock;
+    block: ThinkingBlock | TextBlock;
     active: boolean;
 }
 declare const ThinkingRow: import("svelte").Component<Props, {}, "">;

package/dist/copy.d.ts

@@ -19,6 +19,8 @@ export interface LibrarianCopy {
     notVerified: string;
     /** Shown under an answer that finished without citing anything. */
     notHeld: string;
+    /** Shown when the run itself ended in error and said nothing about why. */
+    answerFailed: string;
     /** Heading over the list of what an answer cited. */
     sources: string;
     /** Heading over the follow-up questions the librarian offered. */

package/dist/copy.js

@@ -20,6 +20,9 @@ export const DEFAULT_COPY = {
     // reading it has no model of any of those, and the room's own instruction
     // to Milton forbids him naming them either.
     notHeld: 'Milton answered this one without a source. He may not hold a document that covers it.',
+    // A run can end `is_error` carrying no message at all, and a turn that
+    // simply stops is the one thing a reader must not have to guess about.
+    answerFailed: 'Milton stopped before he finished this one.',
     sources: 'Sources',
     suggestions: 'Ask next',
     scope: 'What Milton answers from',

package/dist/transcript.svelte.d.ts

@@ -91,8 +91,11 @@ export declare class Transcript {
     apply(event: AgentEvent): void;
 }
 export interface ActivityStep {
-    /** The block this step stands for; a repeated step keeps the FIRST. */
-    block: ToolBlock | ThinkingBlock;
+    /** The block this step stands for; a repeated step keeps the FIRST.
+     *
+     * A `text` block here is interstitial narration, not the answer — see
+     * `segment()`. */
+    block: Block;
     /** How many identical consecutive steps collapsed into this one. */
     repeats: number;
 }
@@ -124,7 +127,7 @@ export interface Turn {
 /**
  * Fold a turn's flat block list into what a reader should actually see.
  *
- * Two problems this solves, both reported off a real transcript:
+ * Three problems this solves, all reported off a real transcript:
  *
  * 1. Fifteen tool rows stood between the question and the first word of the
  *    answer, so the answer had to be scrolled to. Contiguous activity becomes
@@ -132,6 +135,25 @@ export interface Turn {
  * 2. "Reading pspf guidelines 2026" appeared five times in a row — five pages
  *    of one document, which is one act of reading to a human. Consecutive
  *    steps with the same label collapse to one row carrying a count.
+ * 3. Milton's between-tool narration was rendering unfolded, as answer prose.
+ *    The caller stream carries no `thinking` blocks at all — measured on
+ *    production 11/09/2026 — so "Let me also check whether…" arrives as an
+ *    ordinary `text` block, indistinguishable from the answer except by
+ *    POSITION. A text block with any tool call still to come in this turn is
+ *    narration; only the run of text after the LAST tool call is the answer.
+ *    Narration folds into the activity group as a thinking-shaped step.
+ *
+ * That third rule is provisional while a turn streams, and deliberately so: a
+ * text block that is currently last IS the answer as far as anything can know,
+ * and renders as prose. The tool call that arrives after it re-homes it into
+ * the group. Nothing here holds state to make that work — `segment` is pure
+ * and re-derived on every event, so re-homing is just the next call returning
+ * a different shape.
+ *
+ * The cost of the rule is a real answer that Milton interrupts to go back to
+ * the shelf: its first half folds away. That is the trade taken knowingly —
+ * the position of a block is the only signal the stream gives, and a rule read
+ * off the prose itself would be unexplainable the first time it misfired.
  */
 export declare function segment(blocks: Block[]): Segment[];
 /** One line describing a whole investigation, for the collapsed state.

package/dist/transcript.svelte.js

@@ -267,7 +267,7 @@ function renderResult(content) {
 /**
  * Fold a turn's flat block list into what a reader should actually see.
  *
- * Two problems this solves, both reported off a real transcript:
+ * Three problems this solves, all reported off a real transcript:
  *
  * 1. Fifteen tool rows stood between the question and the first word of the
  *    answer, so the answer had to be scrolled to. Contiguous activity becomes
@@ -275,20 +275,44 @@ function renderResult(content) {
  * 2. "Reading pspf guidelines 2026" appeared five times in a row — five pages
  *    of one document, which is one act of reading to a human. Consecutive
  *    steps with the same label collapse to one row carrying a count.
+ * 3. Milton's between-tool narration was rendering unfolded, as answer prose.
+ *    The caller stream carries no `thinking` blocks at all — measured on
+ *    production 11/09/2026 — so "Let me also check whether…" arrives as an
+ *    ordinary `text` block, indistinguishable from the answer except by
+ *    POSITION. A text block with any tool call still to come in this turn is
+ *    narration; only the run of text after the LAST tool call is the answer.
+ *    Narration folds into the activity group as a thinking-shaped step.
+ *
+ * That third rule is provisional while a turn streams, and deliberately so: a
+ * text block that is currently last IS the answer as far as anything can know,
+ * and renders as prose. The tool call that arrives after it re-homes it into
+ * the group. Nothing here holds state to make that work — `segment` is pure
+ * and re-derived on every event, so re-homing is just the next call returning
+ * a different shape.
+ *
+ * The cost of the rule is a real answer that Milton interrupts to go back to
+ * the shelf: its first half folds away. That is the trade taken knowingly —
+ * the position of a block is the only signal the stream gives, and a rule read
+ * off the prose itself would be unexplainable the first time it misfired.
  */
 export function segment(blocks) {
     const out = [];
     let current = null;
-    for (const block of blocks) {
-        if (block.kind === 'text') {
+    let lastTool = -1;
+    for (let i = 0; i < blocks.length; i += 1)
+        if (blocks[i].kind === 'tool')
+            lastTool = i;
+    for (const [i, block] of blocks.entries()) {
+        if (block.kind === 'text' && i > lastTool) {
             current = null;
             out.push(block);
             continue;
         }
         // A thinking block with no text is a row whose chevron opens on nothing.
         // Claude Code's thinking display defaults to "omitted", so most arrive
-        // empty — rendering them is worse than dropping them.
-        if (block.kind === 'thinking' && !block.text.trim())
+        // empty — rendering them is worse than dropping them. An empty narration
+        // block is the same row, for the same reason.
+        if (block.kind !== 'tool' && !block.text.trim())
             continue;
         if (!current) {
             current = {
@@ -318,6 +342,10 @@ function sameStep(a, b) {
         return false;
     if (a.kind === 'thinking')
         return true;
+    // Two narration sentences are two things Milton said; collapsing them to
+    // one row with a count would lose the second one entirely.
+    if (a.kind === 'text')
+        return false;
     const left = describe(a);
     const right = describe(b);
     return left.verb === right.verb && left.object === right.object;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poodle64/librarian",
-	"version": "2026.9.9",
+	"version": "2026.9.11",
 	"description": "Milton's conversation surface as a consumable Svelte 5 package: the stream client, transcript state and chat components (transcript, composer, markdown) every household app renders instead of rebuilding.",
 	"type": "module",
 	"license": "MIT",