@poodle64/librarian 2026.10.2 → 2026.10.4

package/dist/transcript.svelte.js

@@ -6,6 +6,7 @@
  * deltas that belong to each. An event type this does not know about is kept
  * verbatim under `other`, so nothing is silently dropped.
  */
+import { hostOf } from './web-sources';
 /**
  * The question as the READER asked it.
  *
@@ -39,20 +40,35 @@ export function describe(block) {
     const lines = block.result ? block.result.split('\n').length : 0;
     return lines ? { ...said, detail: lines === 1 ? '1 line' : `${lines} lines` } : said;
 }
-const READ = {
-    tally: ['document read', 'documents read'],
-    repeat: ['page', 'pages']
-};
-const SEARCH = { tally: ['search', 'searches'] };
 function describeCall(block) {
     const input = parseInput(block);
     const command = typeof input.command === 'string' ? input.command : '';
     if (block.name === 'Read') {
         const path = str(input.file_path ?? input.path);
-        return { verb: 'Read', object: documentName(path), ...READ };
+        return { verb: 'Read', object: documentName(path) };
+    }
+    if (block.name === 'Write')
+        return { verb: 'Wrote', object: baseName(str(input.file_path)) };
+    if (block.name === 'Edit')
+        return { verb: 'Edited', object: baseName(str(input.file_path)) };
+    if (block.name === 'mcp__library__search') {
+        return { verb: 'Searched the library for', object: str(input.query) };
+    }
+    if (block.name === 'mcp__library__document_content' || block.name === 'mcp__library__document_detail') {
+        return { verb: 'Read a document', object: '' };
+    }
+    if (block.name === 'mcp__supacrawl__supacrawl_search') {
+        return { verb: 'Searched the web for', object: str(input.query) };
+    }
+    if (block.name === 'mcp__supacrawl__supacrawl_scrape') {
+        return { verb: 'Read', object: hostOf(str(input.url)) };
+    }
+    if (block.name.startsWith('mcp__') && block.name.endsWith('__ocr')) {
+        const file = str(input.file_path ?? input.path ?? input.file ?? input.filename ?? input.url);
+        return { verb: 'Read the scanned pages of', object: baseName(file) };
     }
     if (block.name === 'Grep') {
-        return { verb: 'Looked for', object: str(input.pattern), ...SEARCH };
+        return { verb: 'Looked for', object: str(input.pattern) };
     }
     if (block.name === 'Glob') {
         return { verb: 'Looked for documents', object: '' };
@@ -60,14 +76,14 @@ function describeCall(block) {
     if (block.name === 'Bash') {
         if (/\bgrep\b|\brg\b/.test(command)) {
             const quoted = command.match(/["']([^"']{2,60})["']/);
-            return { verb: 'Looked for', object: quoted?.[1] ?? 'a phrase', ...SEARCH };
+            return { verb: 'Looked for', object: quoted?.[1] ?? 'a phrase' };
         }
         if (/\bls\b/.test(command))
             return { verb: 'Looked through the library', object: '' };
         if (/\bfind\b/.test(command))
             return { verb: 'Looked for documents', object: '' };
         if (/\bcat\b|\bhead\b|\bsed\b/.test(command)) {
-            return { verb: 'Read', object: documentName(lastPath(command)), ...READ };
+            return { verb: 'Read', object: documentName(lastPath(command)) };
         }
         if (/\bwc\b/.test(command))
             return { verb: 'Checked', object: '' };
@@ -88,6 +104,7 @@ function parseInput(block) {
     }
 }
 const str = (value) => (typeof value === 'string' ? value : '');
+const baseName = (path) => path.split('/').filter(Boolean).at(-1) ?? '';
 /** A staged path ends with the document's title slug; that is its name. */
 function documentName(path) {
     if (!path)
@@ -154,12 +171,15 @@ export class Transcript {
     outcome = $state(null);
     /** Sources for the answer, from the app's `citations` frame. */
     citations = $state([]);
+    /** The document versions the persona wrote, in order. */
+    written = $state([]);
     other = $state([]);
     #fold = foldState();
     reset() {
         this.blocks = [];
         this.outcome = null;
         this.citations = [];
+        this.written = [];
         this.other = [];
         this.#fold = foldState();
     }
@@ -204,6 +224,22 @@ export function fold(into, state, event) {
         into.citations = (event.items ?? []).filter((item) => typeof item === 'object' && item !== null);
         return true;
     }
+    // The app emits this right after the tool result of a successful Write or
+    // Edit: one version of one document the persona wrote.
+    if (event.type === 'artefact') {
+        if (typeof event.name === 'string' && typeof event.version === 'number') {
+            // Assigned, then pushed through the state's own proxy: `??=` hands back the raw array, and that push redraws nothing.
+            into.written ??= [];
+            into.written.push({
+                name: event.name,
+                version: event.version,
+                media_type: typeof event.media_type === 'string' ? event.media_type : '',
+                bytes: typeof event.bytes === 'number' ? event.bytes : undefined,
+                formats: Array.isArray(event.formats) ? event.formats.map(String) : []
+            });
+        }
+        return true;
+    }
     // No persona and no sentence at this layer: `client.ts` raises this for a
     // stream that would not open or died half-way, and the turn renders the
     // unreachable line in whichever persona's voice the host named.
@@ -321,15 +357,11 @@ function renderResult(content) {
 /**
  * Fold a turn's flat block list into what a reader should actually see.
  *
- * Three problems this solves, all reported off a real transcript:
+ * Two problems this solves, reported off a real transcript:
  *
- * 1. Fifteen tool rows stood between the question and the first word of the
- *    answer, so the answer had to be scrolled to. Contiguous activity becomes
- *    ONE group the caller can collapse.
- * 2. "Reading pspf guidelines 2026" appeared five times in a row — five pages
- *    of one document, which is one act of reading to a human. Consecutive
- *    steps with the same label collapse to one row carrying a count.
- * 3. The persona's between-tool narration was rendering unfolded, as answer prose.
+ * 1. Contiguous activity becomes ONE group, so the answer's prose is never
+ *    split by each step; every step stays its own collapsed row in it.
+ * 2. The persona's between-tool narration was rendering unfolded, as answer prose.
  *    The caller stream carries no `thinking` blocks at all — measured on
  *    production 11/09/2026 — so "Let me also check whether…" arrives as an
  *    ordinary `text` block, indistinguishable from the answer except by
@@ -337,7 +369,7 @@ function renderResult(content) {
  *    narration; only the run of text after the LAST tool call is the answer.
  *    Narration folds into the activity group as a thinking-shaped step.
  *
- * That third rule is provisional while a turn streams, and deliberately so: a
+ * That second rule is provisional while a turn streams, and deliberately so: a
  * text block that is currently last IS the answer as far as anything can know,
  * and renders as prose. The tool call that arrives after it re-homes it into
  * the group. Nothing here holds state to make that work — `segment` is pure
@@ -371,19 +403,11 @@ export function segment(blocks, describeTool) {
         if (block.kind !== 'tool' && !block.text.trim())
             continue;
         if (!current) {
-            current = { kind: 'activity', index: block.index, steps: [], tallies: [] };
+            current = { kind: 'activity', index: block.index, steps: [] };
             out.push(current);
         }
         const words = block.kind === 'tool' ? wordsFor(block, describeTool) : undefined;
-        const last = current.steps.at(-1);
-        if (last && sameStep(last, block, words)) {
-            last.repeats += 1;
-        }
-        else {
-            current.steps.push({ block, repeats: 1, words });
-        }
-        if (words?.tally)
-            count(current, words.tally);
+        current.steps.push({ block, words });
     }
     return out;
 }
@@ -399,33 +423,6 @@ const HANDS_IN = 'StructuredOutput';
 function isStep(block) {
     return block.kind === 'tool' && block.name !== HANDS_IN;
 }
-function sameStep(last, block, words) {
-    if (last.block.kind !== block.kind)
-        return false;
-    if (block.kind === 'thinking')
-        return true;
-    // Two narration sentences are two things the persona said; collapsing them to
-    // one row with a count would lose the second one entirely.
-    if (block.kind === 'text')
-        return false;
-    return last.words?.verb === words?.verb && last.words?.object === words?.object;
-}
-function count(group, [one, many]) {
-    const seen = group.tallies.find((t) => t.one === one && t.many === many);
-    if (seen)
-        seen.count += 1;
-    else
-        group.tallies.push({ one, many, count: 1 });
-}
-/** One line describing a whole investigation, for the collapsed state.
- *
- * Counts of what the persona did are fine ("1 search · 2 documents read"); how
- * it organises what it knows is not — no collection count, no corpus.
- */
-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: `56.3s`, then what it cost
  * — only when the host can price it (`formatCost`) and the run actually

package/dist/web-sources.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The web pages an answer drew on, listed apart from the library's numbered
+ * sources: the pages the turn's supacrawl calls read, and the Markdown links
+ * in the answer itself. A search's results are what it found, not what the
+ * answer drew on, so they stay in the search's own row. Never numbered,
+ * because nothing here is a passage the persona was handed to cite.
+ */
+import type { Block } from './transcript.svelte';
+export interface WebSource {
+    url: string;
+    /** The page's title, or its host where nothing gave one. */
+    title: string;
+    host: string;
+}
+/** A URL's host without a leading `www.`; the text as given where it is no URL. */
+export declare function hostOf(url: string): string;
+/** The pages, once each, in the order the turn met them. */
+export declare function webSources(blocks: Block[], answer: string): WebSource[];

package/dist/web-sources.js

@@ -0,0 +1,58 @@
+/**
+ * The web pages an answer drew on, listed apart from the library's numbered
+ * sources: the pages the turn's supacrawl calls read, and the Markdown links
+ * in the answer itself. A search's results are what it found, not what the
+ * answer drew on, so they stay in the search's own row. Never numbered,
+ * because nothing here is a passage the persona was handed to cite.
+ */
+/** A URL's host without a leading `www.`; the text as given where it is no URL. */
+export function hostOf(url) {
+    try {
+        return new URL(url).hostname.replace(/^www\./, '');
+    }
+    catch {
+        return url;
+    }
+}
+const LINK = /\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;
+function isWeb(url) {
+    return typeof url === 'string' && /^https?:\/\//i.test(url);
+}
+function parse(text) {
+    try {
+        return text ? JSON.parse(text) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function fromTool(block) {
+    if (!block.name.startsWith('mcp__supacrawl__') || !block.name.endsWith('_scrape') || block.isError)
+        return [];
+    const input = parse(block.rawInput);
+    if (!isWeb(input?.url))
+        return [];
+    const page = parse(block.result);
+    const title = [page?.title, page?.metadata?.title].find((t) => typeof t === 'string');
+    return [{ url: input.url, title: title }];
+}
+/** The pages, once each, in the order the turn met them. */
+export function webSources(blocks, answer) {
+    const seen = new Map();
+    const add = (url, title) => {
+        const key = url.replace(/#.*$/, '').replace(/\/$/, '');
+        if (seen.has(key))
+            return;
+        const host = hostOf(url);
+        if (host === url)
+            return;
+        seen.set(key, { url, title: title?.trim() || host, host });
+    };
+    for (const block of blocks)
+        if (block.kind === 'tool')
+            for (const p of fromTool(block))
+                add(p.url, p.title);
+    for (const match of answer.matchAll(LINK))
+        add(match[2], match[1]);
+    return [...seen.values()];
+}

package/dist/written.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The documents a persona writes while it answers.
+ *
+ * The app emits an `artefact` frame after each successful Write or Edit, and a
+ * reopened conversation lists the same versions on its turns. The page shows
+ * each version in the reading column and links it for download; the bytes
+ * come from the host's own route, never from this package.
+ */
+import type { ChatCopy } from './copy';
+import type { Turn } from './transcript.svelte';
+/** One version of one document, as the wire names it. */
+export interface Written {
+    /** A path relative to the conversation's folder; may contain "/". */
+    name: string;
+    /** Counts per name from 1 across the whole conversation. */
+    version: number;
+    /** `text/markdown` or `text/html`. */
+    media_type: string;
+    bytes?: number;
+    /** What the app can render it as beyond the source (`docx`, `pdf`); empty
+     *  where it has no renderer. */
+    formats: string[];
+}
+/** The source of one version, to show it in the pane. */
+export type LoadWritten = (name: string, version: number) => Promise<{
+    text: string;
+    mediaType: string;
+}>;
+/** Where one version downloads as `format` (`source` or one of its `formats`). */
+export type WrittenUrl = (name: string, version: number, format: string) => string;
+export declare const writtenKey: (written: Written) => string;
+export declare const isHtml: (mediaType: string) => boolean;
+/** Every version of `name` across the conversation, oldest first. */
+export declare function writtenVersions(turns: Turn[], name: string): Written[];
+/** What a version downloads as: its source, then each format the app renders. */
+export declare function downloads(written: Written, words: ChatCopy): Array<{
+    format: string;
+    label: string;
+}>;
+/** An empty sandbox stops scripts, not fetches: a written page's <img> or CSS url() would be a beacon without this. */
+export declare const FRAME_CSP = "<meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:\">";
+/**
+ * A written HTML page as its sandboxed frame shows it: under `FRAME_CSP`, and
+ * without a refresh, which navigates the frame itself, a fetch no policy stops.
+ */
+export declare function framed(html: string): string;

package/dist/written.js

@@ -0,0 +1,41 @@
+/**
+ * The documents a persona writes while it answers.
+ *
+ * The app emits an `artefact` frame after each successful Write or Edit, and a
+ * reopened conversation lists the same versions on its turns. The page shows
+ * each version in the reading column and links it for download; the bytes
+ * come from the host's own route, never from this package.
+ */
+export const writtenKey = (written) => `${written.name}@${written.version}`;
+export const isHtml = (mediaType) => mediaType.toLowerCase().startsWith('text/html');
+/** Every version of `name` across the conversation, oldest first. */
+export function writtenVersions(turns, name) {
+    const found = new Map();
+    for (const turn of turns)
+        for (const written of turn.written ?? [])
+            if (written.name === name)
+                found.set(written.version, written);
+    return [...found.values()].sort((a, b) => a.version - b.version);
+}
+/** What a version downloads as: its source, then each format the app renders. */
+export function downloads(written, words) {
+    const label = (format) => format === 'docx' ? words.formatWord : format === 'pdf' ? words.formatPdf : format.toUpperCase();
+    return [
+        { format: 'source', label: isHtml(written.media_type) ? words.formatHtml : words.formatMarkdown },
+        ...written.formats.map((format) => ({ format, label: label(format) }))
+    ];
+}
+/** An empty sandbox stops scripts, not fetches: a written page's <img> or CSS url() would be a beacon without this. */
+export const FRAME_CSP = '<meta http-equiv="Content-Security-Policy" content="default-src \'none\'; style-src \'unsafe-inline\'; img-src data:; font-src data:">';
+/**
+ * A written HTML page as its sandboxed frame shows it: under `FRAME_CSP`, and
+ * without a refresh, which navigates the frame itself, a fetch no policy stops.
+ */
+export function framed(html) {
+    const page = new DOMParser().parseFromString(html, 'text/html');
+    for (const meta of page.querySelectorAll('meta[http-equiv]')) {
+        if (meta.getAttribute('http-equiv')?.trim().toLowerCase() === 'refresh')
+            meta.remove();
+    }
+    return FRAME_CSP + page.documentElement.outerHTML;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poodle64/librarian",
-	"version": "2026.10.2",
+	"version": "2026.10.4",
 	"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",
@@ -43,6 +43,10 @@
 			"types": "./dist/copy.d.ts",
 			"svelte": "./dist/copy.js"
 		},
+		"./written": {
+			"types": "./dist/written.d.ts",
+			"svelte": "./dist/written.js"
+		},
 		"./attachments": {
 			"types": "./dist/attachments.d.ts",
 			"svelte": "./dist/attachments.js"