@poodle64/librarian 2026.9.25 → 2026.9.27

package/README.md

@@ -29,6 +29,7 @@ src/lib/
     conversation/          the whole reading surface: scroll, pill, pane, composer slot
     conversation-list/     past conversations, newest first: reopen, rename, download, delete
     answer-mark/           helpful or not, with a note, on the last answer
+    answer-share/          share an answer read-only, and stop sharing it
     fair-use-notice/       today's allowance, beside the composer
     scope-statement/       what this room answers from, and what it does not hold
     agent-transcript/      one question and everything Milton did answering it
@@ -252,6 +253,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
@@ -268,6 +309,7 @@ the transport passes them through:
 | `remove`        | `DELETE conversations/{id}`                           |
 | `download`      | `GET conversations/{id}/export`, as `{ name, body }`  |
 | `mark`          | its answer mark, where the agent takes one (optional) |
+| `share`         | share an answer read-only, or stop (optional)         |
 
 What the controller relies on the routes to say:
 
@@ -299,6 +341,8 @@ the job may go on by itself; `sendWhileRunning` is true.
 | Concern                  | How                                                                                                                                              |
 | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | The answer mark          | `onmark(turn, verdict)` on `Conversation`: resolve true once recorded. Offered on the last settled answer only; without it no mark renders       |
+| Sharing an answer        | `onshare(turn, share)` on `Conversation`, over `chat.share`: every settled answer offers Share, which copies the link `StoredTurn.shared` names; a shared one offers Copy link and Stop sharing. Nothing is shared unless the reader asks. A host's own `turn` places `AnswerShare` (`./answer-share`) with the `onshare` and `shared` it is handed |
+| A shared answer, read    | `Conversation` given `[storedTurn(id, 0, answer)]` from `./chat` and no handlers, no composer: the question, the answer and its sources, read-only, citations opening as in the room |
 | Waiting, still answering | `waiting` and `answering` on `Conversation`, from the controller                                                                                 |
 | The allowance            | `FairUseNotice quota={…}` in the composer snippet: a count while there are questions left, a notice with `support_url` once there are none. Nothing for `exempt`, or a `limit` of 0 |
 | Past conversations       | `ConversationList`: newest first, `href` makes each row a link, and each act renders only when its handler is given; a delete asks first        |

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,10 @@ 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;
+    /** Where this answer's read-only view lives while it is shared. */
+    shared?: string | null;
 }
 /** A conversation reopened. */
 export interface ConversationRead extends ConversationSummary {
@@ -73,6 +77,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
@@ -103,6 +109,10 @@ export interface RoomTransport {
     /** The answer mark, where the agent takes one. `turn` is the answer's
      *  zero-based position in the conversation. */
     mark?(id: string, turn: number, verdict: Verdict): Promise<void>;
+    /** Shares answer `turn` read-only with whoever may enter the room, or
+     *  stops sharing it. Resolves to where it is read while shared, null once
+     *  it is not. */
+    share?(id: string, turn: number, share: boolean): Promise<string | null>;
 }
 /** A job's routes. */
 export interface JobTransport {
@@ -171,13 +181,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>;
@@ -195,4 +205,10 @@ export declare class Chat {
     download(id: string): Promise<boolean>;
     /** Mark an answer the agent holds. False when it could not be recorded. */
     mark(turn: Turn, verdict: Verdict): Promise<boolean>;
+    /** Share an answer the agent holds, or stop sharing it. False when that
+     *  was not recorded. */
+    share(turn: Turn, share: boolean): Promise<boolean>;
 }
+/** A turn as read back, ready for `Conversation`: given one and no handlers,
+ *  that is the read-only view of a shared answer. */
+export declare function storedTurn(conversation: string, index: number, stored: StoredTurn): Turn;

package/dist/chat.svelte.js

@@ -62,6 +62,8 @@ export class Chat {
     #watch = null;
     #woken = false;
     #wake = null;
+    // The turns the server recorded, which its routes count by place; a mark
+    // or a share on one still being written is the server's to refuse.
     // Plain, as `Session`'s seen-set: nothing renders it.
     // eslint-disable-next-line svelte/prefer-svelte-reactivity
     #held = new Set();
@@ -145,11 +147,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 +165,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() {
@@ -277,15 +281,33 @@ export class Chat {
         const id = this.conversationId;
         if (!id || !this.#room?.mark || !this.#held.has(turn.id))
             return false;
-        const position = this.turns.filter((t) => this.#held.has(t.id)).findIndex((t) => t.id === turn.id);
         try {
-            await this.#room.mark(id, position, verdict);
+            await this.#room.mark(id, this.#position(turn), verdict);
             return true;
         }
         catch {
             return false;
         }
     }
+    /** Share an answer the agent holds, or stop sharing it. False when that
+     *  was not recorded. */
+    async share(turn, share) {
+        const id = this.conversationId;
+        if (!id || !this.#room?.share || !this.#held.has(turn.id))
+            return false;
+        try {
+            turn.shared = (await this.#room.share(id, this.#position(turn), share)) ?? undefined;
+            this.#version += 1;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** A turn's place among the questions the agent was asked: the server's count. */
+    #position(turn) {
+        return this.turns.filter((t) => this.#held.has(t.id)).findIndex((t) => t.id === turn.id);
+    }
     #leave() {
         this.#generation += 1;
         // A stop still waiting to be addressed is carried on the stream it
@@ -301,7 +323,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 +337,7 @@ export class Chat {
             citations: [],
             suggestions: [],
             kind,
+            depth,
             artefact: this.#card(kind)
         });
         const live = this.#turns[this.#turns.length - 1];
@@ -329,7 +352,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) {
@@ -543,7 +567,9 @@ export class Chat {
         return true;
     }
 }
-function storedTurn(conversation, index, stored) {
+/** A turn as read back, ready for `Conversation`: given one and no handlers,
+ *  that is the read-only view of a shared answer. */
+export function storedTurn(conversation, index, stored) {
     return {
         id: `${conversation}:${index}`,
         question: stored.question,
@@ -551,7 +577,9 @@ 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,
+        shared: stored.shared ?? 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';
@@ -35,6 +37,7 @@
 	import { DEFAULT_PERSONA, personaName, resolveCopy, type LibrarianCopy } from '../../copy';
 	import type { Verdict } from '../../chat.svelte';
 	import AnswerMark from '../answer-mark/answer-mark.svelte';
+	import AnswerShare from '../answer-share/answer-share.svelte';
 	import Working from '../working/working.svelte';
 	import ActivityGroup from '../activity-group/activity-group.svelte';
 	import ArtefactCard from '../artefact-card/artefact-card.svelte';
@@ -88,6 +91,21 @@
 		/** 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>;
+		/** Where this answer's read-only view lives while it is shared, as the
+		 *  host's own address. */
+		shared?: string;
+		/** Shares this answer (true) or stops sharing it (false), resolving
+		 *  true once recorded. Omit and nothing about sharing renders: nothing
+		 *  is shared unless the reader asks. */
+		onshare?: (share: boolean) => 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 +128,11 @@
 		describeTool,
 		waiting = false,
 		answering,
-		onmark
+		onmark,
+		shared,
+		onshare,
+		depth,
+		formatCost
 	}: AgentTranscriptProps = $props();
 
 	// The prose IS the artefact: it reads in the column, and the transcript
@@ -361,6 +383,9 @@
 						<span>{copied ? words.copiedAnswer : words.copyAnswer}</span>
 					</button>
 				{/if}
+				{#if onshare && hasAnswer && !failure}
+					<AnswerShare {onshare} {shared} copy={words} />
+				{/if}
 				{#if onmark && hasAnswer && !failure}
 					<AnswerMark {onmark} copy={words} />
 				{/if}
@@ -375,11 +400,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}
@@ -557,8 +583,10 @@
 		color: var(--ds-color-muted-foreground);
 	}
 
+	/* 44px tall: each is a thumb's target on a phone. */
 	.ds-lib-action {
 		display: flex;
+		min-height: 2.75rem;
 		align-items: center;
 		gap: 0.375rem;
 		border: 0;

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,21 @@ 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>;
+    /** Where this answer's read-only view lives while it is shared, as the
+     *  host's own address. */
+    shared?: string;
+    /** Shares this answer (true) or stops sharing it (false), resolving
+     *  true once recorded. Omit and nothing about sharing renders: nothing
+     *  is shared unless the reader asks. */
+    onshare?: (share: boolean) => 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/answer-share/answer-share.svelte

@@ -0,0 +1,129 @@
+<!--
+  Share one answer read-only with whoever may ask here, and stop sharing it.
+
+  Rendered by `AgentTranscript` in its action row, and by a host's own turn
+  beside its own presentation, only when the host passes `onshare`: nothing
+  is shared unless the reader asks. A share copies its link at once; a
+  browser that refuses a copy after the round trip (Safari) still has "Copy
+  link". Several roots, as `AnswerMark`: the buttons sit in the row, and the
+  line saying who can open it drops under it.
+-->
+<script lang="ts">
+	import { tick } from 'svelte';
+	import CheckIcon from '@lucide/svelte/icons/check';
+	import LinkIcon from '@lucide/svelte/icons/link';
+	import Share2Icon from '@lucide/svelte/icons/share-2';
+	import { resolveCopy, type LibrarianCopy } from '../../copy';
+
+	interface Props {
+		/** Shares the answer (true) or stops sharing it (false), resolving true
+		 *  once recorded. */
+		onshare: (share: boolean) => Promise<boolean>;
+		/** Where the read-only view lives while the answer is shared, as the
+		 *  host's own address. */
+		shared?: string;
+		copy?: Partial<LibrarianCopy>;
+	}
+
+	let { onshare, shared, copy }: Props = $props();
+
+	const words = $derived(resolveCopy(copy));
+
+	let saving = $state(false);
+	let failed = $state(false);
+	let copied = $state(false);
+
+	async function send(share: boolean) {
+		if (saving) return;
+		saving = true;
+		failed = false;
+		try {
+			failed = !(await onshare(share));
+		} finally {
+			saving = false;
+		}
+		if (share && !failed) {
+			await tick();
+			await copyLink();
+		}
+	}
+
+	async function copyLink() {
+		if (!shared) return;
+		try {
+			await navigator.clipboard.writeText(new URL(shared, location.href).href);
+			copied = true;
+			setTimeout(() => (copied = false), 1600);
+		} catch {
+			// Refused; "Copy link" is still there to tap.
+		}
+	}
+</script>
+
+{#if shared}
+	<button type="button" class="ds-lib-share" onclick={copyLink} disabled={saving}>
+		{#if copied}<CheckIcon size={14} />{:else}<LinkIcon size={14} />{/if}
+		<span>{copied ? words.linkCopied : words.copyLink}</span>
+	</button>
+	<button type="button" class="ds-lib-share" onclick={() => send(false)} disabled={saving}>
+		<span>{words.stopSharing}</span>
+	</button>
+{:else}
+	<button type="button" class="ds-lib-share" onclick={() => send(true)} disabled={saving}>
+		<Share2Icon size={14} />
+		<span>{words.share}</span>
+	</button>
+{/if}
+{#if shared || failed}
+	<p class="ds-lib-share-line" class:is-failed={failed} role="status">
+		{failed ? words.shareFailed : words.sharedWith}
+	</p>
+{/if}
+
+<style>
+	/* 44px tall: a thumb's target on a phone. */
+	.ds-lib-share {
+		display: flex;
+		min-height: 2.75rem;
+		align-items: center;
+		gap: 0.375rem;
+		border: 0;
+		border-radius: var(--ds-radius-md);
+		background: none;
+		padding: 0.25rem 0.375rem;
+		color: inherit;
+		font: inherit;
+		font-size: var(--ds-text-2xs);
+		cursor: pointer;
+		transition:
+			color 150ms ease,
+			background-color 150ms ease;
+	}
+
+	.ds-lib-share:hover:not(:disabled) {
+		background: var(--ds-color-surface-1);
+		color: var(--ds-color-foreground);
+	}
+
+	.ds-lib-share:disabled {
+		cursor: default;
+		opacity: 0.6;
+	}
+
+	.ds-lib-share:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
+	/* Its own line under the row, whatever sits after the buttons in it. */
+	.ds-lib-share-line {
+		order: 1;
+		flex-basis: 100%;
+		margin: 0 0 0 0.375rem;
+		font-size: var(--ds-text-2xs);
+	}
+
+	.ds-lib-share-line.is-failed {
+		color: var(--ds-color-status-error);
+	}
+</style>

package/dist/components/answer-share/answer-share.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type LibrarianCopy } from '../../copy';
+interface Props {
+    /** Shares the answer (true) or stops sharing it (false), resolving true
+     *  once recorded. */
+    onshare: (share: boolean) => Promise<boolean>;
+    /** Where the read-only view lives while the answer is shared, as the
+     *  host's own address. */
+    shared?: string;
+    copy?: Partial<LibrarianCopy>;
+}
+declare const AnswerShare: import("svelte").Component<Props, {}, "">;
+type AnswerShare = ReturnType<typeof AnswerShare>;
+export default AnswerShare;

package/dist/components/answer-share/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AnswerShare } from './answer-share.svelte';
+export { default } from './answer-share.svelte';

package/dist/components/answer-share/index.js

@@ -0,0 +1,2 @@
+export { default as AnswerShare } from './answer-share.svelte';
+export { default } from './answer-share.svelte';

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

@@ -57,6 +57,9 @@
 		/** Records a verdict on an answer. Offered on the last answer only, as
 		 *  asking again is; without it no mark renders. */
 		onmark?: (turn: Turn, verdict: Verdict) => Promise<boolean>;
+		/** Shares an answer read-only, or stops sharing it (`Chat.share`).
+		 *  Offered on every settled answer; without it nothing is shareable. */
+		onshare?: (turn: Turn, share: boolean) => Promise<boolean>;
 		/** The last question waits behind somebody else's (`Chat.waiting`). */
 		waiting?: boolean;
 		/** When the last answer began, epoch ms, where this page did not see it
@@ -78,6 +81,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
@@ -106,6 +114,7 @@
 		onregenerate,
 		onsuggest,
 		onmark,
+		onshare,
 		waiting = false,
 		answering = null,
 		copy,
@@ -117,7 +126,8 @@
 		collectionNames = new Set(),
 		composer,
 		turn: presentTurn,
-		lead
+		lead,
+		formatCost
 	}: Props = $props();
 
 	// Resolved ONCE, here, and handed down whole: every child takes `copy` and
@@ -311,11 +321,16 @@
 							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,
 							onmark:
-								last && !running && onmark ? (verdict: Verdict) => onmark(turn, verdict) : undefined
+								last && !running && onmark ? (verdict: Verdict) => onmark(turn, verdict) : undefined,
+							shared: turn.shared,
+							onshare:
+								onshare && !(last && running) ? (share: boolean) => onshare(turn, share) : undefined
 						} satisfies AgentTranscriptProps}
 						{#if presentTurn}
 							{@render presentTurn(props)}

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

@@ -33,6 +33,9 @@ interface Props {
     /** Records a verdict on an answer. Offered on the last answer only, as
      *  asking again is; without it no mark renders. */
     onmark?: (turn: Turn, verdict: Verdict) => Promise<boolean>;
+    /** Shares an answer read-only, or stops sharing it (`Chat.share`).
+     *  Offered on every settled answer; without it nothing is shareable. */
+    onshare?: (turn: Turn, share: boolean) => Promise<boolean>;
     /** The last question waits behind somebody else's (`Chat.waiting`). */
     waiting?: boolean;
     /** When the last answer began, epoch ms, where this page did not see it
@@ -54,6 +57,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. */
@@ -68,6 +80,14 @@ export interface LibrarianCopy {
     markSend: string;
     markNoted: string;
     markFailed: string;
+    /** Sharing an answer: the action, once shared, who can open it, and a
+     *  share or a stop that did not go through. */
+    share: string;
+    copyLink: string;
+    linkCopied: string;
+    stopSharing: string;
+    sharedWith: string;
+    shareFailed: string;
     /** The fair-use notice, while there are questions left and once there are
      *  none, filled by `fill()`: `{resets}` is a time already, "midnight" or
      *  "2:00 pm". */

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',
@@ -84,6 +90,12 @@ export function copyFor(name = DEFAULT_PERSONA) {
         markSend: 'Send',
         markNoted: 'Thanks, noted.',
         markFailed: "That couldn't be sent. Nothing was recorded.",
+        share: 'Share',
+        copyLink: 'Copy link',
+        linkCopied: 'Link copied',
+        stopSharing: 'Stop sharing',
+        sharedWith: `Shared: anyone who can ask ${who} here can open the link.`,
+        shareFailed: "That didn't go through. Try again.",
         // The industry wording, whole: the number, that it is a fair-use limit
         // rather than a fault, and when it comes back. No apology.
         questionsLeft: '{remaining} of {limit} questions left today. Resets at {resets}.',

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,12 @@ 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;
+    /** Where this answer's read-only view lives while it is shared, as the
+     *  host's own address. Absent while it is not. */
+    shared?: string;
 }
 /** A turn's artefact, in the host's own words. */
 export interface Artefact {
@@ -258,6 +266,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.25",
+	"version": "2026.9.27",
 	"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",