@poodle64/librarian 2026.9.21 → 2026.9.22

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

@@ -33,6 +33,8 @@
 		type Citation
 	} from '../../citations';
 	import { DEFAULT_PERSONA, personaName, resolveCopy, type LibrarianCopy } from '../../copy';
+	import type { Verdict } from '../../chat.svelte';
+	import AnswerMark from '../answer-mark/answer-mark.svelte';
 	import Working from '../working/working.svelte';
 	import ActivityGroup from '../activity-group/activity-group.svelte';
 	import ArtefactCard from '../artefact-card/artefact-card.svelte';
@@ -76,6 +78,14 @@
 		onopenartefact?: () => void;
 		/** The persona's own words for its tools, and what they read. */
 		describeTool?: DescribeTool;
+		/** The question waits behind somebody else's. */
+		waiting?: boolean;
+		/** When an answer this page did not start began, epoch ms: it is still
+		 *  being written, and the clock counts from then. */
+		answering?: number;
+		/** 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>;
 	}
 
 	let {
@@ -95,7 +105,10 @@
 		artefact,
 		artefactOpen = false,
 		onopenartefact,
-		describeTool
+		describeTool,
+		waiting = false,
+		answering,
+		onmark
 	}: Props = $props();
 
 	// The prose IS the artefact: it reads in the column, and the transcript
@@ -186,11 +199,16 @@
 			: (outcome?.error ?? (outcome?.isError ? words.answerFailed : null))
 	);
 
+	// A turn nothing is answering any more that said nothing and ended with
+	// nothing: stopped before a word came, often while it waited its turn.
+	const unanswered = $derived(!running && !hasAnswer && outcome === null && !artefact);
+
 	// A run that ended has settled, whatever it said: a failed one, where "Ask
 	// again" is the one thing a reader wants, and one that handed in its answer
 	// under a schema and said nothing at all, whose artefact is the answer. A
-	// turn read back from history has no outcome and settles on its prose.
-	const settled = $derived(!running && (hasAnswer || outcome !== null));
+	// turn read back from history has no outcome and settles on its prose, and
+	// an unanswered one settles on nothing, offering "Ask again".
+	const settled = $derived(!running && (hasAnswer || outcome !== null || unanswered));
 
 	/**
 	 * The persona answered and cited nothing, and we WATCHED it happen.
@@ -252,7 +270,15 @@
 		</header>
 
 		{#if running && segments.length === 0}
-			<Working copy={words} />
+			<Working
+				copy={words}
+				label={waiting
+					? words.waiting
+					: answering !== undefined
+						? words.stillAnswering
+						: undefined}
+				since={answering}
+			/>
 		{/if}
 
 		{#each segments as seg (seg.index)}
@@ -284,6 +310,10 @@
 
 		<!-- An empty `notHeld` is a host whose persona answers from no shelf,
 		     where "without a source" would be a claim about nothing. -->
+		{#if unanswered && asked}
+			<p class="ds-lib-not-held">{words.noAnswer}</p>
+		{/if}
+
 		{#if !isArtefact && notHeld && words.notHeld}
 			<p class="ds-lib-not-held">{words.notHeld}</p>
 		{/if}
@@ -316,7 +346,7 @@
 			<p class="ds-lib-failure" role="alert">{failure}</p>
 		{/if}
 
-		{#if !isArtefact && settled}
+		{#if !isArtefact && settled && (hasAnswer || onregenerate || (outcome && !failure))}
 			<div class="ds-lib-actions">
 				{#if hasAnswer}
 					<button
@@ -329,6 +359,9 @@
 						<span>{copied ? words.copiedAnswer : words.copyAnswer}</span>
 					</button>
 				{/if}
+				{#if onmark && hasAnswer && !failure}
+					<AnswerMark {onmark} copy={words} />
+				{/if}
 				{#if onregenerate}
 					<button
 						type="button"
@@ -515,6 +548,7 @@
 
 	.ds-lib-actions {
 		display: flex;
+		flex-wrap: wrap;
 		align-items: center;
 		gap: 0.25rem;
 		margin-inline-start: -0.375rem;

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

@@ -1,6 +1,7 @@
 import { type Artefact, type Block, type DescribeTool, type Outcome } from '../../transcript.svelte';
 import { type Citation } from '../../citations';
 import { type LibrarianCopy } from '../../copy';
+import type { Verdict } from '../../chat.svelte';
 interface Props {
     question: string;
     blocks: Block[];
@@ -38,6 +39,14 @@ interface Props {
     onopenartefact?: () => void;
     /** The persona's own words for its tools, and what they read. */
     describeTool?: DescribeTool;
+    /** The question waits behind somebody else's. */
+    waiting?: boolean;
+    /** When an answer this page did not start began, epoch ms: it is still
+     *  being written, and the clock counts from then. */
+    answering?: number;
+    /** 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>;
 }
 declare const AgentTranscript: import("svelte").Component<Props, {}, "">;
 type AgentTranscript = ReturnType<typeof AgentTranscript>;

package/dist/components/answer-mark/answer-mark.svelte

@@ -0,0 +1,223 @@
+<!--
+  Helpful or not, on the answer a reader has just read, with an optional note.
+
+  Rendered by `AgentTranscript` inside its action row, between copy and ask
+  again, and only when the host passes `onmark`: the Console asks its own
+  library, where nothing can take a mark, and a control a host cannot wire is
+  worse than none (cadmus#114, where this began).
+
+  Several roots on purpose: the two thumbs sit in the row, and the note drops
+  to a line of its own under it (`order`, `flex-basis`), so the keyboard goes
+  verdict, note, ask again, which is the order a reader thinks in.
+
+  The note is optional and opens only after a verdict, so the fast path is one
+  tap. A verdict shows at once and is taken back if it was not recorded; a
+  note says "noted" only once the far side confirms it.
+-->
+<script lang="ts">
+	import ThumbsDownIcon from '@lucide/svelte/icons/thumbs-down';
+	import ThumbsUpIcon from '@lucide/svelte/icons/thumbs-up';
+	import type { Verdict } from '../../chat.svelte';
+	import { resolveCopy, type LibrarianCopy } from '../../copy';
+
+	interface Props {
+		/** Records a verdict, replacing any before it. Resolves true once it is
+		 *  recorded. */
+		onmark: (verdict: Verdict) => Promise<boolean>;
+		copy?: Partial<LibrarianCopy>;
+	}
+
+	let { onmark, copy }: Props = $props();
+
+	const words = $derived(resolveCopy(copy));
+
+	let helpful = $state<boolean | null>(null);
+	let note = $state('');
+	/** The note last recorded, sent again when the verdict flips: the far side
+	 *  replaces the whole mark. */
+	let recorded = $state<string | null>(null);
+	let saving = $state(false);
+	let failed = $state(false);
+	let form = $state<HTMLFormElement | null>(null);
+
+	// The note opens under the last answer, which is where the fold is: it
+	// brings itself into view, and leaves the keyboard where it was, so a
+	// thumb's tap on a phone does not raise one.
+	$effect(() => {
+		form?.scrollIntoView({ block: 'nearest' });
+	});
+
+	async function send(verdict: Verdict): Promise<boolean> {
+		saving = true;
+		failed = false;
+		try {
+			const ok = await onmark(verdict);
+			failed = !ok;
+			return ok;
+		} finally {
+			saving = false;
+		}
+	}
+
+	async function mark(next: boolean) {
+		if (saving || helpful === next) return;
+		const previous = helpful;
+		helpful = next;
+		if (!(await send({ helpful: next, note: recorded }))) helpful = previous;
+	}
+
+	async function submitNote(event: SubmitEvent) {
+		event.preventDefault();
+		const text = note.trim();
+		if (!text || helpful === null || saving) return;
+		if (await send({ helpful, note: text })) recorded = text;
+	}
+</script>
+
+<button
+	type="button"
+	class="ds-lib-mark"
+	class:is-helpful={helpful === true}
+	aria-pressed={helpful === true}
+	aria-label={words.markHelpful}
+	title={words.markHelpful}
+	disabled={saving}
+	onclick={() => mark(true)}
+>
+	<ThumbsUpIcon size={14} />
+</button>
+<button
+	type="button"
+	class="ds-lib-mark"
+	class:is-not-helpful={helpful === false}
+	aria-pressed={helpful === false}
+	aria-label={words.markNotHelpful}
+	title={words.markNotHelpful}
+	disabled={saving}
+	onclick={() => mark(false)}
+>
+	<ThumbsDownIcon size={14} />
+</button>
+
+<!-- A note that failed keeps its box, and the words in it, to try again. -->
+{#if recorded !== null && !failed}
+	<p class="ds-lib-mark-line" role="status">{words.markNoted}</p>
+{:else if helpful !== null}
+	<form bind:this={form} class="ds-lib-mark-line ds-lib-mark-form" onsubmit={submitNote}>
+		<input
+			bind:value={note}
+			maxlength={500}
+			placeholder={words.markNote}
+			aria-label={words.markNote}
+			class="ds-lib-mark-input"
+		/>
+		<button type="submit" class="ds-lib-mark-send" disabled={!note.trim() || saving}>
+			{words.markSend}
+		</button>
+	</form>
+{/if}
+{#if failed}
+	<p class="ds-lib-mark-line ds-lib-mark-failed" role="status">{words.markFailed}</p>
+{/if}
+
+<style>
+	.ds-lib-mark {
+		display: flex;
+		width: 1.75rem;
+		height: 1.75rem;
+		align-items: center;
+		justify-content: center;
+		border: 0;
+		border-radius: var(--ds-radius-md);
+		background: none;
+		color: inherit;
+		cursor: pointer;
+		transition:
+			color 150ms ease,
+			background-color 150ms ease;
+	}
+
+	.ds-lib-mark:hover:not(:disabled) {
+		background: var(--ds-color-surface-1);
+	}
+
+	/* A verdict keeps its colour under the pointer that just gave it. */
+	.ds-lib-mark:hover:not(:disabled, [aria-pressed='true']) {
+		color: var(--ds-color-foreground);
+	}
+
+	.ds-lib-mark:disabled {
+		cursor: default;
+	}
+
+	.ds-lib-mark:focus-visible,
+	.ds-lib-mark-send:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
+	.ds-lib-mark.is-helpful {
+		color: var(--ds-color-status-success);
+	}
+
+	.ds-lib-mark.is-not-helpful {
+		color: var(--ds-color-status-error);
+	}
+
+	/* Its own line under the row, whatever sits after the thumbs in it. */
+	.ds-lib-mark-line {
+		order: 1;
+		flex-basis: 100%;
+		margin: 0.25rem 0 0 0.375rem;
+		font-size: var(--ds-text-2xs);
+	}
+
+	.ds-lib-mark-failed {
+		color: var(--ds-color-status-error);
+	}
+
+	.ds-lib-mark-form {
+		display: flex;
+		max-width: 28rem;
+		min-width: 0;
+		gap: 0.5rem;
+	}
+
+	.ds-lib-mark-input {
+		min-width: 0;
+		flex: 1;
+		border: 1px solid var(--ds-color-border);
+		border-radius: var(--ds-radius-md);
+		background: var(--ds-color-surface-1);
+		padding: 0.375rem 0.625rem;
+		color: var(--ds-color-foreground);
+		font: inherit;
+		font-size: 0.875rem;
+	}
+
+	.ds-lib-mark-input::placeholder {
+		color: var(--ds-color-muted-foreground);
+	}
+
+	.ds-lib-mark-input:focus {
+		border-color: color-mix(in oklab, var(--ds-color-primary) 60%, transparent);
+		outline: none;
+	}
+
+	.ds-lib-mark-send {
+		flex: none;
+		border: 1px solid var(--ds-color-border);
+		border-radius: var(--ds-radius-md);
+		background: none;
+		padding: 0.25rem 0.75rem;
+		color: var(--ds-color-foreground);
+		font: inherit;
+		font-size: 0.8125rem;
+		cursor: pointer;
+	}
+
+	.ds-lib-mark-send:disabled {
+		cursor: default;
+		opacity: 0.4;
+	}
+</style>

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

@@ -0,0 +1,11 @@
+import type { Verdict } from '../../chat.svelte';
+import { type LibrarianCopy } from '../../copy';
+interface Props {
+    /** Records a verdict, replacing any before it. Resolves true once it is
+     *  recorded. */
+    onmark: (verdict: Verdict) => Promise<boolean>;
+    copy?: Partial<LibrarianCopy>;
+}
+declare const AnswerMark: import("svelte").Component<Props, {}, "">;
+type AnswerMark = ReturnType<typeof AnswerMark>;
+export default AnswerMark;

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

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

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

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

package/dist/components/conversation/conversation.svelte

@@ -12,6 +12,7 @@
 	import type { Snippet } from 'svelte';
 	import ArrowDownIcon from '@lucide/svelte/icons/arrow-down';
 	import type { DescribeTool, Turn } from '../../transcript.svelte';
+	import type { Verdict } from '../../chat.svelte';
 	import type { Citation, LoadDocument } from '../../citations';
 	import { DEFAULT_PERSONA, personaName, resolveCopy, type LibrarianCopy } from '../../copy';
 	import { FollowScroll } from '../../follow-scroll.svelte';
@@ -51,6 +52,14 @@
 		/** Asks a follow-up the librarian suggested. Offered on the last answer
 		 *  only; without it the suggestion chips do not render. */
 		onsuggest?: (question: string) => void;
+		/** 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>;
+		/** 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
+		 *  start (`Chat.answering`): it reads as still being written. */
+		answering?: number | null;
 		/** Overrides for the package's own words. */
 		copy?: Partial<LibrarianCopy>;
 		/** Enables the source pane. Without it, chips render but do not open. */
@@ -85,6 +94,9 @@
 		scope,
 		onregenerate,
 		onsuggest,
+		onmark,
+		waiting = false,
+		answering = null,
 		copy,
 		loadDocument,
 		oncite,
@@ -256,11 +268,14 @@
 					{/if}
 
 					{#each turns as turn, index (turn.id)}
+						{@const last = index === turns.length - 1}
 						<AgentTranscript
 							question={turn.question}
 							blocks={turn.blocks}
 							outcome={turn.outcome}
-							running={running && index === turns.length - 1}
+							running={running && last}
+							waiting={waiting && last}
+							answering={last ? (answering ?? undefined) : undefined}
 							citations={turn.citations ?? []}
 							suggestions={turn.suggestions ?? []}
 							{collectionNames}
@@ -272,8 +287,11 @@
 							onopenartefact={opener(turn)}
 							{describeTool}
 							oncite={oncite || loadDocument ? cite : undefined}
-							onregenerate={index === turns.length - 1 && !running ? onregenerate : undefined}
-							onsuggest={index === turns.length - 1 && !running ? onsuggest : undefined}
+							onregenerate={last && !running ? onregenerate : undefined}
+							onsuggest={last && !running ? onsuggest : undefined}
+							onmark={last && !running && onmark
+								? (verdict) => onmark(turn, verdict)
+								: undefined}
 						/>
 					{/each}
 				</div>

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

@@ -1,5 +1,6 @@
 import type { Snippet } from 'svelte';
 import type { DescribeTool, Turn } from '../../transcript.svelte';
+import type { Verdict } from '../../chat.svelte';
 import type { Citation, LoadDocument } from '../../citations';
 import { type LibrarianCopy } from '../../copy';
 interface Props {
@@ -28,6 +29,14 @@ interface Props {
     /** Asks a follow-up the librarian suggested. Offered on the last answer
      *  only; without it the suggestion chips do not render. */
     onsuggest?: (question: string) => void;
+    /** 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>;
+    /** 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
+     *  start (`Chat.answering`): it reads as still being written. */
+    answering?: number | null;
     /** Overrides for the package's own words. */
     copy?: Partial<LibrarianCopy>;
     /** Enables the source pane. Without it, chips render but do not open. */