@poodle64/librarian 2026.9.10 → 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/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/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/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.10",
+	"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",