@poodle64/librarian 2026.9.24 → 2026.9.26

package/README.md

@@ -252,6 +252,46 @@ artefact })` says that kind opens, on a live turn and a reopened one alike:
 `{ title: 'Briefing', isAnswer: true }` cards it and opens its prose in the
 column. `again()` asks it as the same kind.
 
+### Depth: Quick or Thorough, and what it cost
+
+`Composer`'s `depth` is optional and bindable, and entirely opt-in: omit it
+and the composer renders exactly as it always has. Bind it, the host's own
+`$state<Depth>('quick')`, and the switch always renders, both sides always
+enabled. The operator's ruling (30/09/2026) is that once a room offers the
+choice, it is never disabled, hidden, greyed out, or explained by naming a
+model. `depth` is `'quick' | 'thorough'`, exported from
+`@poodle64/librarian/composer` and `@poodle64/librarian/client`.
+
+```svelte
+<Composer bind:value={chat.draft} bind:depth onsubmit={() => chat.ask(undefined, undefined, depth)} ... />
+```
+
+`chat.ask(question?, kind?, depth?)` carries it to `client.ask()`'s `depth`,
+`StoredTurn.depth` reads it back, and `again()` keeps it: the same shape as
+`kind`, alongside it rather than replacing it. A host whose route does not
+read `depth` yet is unaffected, since the field rides along and is ignored.
+
+Under a settled answer, `AgentTranscript`'s footer folds the turn's `depth`
+and `outcome.costUsd` into the ONE line that already showed the duration:
+`Quick · 56 s · about A$0.34`. Both are opt-in the same way: pass `depth` to
+`Conversation`/`AgentTranscript` (it already has it, from `Turn.depth`) and a
+`formatCost(usd) => string` to price it in the host's own currency and words
+("about A$0.34"; cadmus converts USD to AUD with its own setting). Without
+`depth` the line renders exactly as before (`56.3s`). Without `formatCost`,
+or where `costUsd` is `0` (a local model), it shows depth and duration only,
+never a raw USD figure and never which model answered.
+
+Past `turnLimit` turns (`Composer`'s prop, 8 by default), a quiet banner
+appears above the box, "This conversation is getting long. A new question
+keeps Milton quick." with a "New question" button, because a follow-up
+re-reads the whole conversation, so each one costs more than the last.
+`turnCount` and `onnewquestion` are both required for it to render; either
+missing and the composer stays as it is today.
+
+None of this prices anything before asking, and none of it names a model.
+That is the operator's ruling on what a colleague sees, and the package
+never puts a control in front of it.
+
 The transport is the app's own client over its routes, and the shapes are
 the routes' own bodies (`ConversationSummary`, `ConversationRead`,
 `StoredTurn`, `Quota`), so the stamped slice returns them as they are and

package/dist/chat.svelte.d.ts

@@ -19,7 +19,7 @@
  * routes, and its shapes are the routes' own bodies, so a stamped app passes
  * what its client returns straight through.
  */
-import { type AgentEvent } from './client';
+import { type AgentEvent, type Depth } from './client';
 import type { Citation } from './citations';
 import { type Artefact, type Turn } from './transcript.svelte';
 /** One conversation in the list. */
@@ -43,6 +43,8 @@ export interface StoredTurn {
     citations?: Citation[];
     /** What the host asked for, when it was not a plain question. */
     kind?: string | null;
+    /** How hard the persona worked on this one. */
+    depth?: Depth | null;
 }
 /** A conversation reopened. */
 export interface ConversationRead extends ConversationSummary {
@@ -73,6 +75,8 @@ export interface AskRequest {
     signal: AbortSignal;
     /** What the host asked for, when it is not a plain question: `client.ask()`'s `kind`. */
     kind?: string;
+    /** How hard the persona should work on this one: `client.ask()`'s `depth`. */
+    depth?: Depth;
 }
 /**
  * A room's routes, as the host's own client reaches them. Every method but
@@ -171,13 +175,13 @@ export declare class Chat {
     new(): void;
     /**
      * Ask `question`, or what is in the box, as a `kind` of turn when it is not
-     * a plain question. Resolves once the turn settles: true if it was asked,
-     * false if it was refused, here or by the server, in which case typed words
-     * go back into the box.
+     * a plain question, at a `depth` when the host offers the choice. Resolves
+     * once the turn settles: true if it was asked, false if it was refused,
+     * here or by the server, in which case typed words go back into the box.
      */
-    ask(question?: string, kind?: string): Promise<boolean>;
+    ask(question?: string, kind?: string, depth?: Depth): Promise<boolean>;
     /** The last question again, as a new turn: the conversation is append-only,
-     *  because the agent's transcript is. */
+     *  because the agent's transcript is. Same kind, same depth. */
     again(): Promise<boolean>;
     /** Stop the answer being written, wherever it is being written. */
     stop(): Promise<void>;

package/dist/chat.svelte.js

@@ -145,11 +145,11 @@ export class Chat {
     }
     /**
      * Ask `question`, or what is in the box, as a `kind` of turn when it is not
-     * a plain question. Resolves once the turn settles: true if it was asked,
-     * false if it was refused, here or by the server, in which case typed words
-     * go back into the box.
+     * a plain question, at a `depth` when the host offers the choice. Resolves
+     * once the turn settles: true if it was asked, false if it was refused,
+     * here or by the server, in which case typed words go back into the box.
      */
-    async ask(question, kind) {
+    async ask(question, kind, depth) {
         const typed = question === undefined;
         const text = (question ?? this.draft).trim();
         if (!text)
@@ -163,13 +163,15 @@ export class Chat {
             this.draft = '';
             this.files = [];
         }
-        return this.#ask(text, files, typed, kind);
+        return this.#ask(text, files, typed, kind, depth);
     }
     /** The last question again, as a new turn: the conversation is append-only,
-     *  because the agent's transcript is. */
+     *  because the agent's transcript is. Same kind, same depth. */
     again() {
         const last = this.turns.at(-1);
-        return last?.question ? this.ask(last.question, last.kind) : Promise.resolve(false);
+        return last?.question
+            ? this.ask(last.question, last.kind, last.depth)
+            : Promise.resolve(false);
     }
     /** Stop the answer being written, wherever it is being written. */
     async stop() {
@@ -301,7 +303,7 @@ export class Chat {
         this.answering = null;
         this.waiting = false;
     }
-    async #ask(text, files, typed, kind) {
+    async #ask(text, files, typed, kind, depth) {
         const room = this.#room;
         const mine = this.#generation;
         const stream = { controller: new AbortController(), stopWanted: false };
@@ -315,6 +317,7 @@ export class Chat {
             citations: [],
             suggestions: [],
             kind,
+            depth,
             artefact: this.#card(kind)
         });
         const live = this.#turns[this.#turns.length - 1];
@@ -329,7 +332,8 @@ export class Chat {
             files,
             resume: this.conversationId,
             signal: stream.controller.signal,
-            kind
+            kind,
+            depth
         })) {
             const named = event.type === 'system' && event.subtype === 'init' ? event.session_id : undefined;
             if (stream.stopWanted) {
@@ -551,7 +555,8 @@ function storedTurn(conversation, index, stored) {
         blocks: stored.answer ? [{ kind: 'text', index: 0, text: stored.answer }] : [],
         outcome: null,
         citations: stored.citations ?? [],
-        kind: stored.kind ?? undefined
+        kind: stored.kind ?? undefined,
+        depth: stored.depth ?? undefined
     };
 }
 function epoch(value) {

package/dist/client.d.ts

@@ -8,6 +8,15 @@
  * event type needs no change on either side.
  */
 import type { Citation } from './citations';
+/**
+ * How hard the persona works on one question: a reading budget and a model,
+ * both the operator's to set per deployment, never the colleague's concern.
+ * `quick` is always the default; `thorough` always means something — a
+ * bigger budget on the strongest model the room allows, even where that
+ * model is a local one — so a host never has a state where the choice is
+ * greyed out or explained away.
+ */
+export type Depth = 'quick' | 'thorough';
 /** A Claude Code message, whole. `content` is a plain string only on a user frame. */
 export interface AgentMessage {
     id?: string;
@@ -95,6 +104,10 @@ export interface AskOptions {
      *  (`'briefing'`) and interprets what comes back accordingly — the wire
      *  vocabulary is the host's own, never a fixed set here. */
     kind?: string;
+    /** How hard the persona should work on this one. Absent asks for
+     *  whatever the route does by default, so a host that never reads
+     *  `Composer`'s `depth` sends exactly what it always has. */
+    depth?: Depth;
     signal?: AbortSignal;
     /** Where the ask lands. Each app mounts its own ask route. */
     endpoint?: string;

package/dist/client.js

@@ -34,7 +34,8 @@ function requestInit(options, signal) {
                 resume: options.resume ?? null,
                 subtree: options.subtree ?? '',
                 collections: options.collections ?? [],
-                kind: options.kind
+                kind: options.kind,
+                depth: options.depth
             }),
             signal
         };
@@ -49,6 +50,8 @@ function requestInit(options, signal) {
         form.append('files[]', file, file.name);
     if (options.kind)
         form.append('kind', options.kind);
+    if (options.depth)
+        form.append('depth', options.depth);
     return { method: 'POST', credentials: 'include', body: form, signal };
 }
 /**

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

@@ -17,12 +17,14 @@
 	import CopyIcon from '@lucide/svelte/icons/copy';
 	import RefreshCwIcon from '@lucide/svelte/icons/refresh-cw';
 	import {
+		outcomeLine,
 		readerQuestion,
 		readFrom,
 		segment,
 		type Artefact,
 		type Block,
 		type DescribeTool,
+		type Depth,
 		type Outcome,
 		type TextBlock
 	} from '../../transcript.svelte';
@@ -88,6 +90,14 @@
 		/** Records a verdict on this answer. Omit and no mark renders: a
 		 *  control that records nothing is worse than none. */
 		onmark?: (verdict: Verdict) => Promise<boolean>;
+		/** How hard the persona worked on this one, for the footer's cost line
+		 *  (`Quick · 56 s · about A$0.34`). Absent renders the footer exactly
+		 *  as it always has: the duration alone. */
+		depth?: Depth;
+		/** Prices `outcome.costUsd` in the host's own currency and words
+		 *  ("about A$0.34"). The package never converts currency itself,
+		 *  and a zero-cost run (a local model) shows no cost regardless. */
+		formatCost?: (usd: number) => string;
 	}
 
 	let {
@@ -110,7 +120,9 @@
 		describeTool,
 		waiting = false,
 		answering,
-		onmark
+		onmark,
+		depth,
+		formatCost
 	}: AgentTranscriptProps = $props();
 
 	// The prose IS the artefact: it reads in the column, and the transcript
@@ -375,11 +387,12 @@
 						<span>{words.askAgain}</span>
 					</button>
 				{/if}
-				<!-- How long it took, which is not the same fact as when it was
+				<!-- What it took, which is not the same fact as when it was
 				     asked; both are on the card and neither stands in for the
-				     other. -->
+				     other. Depth and cost fold into the SAME line, never a
+				     second one, once the host offers either. -->
 				{#if outcome && !failure}
-					<span class="ds-lib-duration">{((outcome.durationMs ?? 0) / 1000).toFixed(1)}s</span>
+					<span class="ds-lib-duration">{outcomeLine(outcome, depth, words, formatCost)}</span>
 				{/if}
 			</div>
 		{/if}

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

@@ -1,4 +1,4 @@
-import { type Artefact, type Block, type DescribeTool, type Outcome } from '../../transcript.svelte';
+import { type Artefact, type Block, type DescribeTool, type Depth, type Outcome } from '../../transcript.svelte';
 import { type Citation } from '../../citations';
 import { type LibrarianCopy } from '../../copy';
 import type { Verdict } from '../../chat.svelte';
@@ -49,6 +49,14 @@ export interface AgentTranscriptProps {
     /** Records a verdict on this answer. Omit and no mark renders: a
      *  control that records nothing is worse than none. */
     onmark?: (verdict: Verdict) => Promise<boolean>;
+    /** How hard the persona worked on this one, for the footer's cost line
+     *  (`Quick · 56 s · about A$0.34`). Absent renders the footer exactly
+     *  as it always has: the duration alone. */
+    depth?: Depth;
+    /** Prices `outcome.costUsd` in the host's own currency and words
+     *  ("about A$0.34"). The package never converts currency itself,
+     *  and a zero-cost run (a local model) shows no cost regardless. */
+    formatCost?: (usd: number) => string;
 }
 declare const AgentTranscript: import("svelte").Component<AgentTranscriptProps, {}, "">;
 type AgentTranscript = ReturnType<typeof AgentTranscript>;

package/dist/components/composer/composer.svelte

@@ -14,6 +14,7 @@
 -->
 <script lang="ts">
 	import ArrowUpIcon from '@lucide/svelte/icons/arrow-up';
+	import ClockIcon from '@lucide/svelte/icons/clock';
 	import FileTextIcon from '@lucide/svelte/icons/file-text';
 	import PaperclipIcon from '@lucide/svelte/icons/paperclip';
 	import SquareIcon from '@lucide/svelte/icons/square';
@@ -25,8 +26,14 @@
 		MAX_FILES,
 		rejectionMessage
 	} from '../../attachments';
+	import type { Depth } from '../../client';
 	import { DEFAULT_PERSONA, resolveCopy, type LibrarianCopy } from '../../copy';
 
+	/** Past this many turns, the long-conversation banner offers to start
+	 *  over: a follow-up re-reads the whole conversation, so each one costs
+	 *  more than the last (measured — the longest ran 2.05M cached tokens). */
+	const DEFAULT_TURN_LIMIT = 8;
+
 	export type Scope = 'document' | 'collection' | 'library';
 
 	interface Props {
@@ -63,6 +70,21 @@
 		 *  sit, in the host's words: what sending does here ("It carries on
 		 *  from where it stopped."). */
 		note?: string;
+		/** Quick or Thorough for the next question, as a two-way switch with a
+		 *  one-line hint. Bind it and pass it to `ask()`; omit it and nothing
+		 *  renders. Once shown it is never disabled or hidden, and never names
+		 *  the model behind it. */
+		depth?: Depth;
+		/** How many turns are in the conversation so far. Past `turnLimit`
+		 *  (8 by default), a quiet banner appears above the box offering to
+		 *  start over. Omit and no banner ever renders — a host that does not
+		 *  track turns keeps today's composer. */
+		turnCount?: number;
+		turnLimit?: number;
+		/** Starts a new conversation, from the banner's own button. Without it
+		 *  the banner never renders, past the limit or not — an offer with no
+		 *  action is worse than none. */
+		onnewquestion?: () => void;
 	}
 
 	let {
@@ -80,7 +102,11 @@
 		name = DEFAULT_PERSONA,
 		copy,
 		note,
-		sendWhileRunning = false
+		sendWhileRunning = false,
+		depth = $bindable(),
+		turnCount,
+		turnLimit = DEFAULT_TURN_LIMIT,
+		onnewquestion
 	}: Props = $props();
 
 	/** Nothing can be said right now: a chat whose answer is still coming. */
@@ -88,6 +114,12 @@
 
 	const words = $derived(resolveCopy(copy, name));
 
+	// The banner needs somewhere to send a reader AND a reason to show at
+	// all: a host that never counts turns gets today's composer, unchanged.
+	const longConversation = $derived(
+		turnCount !== undefined && turnCount > turnLimit && Boolean(onnewquestion)
+	);
+
 	// What Milton is being asked about — this document, this collection, or
 	// the whole library. Callers that have no narrower scope pass neither
 	// name, leaving "The whole library" the sole entry — and a sole entry is
@@ -212,6 +244,16 @@
 		? '0px'
 		: 'env(safe-area-inset-bottom, 0px)'}"
 >
+	{#if longConversation}
+		<div class="ds-lib-long" role="status">
+			<ClockIcon size={16} />
+			<span>{words.longConversation}</span>
+			<button type="button" class="ds-lib-long-new" onclick={onnewquestion}>
+				{words.newQuestion}
+			</button>
+		</div>
+	{/if}
+
 	<div class="ds-lib-box">
 		{#if files.length > 0}
 			<ul class="ds-lib-files">
@@ -279,6 +321,31 @@
 				</button>
 			{/if}
 
+			{#if depth !== undefined}
+				<div role="group" aria-label={words.depthGroupLabel} class="ds-lib-depth">
+					<button
+						type="button"
+						aria-pressed={depth === 'quick'}
+						class="ds-lib-depth-side"
+						class:is-chosen={depth === 'quick'}
+						onclick={() => (depth = 'quick')}
+					>
+						{words.depthQuick}
+					</button>
+					<button
+						type="button"
+						aria-pressed={depth === 'thorough'}
+						class="ds-lib-depth-side"
+						class:is-chosen={depth === 'thorough'}
+						onclick={() => (depth = 'thorough')}
+					>
+						{words.depthThorough}
+					</button>
+				</div>
+				<span class="ds-lib-note">
+					{depth === 'quick' ? words.depthQuickHint : words.depthThoroughHint}
+				</span>
+			{/if}
 			{#if hasChoice}
 				<div class="ds-lib-scopes">
 					{#each choices as choice (choice.id)}
@@ -415,8 +482,10 @@
 
 	.ds-lib-controls {
 		display: flex;
+		flex-wrap: wrap;
 		align-items: center;
 		gap: 0.5rem;
+		row-gap: 0.375rem;
 		padding: 0 0.75rem 0.625rem;
 	}
 
@@ -538,6 +607,91 @@
 		font-size: var(--ds-text-2xs);
 	}
 
+	/* A labelled button group, never a select: two states a reader compares
+	   at a glance, not a list to open. 44px touch targets throughout — the
+	   one row here a colleague reaches for on every single question. */
+	.ds-lib-depth {
+		display: flex;
+		flex: none;
+		gap: 0.125rem;
+		border-radius: var(--ds-radius-lg);
+		background: var(--ds-color-surface-3);
+		padding: 0.1875rem;
+	}
+
+	.ds-lib-depth-side {
+		min-width: 2.75rem;
+		min-height: 2.75rem;
+		border: 0;
+		border-radius: var(--ds-radius-md);
+		background: none;
+		padding: 0 0.75rem;
+		color: var(--ds-color-muted-foreground);
+		font: inherit;
+		font-size: var(--ds-text-2xs);
+		cursor: pointer;
+		transition:
+			color 150ms ease,
+			background-color 150ms ease;
+	}
+
+	.ds-lib-depth-side:hover {
+		color: var(--ds-color-foreground);
+	}
+
+	.ds-lib-depth-side.is-chosen {
+		background: var(--ds-color-primary);
+		color: var(--ds-color-primary-foreground);
+		font-weight: 600;
+	}
+
+	.ds-lib-depth-side:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
+	/* Above the box, never inside it: it is about the conversation so far,
+	   not this one question. Warning-tinted, never error — nothing has gone
+	   wrong, a follow-up just costs more than the last one did. */
+	.ds-lib-long {
+		display: flex;
+		align-items: center;
+		gap: 0.625rem;
+		border: 1px solid color-mix(in oklab, var(--ds-color-status-warning) 40%, transparent);
+		border-radius: var(--ds-radius-lg);
+		background: color-mix(in oklab, var(--ds-color-status-warning) 12%, transparent);
+		padding: 0.5rem 0.5rem 0.5rem 0.875rem;
+		color: var(--ds-color-foreground);
+		font-size: 0.875rem;
+	}
+
+	.ds-lib-long span {
+		flex: 1;
+	}
+
+	.ds-lib-long-new {
+		min-height: 2.75rem;
+		flex: none;
+		border: 1px solid var(--ds-color-border);
+		border-radius: var(--ds-radius-md);
+		background: transparent;
+		padding: 0 0.875rem;
+		color: var(--ds-color-foreground);
+		font: inherit;
+		font-size: var(--ds-text-2xs);
+		cursor: pointer;
+		transition: background-color 150ms ease;
+	}
+
+	.ds-lib-long-new:hover {
+		background: var(--ds-color-surface-2);
+	}
+
+	.ds-lib-long-new:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
 	@media (prefers-reduced-motion: reduce) {
 		.ds-lib-composer-lift {
 			transition: none;

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

@@ -1,3 +1,4 @@
+import type { Depth } from '../../client';
 import { type LibrarianCopy } from '../../copy';
 export type Scope = 'document' | 'collection' | 'library';
 interface Props {
@@ -34,7 +35,22 @@ interface Props {
      *  sit, in the host's words: what sending does here ("It carries on
      *  from where it stopped."). */
     note?: string;
+    /** Quick or Thorough for the next question, as a two-way switch with a
+     *  one-line hint. Bind it and pass it to `ask()`; omit it and nothing
+     *  renders. Once shown it is never disabled or hidden, and never names
+     *  the model behind it. */
+    depth?: Depth;
+    /** How many turns are in the conversation so far. Past `turnLimit`
+     *  (8 by default), a quiet banner appears above the box offering to
+     *  start over. Omit and no banner ever renders — a host that does not
+     *  track turns keeps today's composer. */
+    turnCount?: number;
+    turnLimit?: number;
+    /** Starts a new conversation, from the banner's own button. Without it
+     *  the banner never renders, past the limit or not — an offer with no
+     *  action is worse than none. */
+    onnewquestion?: () => void;
 }
-declare const Composer: import("svelte").Component<Props, {}, "value" | "files">;
+declare const Composer: import("svelte").Component<Props, {}, "value" | "depth" | "files">;
 type Composer = ReturnType<typeof Composer>;
 export default Composer;

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

@@ -1,3 +1,4 @@
 export { default as Composer } from './composer.svelte';
 export { default } from './composer.svelte';
 export type { Scope } from './composer.svelte';
+export type { Depth } from '../../client';

package/dist/components/conversation/conversation.svelte

@@ -78,6 +78,11 @@
 		showing?: string;
 		/** The persona's own words for its tools, and what they read. */
 		describeTool?: DescribeTool;
+		/** Prices a turn's `outcome.costUsd` in the host's own currency and
+		 *  words ("about A$0.34"), for the footer's cost line beside a turn's
+		 *  `depth`. The package never converts currency itself; omitted, the
+		 *  line shows depth and duration only. */
+		formatCost?: (usd: number) => string;
 		collectionNames?: Set<string>;
 		/** The composer, rendered INSIDE the transcript column so the source
 		 *  pane narrows it too — a composer the host places outside slides
@@ -117,7 +122,8 @@
 		collectionNames = new Set(),
 		composer,
 		turn: presentTurn,
-		lead
+		lead,
+		formatCost
 	}: Props = $props();
 
 	// Resolved ONCE, here, and handed down whole: every child takes `copy` and
@@ -231,6 +237,16 @@
 		if (onopenartefact) return showing === turn.id;
 		return column?.kind === 'artefact' && column.turn.id === turn.id;
 	}
+
+	// Lifts the shell's report button (`@poodle64/ui` ReportWidget) clear of
+	// Send, which shares its corner. Set on the document because the button
+	// renders outside this subtree; a constant because Send is always the
+	// composer's last row.
+	$effect(() => {
+		if (!composer || typeof document === 'undefined') return;
+		document.documentElement.style.setProperty('--ds-report-clearance', '4.5rem');
+		return () => document.documentElement.style.removeProperty('--ds-report-clearance');
+	});
 </script>
 
 <div class="ds-lib-surface">
@@ -301,6 +317,8 @@
 							artefactOpen: isShowing(turn),
 							onopenartefact: opener(turn),
 							describeTool,
+							depth: turn.depth,
+							formatCost,
 							oncite: oncite || loadDocument ? cite : undefined,
 							onregenerate: last && !running ? onregenerate : undefined,
 							onsuggest: last && !running ? onsuggest : undefined,

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

@@ -54,6 +54,11 @@ interface Props {
     showing?: string;
     /** The persona's own words for its tools, and what they read. */
     describeTool?: DescribeTool;
+    /** Prices a turn's `outcome.costUsd` in the host's own currency and
+     *  words ("about A$0.34"), for the footer's cost line beside a turn's
+     *  `depth`. The package never converts currency itself; omitted, the
+     *  line shows depth and duration only. */
+    formatCost?: (usd: number) => string;
     collectionNames?: Set<string>;
     /** The composer, rendered INSIDE the transcript column so the source
      *  pane narrows it too — a composer the host places outside slides

package/dist/copy.d.ts

@@ -44,6 +44,18 @@ export interface LibrarianCopy {
     /** The composer's placeholder, idle and while an answer streams. */
     askPlaceholder: string;
     answeringPlaceholder: string;
+    /** The depth switch: its group's accessible name, each side's label, and
+     *  the one-line hint beside it saying what the picked side is for. Never
+     *  which model sits behind it — that is never the colleague's concern. */
+    depthGroupLabel: string;
+    depthQuick: string;
+    depthThorough: string;
+    depthQuickHint: string;
+    depthThoroughHint: string;
+    /** Past a few turns, the quiet line above the composer that offers to
+     *  start over — a follow-up re-reads the whole conversation, so each one
+     *  costs more than the last. */
+    longConversation: string;
     /** The pre-first-token words, cycled one every 2.6s. */
     working: string[];
     /** The scroll region's accessible name. */

package/dist/copy.js

@@ -66,6 +66,12 @@ export function copyFor(name = DEFAULT_PERSONA) {
         welcome: `Ask ${who} a question.`,
         askPlaceholder: `Ask ${who}…`,
         answeringPlaceholder: `${who} is answering…`,
+        depthGroupLabel: `How hard ${who} works`,
+        depthQuick: 'Quick',
+        depthThorough: 'Thorough',
+        depthQuickHint: 'Fast, for looking something up',
+        depthThoroughHint: 'Slower, reads more, for questions of interpretation',
+        longConversation: `This conversation is getting long. A new question keeps ${who} quick.`,
         working: [`${who} is looking`, `${who} is reading`],
         conversationLabel: `Conversation with ${who}`,
         copyAnswer: 'Copy',

package/dist/transcript.svelte.d.ts

@@ -6,8 +6,10 @@
  * deltas that belong to each. An event type this does not know about is kept
  * verbatim under `other`, so nothing is silently dropped.
  */
-import type { AgentEvent } from './client';
+import type { AgentEvent, Depth } from './client';
 import type { Citation } from './citations';
+import type { LibrarianCopy } from './copy';
+export type { Depth };
 export interface TextBlock {
     kind: 'text';
     index: number;
@@ -208,6 +210,9 @@ export interface Turn {
     /** What the host asked for when this was not a plain question
      *  (`'briefing'`), in its own word, as `client.ask()` sent it. */
     kind?: string;
+    /** How hard the persona worked on this one, as `client.ask()` sent it.
+     *  Absent, a host that never offers the choice. */
+    depth?: Depth;
 }
 /** A turn's artefact, in the host's own words. */
 export interface Artefact {
@@ -258,6 +263,23 @@ export declare function segment(blocks: Block[], describeTool?: DescribeTool): S
  * it organises what it knows is not — no collection count, no shelf, no corpus.
  */
 export declare function summariseActivity(group: ActivityGroup): string;
+/**
+ * What a settled answer took, as one quiet line: `Quick · 56 s · about
+ * A$0.34`. Depth first (absent on a turn the host never asked one for, or
+ * one read back before the feature shipped), then the duration, then what it
+ * cost — only when the host can price it (`formatCost`) and the run actually
+ * spent something, since a zero-cost run (a local model) has nothing worth
+ * saying about money.
+ *
+ * The host prices `outcome.costUsd`, never this package: the currency and
+ * the rate are the app's own setting, not something a shared component
+ * should be converting.
+ *
+ * A turn asked with no depth at all renders exactly what this line always
+ * has (`56.3s`, one decimal, no gap) — a host that never wires depth sees no
+ * change here either.
+ */
+export declare function outcomeLine(outcome: Outcome, depth: Depth | undefined, words: Pick<LibrarianCopy, 'depthQuick' | 'depthThorough'>, formatCost?: (usd: number) => string): string;
 /**
  * What a turn's calls read that a reader can open, numbered in the order it
  * was first read: the host's `ToolWords.source`, as the sources the answer

package/dist/transcript.svelte.js

@@ -438,6 +438,31 @@ export function summariseActivity(group) {
     const parts = group.tallies.map((t) => `${t.count} ${t.count === 1 ? t.one : t.many}`);
     return parts.length ? parts.join(' · ') : 'Looked into it';
 }
+/**
+ * What a settled answer took, as one quiet line: `Quick · 56 s · about
+ * A$0.34`. Depth first (absent on a turn the host never asked one for, or
+ * one read back before the feature shipped), then the duration, then what it
+ * cost — only when the host can price it (`formatCost`) and the run actually
+ * spent something, since a zero-cost run (a local model) has nothing worth
+ * saying about money.
+ *
+ * The host prices `outcome.costUsd`, never this package: the currency and
+ * the rate are the app's own setting, not something a shared component
+ * should be converting.
+ *
+ * A turn asked with no depth at all renders exactly what this line always
+ * has (`56.3s`, one decimal, no gap) — a host that never wires depth sees no
+ * change here either.
+ */
+export function outcomeLine(outcome, depth, words, formatCost) {
+    const seconds = (outcome.durationMs ?? 0) / 1000;
+    if (!depth)
+        return `${seconds.toFixed(1)}s`;
+    const parts = [depth === 'quick' ? words.depthQuick : words.depthThorough, `${Math.round(seconds)} s`];
+    if (formatCost && outcome.costUsd)
+        parts.push(formatCost(outcome.costUsd));
+    return parts.join(' · ');
+}
 /**
  * What a turn's calls read that a reader can open, numbered in the order it
  * was first read: the host's `ToolWords.source`, as the sources the answer

package/package.json

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