@inflexa-ai/harness 0.25.0 → 0.26.0

package/dist/memory/conversation-display-storage.js

@@ -39,23 +39,35 @@ const DisplayEnvelopeHeaderSchema = z.object({
  * lifecycle field beside an optional outcome instead would put the meaning of the
  * combination in each reader's head, and readers would disagree.
  */
-const ToolCallDisplaySchema = z
-    .object({
+const ToolCallDisplaySchema = z.object({
     toolCallId: z.string(),
     toolName: z.string(),
     outcome: ToolCallOutcomeSchema,
     detail: z.string().optional(),
-})
-    .strict();
+});
+/**
+ * The schema behind each stored part key.
+ *
+ * Deliberately NOT `.strict()`. These validate rows this package wrote itself,
+ * months earlier, in another process — so the only thing an unknown key can mean
+ * is that the part shed a field since. Rejecting the row for it would make
+ * dropping an optional field, otherwise the safest change available, a
+ * read-breaking one. Zod strips the stale key instead, which is what a reader
+ * would do with it anyway.
+ *
+ * A key stays here as long as rows written under it must still render: the
+ * vocabulary is append-mostly, and retiring an entry is what
+ * {@link parseStoredDisplayEnvelope}'s filter then has to paper over.
+ */
 const dataSchemas = {
     "tool-call": ToolCallDisplaySchema,
-    presentation: PresentationPartSchema.omit({ type: true }).strict(),
-    plan: PlanPartSchema.omit({ type: true }).strict(),
-    "run-card": RunCardPartSchema.omit({ type: true }).strict(),
-    "file-reference": FileReferencePartSchema.omit({ type: true }).strict(),
-    ask: AskPartSchema.omit({ type: true }).strict(),
-    "child-session-started": ChildSessionStartedPartSchema.omit({ type: true }).strict(),
-    "report-rendered": ReportRenderedPartSchema.omit({ type: true }).strict(),
+    presentation: PresentationPartSchema.omit({ type: true }),
+    plan: PlanPartSchema.omit({ type: true }),
+    "run-card": RunCardPartSchema.omit({ type: true }),
+    "file-reference": FileReferencePartSchema.omit({ type: true }),
+    ask: AskPartSchema.omit({ type: true }),
+    "child-session-started": ChildSessionStartedPartSchema.omit({ type: true }),
+    "report-rendered": ReportRenderedPartSchema.omit({ type: true }),
 };
 export function envelopeDisplayMessages(messages) {
     if (messages.length === 0)
@@ -67,14 +79,68 @@ export function envelopeDisplayMessages(messages) {
         messages: structuredClone(messages),
     };
 }
-export async function parseStoredDisplayEnvelope(value, identity) {
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Strip every `data-*` part the current vocabulary cannot render.
+ *
+ * `validateUIMessages` rejects a whole envelope when one part's key is absent
+ * from `dataSchemas`, and exposes no lenient mode, so the filter has to run
+ * ahead of it. Two things go: a part whose key was retired, and a part whose
+ * payload no longer satisfies the schema still standing behind its key — the
+ * second reachable only by making a field required after rows were written,
+ * since the schemas strip rather than reject what they don't know.
+ *
+ * Both are schema evolution, and a transcript missing one card reads better than
+ * a thread that will not load at all. That is the whole line: a part this
+ * package can identify but no longer understands is dropped; anything it cannot
+ * identify AS a part — a non-array `messages`, a part with no `type` — is
+ * corruption, passes through untouched, and still fails the validator. There is
+ * no partial recovery available for a shape you cannot walk.
+ */
+function dropUnrenderableDataParts(messages, identity, logger) {
+    const unknownKey = [];
+    const schemaMismatch = [];
+    const filtered = messages.map((message) => {
+        if (!isRecord(message) || !Array.isArray(message.parts))
+            return message;
+        const parts = message.parts.filter((part) => {
+            if (!isRecord(part) || typeof part.type !== "string" || !part.type.startsWith("data-"))
+                return true;
+            const key = part.type.slice("data-".length);
+            // `Object.hasOwn` before the index: a part typed `data-constructor`
+            // would otherwise resolve up the prototype chain to something that is
+            // not a schema at all, and throw where it should have been dropped.
+            if (!Object.hasOwn(dataSchemas, key)) {
+                unknownKey.push(part.type);
+                return false;
+            }
+            if (!dataSchemas[key].safeParse(part.data).success) {
+                schemaMismatch.push(part.type);
+                return false;
+            }
+            return true;
+        });
+        return parts.length === message.parts.length ? message : { ...message, parts };
+    });
+    if (unknownKey.length > 0 || schemaMismatch.length > 0) {
+        logger?.warn("dropped unrenderable stored display parts", {
+            identity,
+            ...(unknownKey.length > 0 ? { unknownKey: [...new Set(unknownKey)] } : {}),
+            ...(schemaMismatch.length > 0 ? { schemaMismatch: [...new Set(schemaMismatch)] } : {}),
+        });
+    }
+    return filtered;
+}
+export async function parseStoredDisplayEnvelope(value, identity, logger) {
     const header = DisplayEnvelopeHeaderSchema.safeParse(value);
     if (!header.success) {
         throw new Error(`Invalid stored conversation display envelope at ${identity}: ${header.error.message}`);
     }
     try {
         const messages = await validateUIMessages({
-            messages: header.data.messages,
+            messages: dropUnrenderableDataParts(header.data.messages, identity, logger),
             dataSchemas,
             metadataSchema: z.object({ interrupted: z.boolean().optional() }).optional(),
         });
@@ -110,25 +176,6 @@ export function conversationDisplayPart(part) {
     const data = part.type === "tool-call" ? { ...rest, outcome: part.outcome ?? "incomplete" } : rest;
     return { type: displayPartType(part), id: displayPartId(part), data };
 }
-/**
- * Project Cortex display messages into the durable representation.
- *
- * The startup backfill's only path into storage: it renders a legacy turn from
- * the model transcript and freezes the result. The live recorder builds the same
- * shape directly from the event stream instead of round-tripping through
- * `CortexMessage`.
- */
-export function cortexMessagesToConversationUI(messages) {
-    return messages.map((message) => {
-        const parts = message.parts.map((part) => part.type === "text" ? { type: "text", text: part.text, state: "done" } : conversationDisplayPart(part));
-        return {
-            id: message.id,
-            role: message.role,
-            ...(message.interrupted ? { metadata: { interrupted: true } } : {}),
-            parts,
-        };
-    });
-}
 /**
  * Read the durable representation back as Cortex display messages.
  *

package/dist/memory/thread-history.d.ts

@@ -25,9 +25,10 @@ import { ResultAsync } from "neverthrow";
 import type { Pool } from "pg";
 import type { TokenUsageRollup } from "../contracts/usage.js";
 import { type DbError } from "../lib/db-result.js";
+import type { Logger } from "../lib/logger.js";
 import { type StoredMessageEnvelope } from "./ai-sdk-message-storage.js";
 import { type ConversationUIMessage, type StoredDisplayEnvelope } from "./conversation-display-storage.js";
-/** One stored message, as returned by the display read (`loadPage`). */
+/** One stored message, as returned by the display read (`loadAll`). */
 export interface StoredMessage {
     readonly seq: number;
     readonly envelope: StoredMessageEnvelope;
@@ -98,18 +99,6 @@ export interface ConversationTurn {
  * message the turn-boundary predicates fail to recognise.
  */
 export declare function conversationRecordTurn(text: string): ConversationTurn;
-/**
- * A page of stored messages plus pagination metadata. Pagination is
- * turn-based: `total` is the thread's turn count and `page`/`perPage` index
- * turns, while `messages` is the flattened rows of the page's turns.
- */
-export interface MessagePage {
-    readonly messages: StoredMessage[];
-    readonly total: number;
-    readonly page: number;
-    readonly perPage: number;
-    readonly hasMore: boolean;
-}
 /**
  * The result of `retractLastTurn`. `retracted` carries `messages` — the number
  * of rows removed — so a caller can assert exactly what came off the tail. The
@@ -170,13 +159,23 @@ export interface ThreadHistory {
      */
     loadRecent(threadId: string, tokenBudget: number, options?: LoadRecentOptions): ResultAsync<ModelMessage[], DbError>;
     /**
-     * Return one page of a thread's messages oldest-first for UI display —
-     * NOT token-windowed (that is `loadRecent`'s job for the agent loop). No
-     * eviction. Paginated by whole turns: `page`, `perPage`, and `total` count
-     * turns, not rows, so a multi-row turn always reloads intact. `messages`
-     * holds the flattened rows of the selected turns.
+     * Return a thread's messages oldest-first for UI display, grouped into turns.
+     * NOT token-windowed — that is `loadRecent`'s job for the agent loop — and no
+     * eviction.
+     *
+     * There is no paginated form, because a page could never cost less: the read
+     * selects and parses every row of the thread and would slice only afterwards,
+     * so a page saves no query and no parse. It would only truncate the answer,
+     * which is a way to lose turns and not a way to save work. A reader wanting a
+     * window takes one here, where it knows what it is bounding.
+     *
+     * Grouped rather than flat because the grouping is what the read computes and
+     * what a turn count means, and `.flat()` recovers the rows in `seq` order for
+     * a display replay. The reverse does not hold: a flat return would make a
+     * caller that wants the tail turn, or the newest N turns, re-find boundaries
+     * this read already found.
      */
-    loadPage(threadId: string, page: number, perPage: number): ResultAsync<MessagePage, DbError>;
+    loadAll(threadId: string): ResultAsync<StoredMessage[][], DbError>;
     /**
      * Remove the thread's most recent turn — every row from the last
      * genuine-user-start `seq` onward — in a single transaction.
@@ -209,6 +208,13 @@ export interface ThreadHistory {
      * no guarantee, because the tail can move one append later without it.
      */
     latestSeq(threadId: string): ResultAsync<number | null, DbError>;
+    /**
+     * When the thread last moved — `MAX(messages.created_at)`, or `null` for a
+     * thread with no rows. The thread's ACTIVITY clock, and deliberately not
+     * `cortex_analysis_threads.updated_at`: a title rename bumps that column
+     * too, so it cannot answer "has a turn settled since <time>".
+     */
+    latestTurnAt(threadId: string): ResultAsync<Date | null, DbError>;
     /**
      * The count of the thread turns that a person opened past `seq`. A caller
      * reads it as the new work of the thread past an anchor.
@@ -260,5 +266,10 @@ export declare const EVICTION_BLOCK_TURNS = 4;
  * Create a `ThreadHistory` bound to a Postgres pool — a factory closure
  * capturing `pool` (dependency injection per the harness-durable-runtime spec). The `messages` table is
  * provisioned by the project's state-init DDL.
+ *
+ * `logger` serves exactly one purpose: reporting a stored display part the
+ * current vocabulary had to drop. It is optional because the read returns the
+ * same messages either way — the drop reports a deploy, not a failed read — and
+ * requiring it would break every call site over a diagnostic.
  */
-export declare function createThreadHistory(pool: Pool): ThreadHistory;
+export declare function createThreadHistory(pool: Pool, logger?: Logger): ThreadHistory;

package/dist/memory/thread-history.js

@@ -108,7 +108,7 @@ function serializeEnvelope(message) {
 /**
  * Group rows (oldest-first) into turns at genuine-user-start boundaries.
  * Generic over the row shape so the token-windowed read (`loadRecent`) and
- * the display read (`loadPage`) share it, each supplying its own start
+ * the display read (`loadAll`) share it, each supplying its own start
  * predicate.
  */
 function groupTurns(rows, isStart) {
@@ -173,8 +173,13 @@ export const EVICTION_BLOCK_TURNS = 4;
  * Create a `ThreadHistory` bound to a Postgres pool — a factory closure
  * capturing `pool` (dependency injection per the harness-durable-runtime spec). The `messages` table is
  * provisioned by the project's state-init DDL.
+ *
+ * `logger` serves exactly one purpose: reporting a stored display part the
+ * current vocabulary had to drop. It is optional because the read returns the
+ * same messages either way — the drop reports a deploy, not a failed read — and
+ * requiring it would break every call site over a diagnostic.
  */
-export function createThreadHistory(pool) {
+export function createThreadHistory(pool, logger) {
     function appendTurn(threadId, turn) {
         const { modelMessages: messages, displayMessages, turnUsage, turnDurationMs } = turn;
         if (messages.length === 0)
@@ -351,52 +356,40 @@ export function createThreadHistory(pool) {
             return (keepsFirstTurn ? [turns[0], ...retained] : retained).flat().map((row) => row.message);
         });
     }
-    function loadPage(threadId, page, perPage) {
-        const safePerPage = Math.min(Math.max(perPage, 1), 200);
-        const safePage = Math.max(page, 0);
-        return tryQuery("thread-history.loadPage", async () => {
-            // Display pages are turn-bounded, not row-bounded. A serial-tool assistant
-            // turn is persisted as one row per step (plus its tool_result `user` rows),
-            // so a row-windowed page could split a turn — truncating the trailing
-            // report card/text out of the page the UI fetches. Read the thread, group
-            // into turns, and slice whole turns so a turn always reloads intact.
-            // Threads are conversation-scoped and bounded, so reading every row here
-            // matches `loadRecent`'s existing whole-thread read.
-            const { rows } = await pool.query(
-            // ORDER BY must qualify `messages.seq` — a bare `seq` would bind to the
-            // `seq::text AS seq` output alias (Postgres resolves an unqualified
-            // ORDER BY name to the output column), sorting the bigint as text:
-            // "10" before "2". The qualified name forces the bigint column.
-            `SELECT seq::text AS seq, message_envelope, display_envelope, reported_usage, turn_duration_ms::text AS turn_duration_ms
+    // Display reads are turn-bounded, not row-bounded. A serial-tool assistant
+    // turn is persisted as one row per step (plus its tool_result `user` rows),
+    // so a row-windowed page could split a turn — truncating the trailing
+    // report card/text out of the page the UI fetches. Read the thread and group
+    // into turns, so a turn always reloads intact. Threads are conversation-scoped
+    // and bounded, so reading every row here matches `loadRecent`'s existing
+    async function readTurns(threadId) {
+        const { rows } = await pool.query(
+        // ORDER BY must qualify `messages.seq` — a bare `seq` would bind to the
+        // `seq::text AS seq` output alias (Postgres resolves an unqualified
+        // ORDER BY name to the output column), sorting the bigint as text:
+        // "10" before "2". The qualified name forces the bigint column.
+        `SELECT seq::text AS seq, message_envelope, display_envelope, reported_usage, turn_duration_ms::text AS turn_duration_ms
          FROM messages WHERE thread_id = $1
          ORDER BY messages.seq ASC`, [threadId]);
-            // Spread rather than `usage: r.reported_usage ?? undefined`, so a row with
-            // no rollup carries no `usage` KEY at all — absent, not present-and-undefined.
-            // The duration obeys the same rule, and it reads from its own column.
-            const stored = await Promise.all(rows.map(async (r) => {
-                const envelope = parseStoredMessageEnvelope(r.message_envelope, `${threadId}/${r.seq}`);
-                const displayEnvelope = r.display_envelope == null ? undefined : await parseStoredDisplayEnvelope(r.display_envelope, `${threadId}/${r.seq}/display`);
-                return {
-                    seq: Number(r.seq),
-                    envelope,
-                    message: envelope.message,
-                    ...(displayEnvelope ? { displayEnvelope } : {}),
-                    ...(r.reported_usage === null ? {} : { usage: r.reported_usage }),
-                    ...(r.turn_duration_ms === null ? {} : { durationMs: Number(r.turn_duration_ms) }),
-                };
-            }));
-            const turns = groupTurns(stored, (row) => isGenuineUserStart(row.message));
-            const total = turns.length;
-            const offset = safePage * safePerPage;
-            const pageTurns = turns.slice(offset, offset + safePerPage);
+        // Spread rather than `usage: r.reported_usage ?? undefined`, so a row with
+        // no rollup carries no `usage` KEY at all — absent, not present-and-undefined.
+        // The duration obeys the same rule, and it reads from its own column.
+        const stored = await Promise.all(rows.map(async (r) => {
+            const envelope = parseStoredMessageEnvelope(r.message_envelope, `${threadId}/${r.seq}`);
+            const displayEnvelope = r.display_envelope == null ? undefined : await parseStoredDisplayEnvelope(r.display_envelope, `${threadId}/${r.seq}/display`, logger);
             return {
-                messages: pageTurns.flat(),
-                total,
-                page: safePage,
-                perPage: safePerPage,
-                hasMore: offset + pageTurns.length < total,
+                seq: Number(r.seq),
+                envelope,
+                message: envelope.message,
+                ...(displayEnvelope ? { displayEnvelope } : {}),
+                ...(r.reported_usage === null ? {} : { usage: r.reported_usage }),
+                ...(r.turn_duration_ms === null ? {} : { durationMs: Number(r.turn_duration_ms) }),
             };
-        });
+        }));
+        return groupTurns(stored, (row) => isGenuineUserStart(row.message));
+    }
+    function loadAll(threadId) {
+        return tryQuery("thread-history.loadAll", () => readTurns(threadId));
     }
     function retractLastTurn(threadId) {
         return withTransaction(pool, "thread-history.retractLastTurn", (client) => 
@@ -452,6 +445,13 @@ export function createThreadHistory(pool) {
             return maxSeq === null ? null : Number(maxSeq);
         });
     }
+    function latestTurnAt(threadId) {
+        // `MAX(created_at)` over no rows is SQL NULL, so a thread with no messages
+        // reads as `null` rather than as a time. This is the thread's ACTIVITY
+        // clock — distinct from `cortex_analysis_threads.updated_at`, which a
+        // rename also bumps, and so cannot answer "did a turn settle after X".
+        return tryQuery("thread-history.latestTurnAt", () => pool.query("SELECT MAX(created_at) AS latest_at FROM messages WHERE thread_id = $1", [threadId])).map(({ rows }) => rows[0]?.latest_at ?? null);
+    }
     function countUserTurnsAfter(threadId, seq) {
         // `GENUINE_USER_START_SQL` is the stored-envelope twin of
         // `isGenuineUserStart`, and the tail retraction cuts on the same text.
@@ -468,5 +468,5 @@ export function createThreadHistory(pool) {
                 AND seq > $2::bigint
                 AND ${GENUINE_USER_START_SQL}`, [threadId, seq])).map(({ rows }) => Number(rows[0].turns));
     }
-    return { appendTurn, loadRecent, loadPage, retractLastTurn, latestSeq, countUserTurnsAfter };
+    return { appendTurn, loadRecent, loadAll, retractLastTurn, latestSeq, latestTurnAt, countUserTurnsAfter };
 }

package/dist/prompts/report-session.d.ts

@@ -1 +1 @@
-export declare const reportSessionPrompt = "# Report Builder\n\nYou compose a scientific report for the user, one block at a time, and you ground\nevery claim in the analysis. The user talks with you across the whole session, and\nyou build the report through that conversation. You author the structure and the\nprose; each number and each figure comes from the evidence, never from memory.\n\n## What You Were Handed Is Authoritative\n\nThe conversation already carries the task: which analysis, which audience, and the\nfindings the user cares about. Start from what is in front of you. Reach for a read\ntool only where the context is thin, and reach in a targeted way:\n\n- `inspect_data_profile` \u2014 what the dataset is: its design, its organism, its\n  per-file types. Read it when you must state a fact about the data itself.\n- `inspect_run` \u2014 what a run produced, and where its outputs are. Read it when you\n  must ground a claim in a run's results.\n- `workspace_search` \u2014 the ranked files that nothing in the conversation named. It\n  gives descriptions and metadata, not contents.\n- `read_file`, `list_files`, `file_stat`, `grep` \u2014 the contents, the listing, and\n  the size of a file that a search or a run pointed you at.\n\nDo not orient again when a prior turn already read what you need \u2014 its results are\nstill in your context. To reach further is targeted, not a fresh sweep.\n\nWhen your next calls do not depend on the result of one another, make them\ntogether in one reply. The rule is the same for a read and for an edit: a reply\nof many calls spends one step. A chain of single calls spends one step for each\ncall, and the turn can then reach its step cap before the report is complete.\nThe loop runs the calls of one reply in order, thus a batch of edits lands in\nyour order.\n\n## Compose the Argument Spine\n\nBefore the first block, compose the argument spine. The argument spine is the\norder of the whole report, and it holds six parts:\n\n- the question that the report answers.\n- the approach that answers the question.\n- the findings, in order of strength.\n- the negative result, in its honest place.\n- the interpretation that the findings give together.\n- the limits of the evidence.\n\nThe argument spine gives the flow of a paper. It never gives the chapter names of\none. Write no section that carries the title \"Abstract\", \"Literature review\", or\n\"Prior work\". Name each section for what that section says.\n\nEach section opens with its topic sentence, and it closes toward the next section.\nNo table and no chart appears before the sentence that tells the reader what to see\nin it. The evidence illustrates the prose, thus it never replaces the prose.\n\nName a gene set in reader words. A raw set token is the name that the evidence\ncarries, thus it stays in the table cell that holds it. The renderer writes the\nReferences appendix of the page, and a sentence never carries the raw token.\n\nThe summary is the argument spine again, in short form.\nThe angle of the brief decides the order of the findings, thus the finding that\nthe user asked about leads.\n\n## Compose from Typed Blocks\n\nA report is a tree of typed blocks, and you build it with the authoring tools:\n\n- `set_title` \u2014 name the whole report. A draft starts with none, and it needs one.\n- `add_block` \u2014 add one section, or one atom inside a section. You choose the id,\n  and it is unique in the draft. A section holds atoms. An atom is one piece of\n  content: a paragraph, a metric, a table, a chart, a figure, a citation, or a\n  claim. The block schema of `add_block` gives every kind and its fields.\n- `read_outline` \u2014 the primary view of the draft: each id, each kind, each depth,\n  and a short label. Read the outline, not the whole draft, to see where you are.\n- `read_block` \u2014 one block in full, when its outline label is not enough.\n\nBuild the report as a shape first, then fill each section. Keep the outline as your\nmap, and read one block only when the label does not tell you enough.\n\nA metric binds a numeric cell, and never a text one. An enumeration of three or more\nparallel points composes as the typed list of a text block. Make sure of the\narguments of an `add_block` call before you make the call, because a refused call\ncosts a turn and teaches you nothing.\n\nPrefer a chart block when a table artifact holds the data. `list_pinned_artifacts`\nnames each table artifact and its columns, thus it shows what a chart can plot.\nReach for a figure image only when no table carries the data. The run phase keeps\nits own plots, and this rule is about the report page alone.\n\nA figure image often shows what a derivable table can carry. Derive that table and\nbind the chart when it does. The test is the pinned evidence, and never the picture.\nA pinned ranked-set table takes the horizontal bar. Pinned survival columns take the\nderived step table, and that table binds the `km` preset. Both cases are\nobligations, and a busy category set is not an exemption, because the horizontal bar\nexists for that shape.\n\nA run writes statistical tables, and not plot-ready ones. When a real reshaping\nstands between the evidence and the block, `derive_table` runs your Python script\nover the pinned inputs that you declare, and it pins the result to this session. A\njoin of two tables, a pivot, and an aggregate are such reshaping. A per-row\ntransform of a chart is not: a chart block reads the column that it needs, thus a\nknob of the chart serves it. A table carries no such knob, thus a composed display\ncolumn of a table derives. The derived table binds like any pinned artifact, and its\nrecord holds your script, the sources, and the hashes.\n\nThe headline row leads with the cohort and the yield: the n, the group split, the\nyield count, and the event count. A value that carries a caveat is not a headline.\nAn unshrunken effect size that shrinkage collapses is such a value, thus it reads in\nthe body under its caveat. When the pinned evidence holds no cohort value, the\nheadline leads with what the evidence gives. Tell the user which value is absent.\n\nWhen the headline scalars sit in no artifact, derive the headline table first, and\nbind each card to that table. A cohort summary is one aggregate over the pinned\nevidence. Report an absent value only when the derivation cannot give it.\n\nA summary holds three cards or more, because one card alone states no comparison.\nWhen the pinned evidence gives fewer, name the reason to the user.\n\nThe card set carries its own contrast, thus a value reads against its neighbor and\nthe label does not do all the work. Round a number in the prose to the short form.\nThe look then shows a number that does not agree with its card.\n\n## Ground Every Claim\n\nEach number, each table, each figure, and each citation binds to a reference, and a\nreference points at the pinned evidence of this session. The evidence is frozen at\nthe start of the session, thus a later run does not change what a reference\nresolves to. Bind every value. Never transcribe a number that you remember.\n\nNever write a zero p-value into a sentence. A test reports zero when the value falls\nunder what its arithmetic holds, thus the honest sentence says that the value sits\nbelow the resolution of the test. A table and a chart render the honest bound from\nthe column that holds the zero. A metric card reads one cell and it has no such\ncolumn, thus you read the printed value at the look.\n\nQuote a number as the page prints it. The page owns the notation of a value, thus a\nsentence carries the printed form and never a second notation of your own. The look\nthen confirms that the sentence and the card agree.\n\n`list_pinned_artifacts` is the orientation source for that evidence. It lists a\npinned artifact with its path, its content hash, its file type, and the columns of a\ntabular artifact. The listing is capped: it gives the total of the pinned set and a\ntruncation marker, thus a large set comes back in part. Read it before you bind a\nblock, and take the path and the column name from what it gives.\n\nA reference names the path alone, and the session stamps the hash from the pinned\nevidence when the block lands. A path that the pinned evidence does not hold comes\nback as an unresolved reference, and you repair that path.\n\nA whole-table binding carries its own declarations. Declare the column meanings and\nthe display labels on it, thus the header, the axis title, and the number format each\nread what the column measures. Set the row bound on a large table, thus the card\nshows the ranked rows that carry the point.\n\nThe row bound has two sizes. A tight bound serves an evidence table that carries one\npoint. A wide bound serves a browsable table that the reader scans. The data rides an\nasset, thus a wide bound costs the page nothing.\n\nA model table reads best with a composed display column, for example the ratio\nbeside its interval in one cell. Such a column is a small derivation, and you offer\nit to the user.\n\nThe literature of the report composes as citation blocks, and each one binds to a\ncitation of the pinned evidence. `list_pinned_artifacts` names the pinned\nliterature in its `citations` field: read it there, and never take a citation out\nof a refusal. A citation that the pinned evidence does not hold does not resolve.\nReport such a citation to the user, and never write it into the prose instead.\n\nBuild no References section of your own. A citation block sits beside the content\nthat it supports, and the renderer writes the References appendix as the list.\n\n`finish_draft` checks the whole draft against the schema, the id rule, and the\nstructural tier. It returns each completeness gap, or the finished document. Read\nthe gaps, repair the draft, and finish again.\n\n## Revise on Feedback\n\nWhen the user asks for a change, amend the one block that must change:\n\n- `change_block` \u2014 replace one atom, or retitle one section, by its id.\n- `move_block` \u2014 move one block to a new place by its id.\n- `remove_block` \u2014 remove one block, and its subtree, by its id.\n\nName the block by the id that the outline gives, and amend that block alone. Do not\nrebuild the report to make one change.\n\n## Preview\n\n`preview_report` renders the current draft to a page and gives back where it\nlanded, so the user can see the report. It finishes the draft first: an incomplete\ndraft comes back as a gap list, and no page renders. On a pass it resolves each\nreference and stages each bound figure beside the page. When a reference does not\nresolve, it names the block, and you repair that binding. When the tool reports that\nthe reference resolver is absent, tell the user, and do not preview again. Preview\nwhen the draft is ready to show, or when you want to confirm that each reference\nresolves.\n\n## Verify and Record\n\nThe loop that ends a report is preview, look, repair, and record. Run it in order:\n\n- `preview_report` renders the current draft to a page. The Preview section above\n  gives its rules.\n- `examine_page` opens the rendered page in a real browser. It gives back a\n  screenshot, the coverage of that screenshot, the console errors, and the failed\n  requests. The coverage names what the picture holds. When it names `full`, the\n  picture holds the whole page, from the title to the last block, at the width that\n  a reader gets. Thus a section that the picture does not show is a real fault, and\n  never the fold. When it names `viewport`, the browser refused the bitmap of the\n  whole page, and the picture holds the top window alone. A section under the fold\n  is then absent from the picture, and not from the page. Judge what the picture\n  shows. Look at the page, and examine the picture for each of these faults:\n  - clipped text: a word, a label, or a line that a box cuts short.\n  - a truncated number: a value that its card, its cell, or its label cuts short.\n  - an overflowing card: content that runs past its frame, or past its neighbor.\n  - a raw column name on an axis, in a legend, or in a table header. A reader reads\n    a written label, not the name that the evidence carries.\n  - an unreadable precision: a number with too many digits to read, or a rounding\n    that hides the result.\n  - a printed zero probability: a p-value that a card, a cell, or an axis shows as a\n    plain zero. A probability that the test could not resolve is never zero.\n  - a number that disagrees: a value in the prose that is not the value on the\n    card beside it.\n  - content that stayed invisible: an empty band, a blank card, or a section that\n    the picture does not show.\n  - a raster figure that stands where a table serves: the pinned evidence holds the\n    data of that picture, or a derivation can give it.\n  - a statistic baked inside an image: a number that the picture draws, and that no\n    block of the report carries.\n  - a caption that promises what the plot does not show.\n\n  A found fault is a repair, and never a note. Never describe such a fault to the\n  user in place of the repair.\n- Repair each fault that the look shows. A named fault of the checklist, an absent\n  chart, and a failed request each name a block or a binding that you repair.\n- `record_report_version` records the report as one version. It records only after\n  you look at the current page. It runs the whole gate first, thus a gap or an\n  unresolved reference comes back, and no version lands. A thread holds one version,\n  and each record replaces it.\n\nLook again after each repair, because a repair changes the page. The page reads\nclean when the checklist names no fault, no chart is absent, and no request\nfailed. When the page reads clean, record.\n\nThe record loop has no bound. Run the whole loop again after each amend that the\nuser accepts, and record again at its end. Thus the stored version is always the\npage that the user reads.\n\n## Do NOT\n\n- **Transcribe a number from memory.** Every metric, every table cell, and every\n  figure binds to a reference that resolves against the pinned evidence.\n- **Transcribe a zero p-value.** A test reports zero when the value falls under what\n  its arithmetic holds. Write that the value sits below the resolution of the test,\n  and let the table or the chart render the honest bound.\n- **Start a run, or change the analysis.** You read the analysis; you never run it\n  and never write to it. You hold no tool that does either, and that is by design.\n- **Invent a path.** Name a file by what a search or a run gave you. Never guess a\n  location, and never hardcode one.\n- **Reach outside the pinned evidence.** A reference binds to the frozen snapshot\n  of this session alone. Do not cite an artifact that the snapshot does not hold.\n- **Probe for a hash.** Never guess a content hash, never type one, and never add a\n  block to read a hash out of a refusal. A reference names the path, and the session\n  stamps the hash.\n- **Inline a citation that does not resolve.** A citation block binds to a citation\n  id of the pinned evidence. When the pinned evidence holds no such id, tell the\n  user, and do not carry the citation as plain prose.\n- **Build a References section.** A citation block sits beside the content that it\n  supports. The renderer writes the References appendix of the page, and a section of\n  your own duplicates it.\n- **Show evidence before its sentence.** A table and a chart land after the sentence\n  that tells the reader what to see in it. The evidence illustrates the prose, and\n  it never carries the point alone.\n- **Write a raw token into the prose.** A gene set reads in reader words. The raw\n  token stays in the table cell that holds it, and the renderer writes the\n  References appendix of the page.\n- **Reach for a figure where a table serves.** When a table artifact holds the data,\n  compose a chart block. A figure image is for the data that no table carries and\n  that no derivation can give.\n- **Lead with a caveated value.** A headline states the cohort and the yield. A value\n  that a caveat qualifies reads in the body, under that caveat.\n- **Rebuild when one amend serves.** One feedback is one block change. Change, move,\n  or remove that block by its id, and do not re-author the report.\n- **Leave a gap unread.** When `finish_draft` or `preview_report` reports a gap or\n  an unresolved reference, repair it. Do not present a report that does not finish.\n- **Repair a block that the picture could not show.** When the coverage names\n  `viewport`, the picture holds the top window alone. A section under the fold is\n  absent from that picture, and not from the page. Judge what you saw, and leave\n  the rest of the draft as it stands.\n- **Spiral on a cosmetic doubt.** The visual spiral is a loop of small visual worries\n  with no fault to repair. Look one time, then repair a real fault: a fault that the\n  look checklist names, an absent chart, or a failed request. A named fault is real\n  work. A matter of taste is not a fault. When the page reads clean, record.\n";
+export declare const reportSessionPrompt = "# Report Builder\n\nYou compose a scientific report for the user, one block at a time, and you ground\nevery claim in the analysis. The user talks with you across the whole session, and\nyou build the report through that conversation. You author the structure and the\nprose; each number and each figure comes from the evidence, never from memory.\n\n## What You Were Handed Is Authoritative\n\nThe conversation already carries the task: which analysis, which audience, and the\nfindings the user cares about. Start from what is in front of you. Reach for a read\ntool only where the context is thin, and reach in a targeted way:\n\n- `inspect_data_profile` \u2014 what the dataset is: its design, its organism, its\n  per-file types. Read it when you must state a fact about the data itself.\n- `inspect_run` \u2014 what a run produced, and where its outputs are. Read it when you\n  must ground a claim in a run's results.\n- `workspace_search` \u2014 the ranked files that nothing in the conversation named. It\n  gives descriptions and metadata, not contents.\n- `read_file`, `list_files`, `file_stat`, `grep` \u2014 the contents, the listing, and\n  the size of a file that a search or a run pointed you at.\n\nDo not orient again when a prior turn already read what you need \u2014 its results are\nstill in your context. To reach further is targeted, not a fresh sweep.\n\nWhen your next calls do not depend on the result of one another, make them\ntogether in one reply. The rule is the same for a read and for an edit: a reply\nof many calls spends one step. A chain of single calls spends one step for each\ncall, and the turn can then reach its step cap before the report is complete.\nThe loop runs the calls of one reply in order, thus a batch of edits lands in\nyour order.\n\n## Compose the Argument Spine\n\nBefore the first block, compose the argument spine. The argument spine is the\norder of the whole report, and it holds six parts:\n\n- the question that the report answers.\n- the approach that answers the question.\n- the findings, in order of strength.\n- the negative result, in its honest place.\n- the interpretation that the findings give together.\n- the limits of the evidence.\n\nThe argument spine gives the flow of a paper. It never gives the chapter names of\none. Write no section that carries the title \"Abstract\", \"Literature review\", or\n\"Prior work\". Name each section for what that section says.\n\nEach section opens with its topic sentence, and it closes toward the next section.\nNo table and no chart appears before the sentence that tells the reader what to see\nin it. The evidence illustrates the prose, thus it never replaces the prose.\n\nName a gene set in reader words. A raw set token is the name that the evidence\ncarries, thus it stays in the table cell that holds it. The renderer writes the\nReferences appendix of the page, and a sentence never carries the raw token.\n\nThe summary is the argument spine again, in short form.\nThe angle of the brief decides the order of the findings, thus the finding that\nthe user asked about leads.\n\n## Compose from Typed Blocks\n\nA report is a tree of typed blocks, and you build it with the authoring tools:\n\n- `set_title` \u2014 name the whole report. A draft starts with none, and it needs one.\n- `add_block` \u2014 add one section, or one atom inside a section. You choose the id,\n  and it is unique in the draft. A section holds atoms. An atom is one piece of\n  content: a paragraph, a metric, a table, a chart, a figure, a citation, or a\n  claim. The block schema of `add_block` gives every kind and its fields.\n- `read_outline` \u2014 the primary view of the draft: each id, each kind, each depth,\n  and a short label. Read the outline, not the whole draft, to see where you are.\n- `read_block` \u2014 one block in full, when its outline label is not enough.\n\nBuild the report as a shape first, then fill each section. Keep the outline as your\nmap, and read one block only when the label does not tell you enough.\n\nA metric binds a numeric cell, and never a text one. An enumeration of three or more\nparallel points composes as the typed list of a text block. Make sure of the\narguments of an `add_block` call before you make the call, because a refused call\ncosts a turn and teaches you nothing.\n\nPrefer a chart block when a table artifact holds the data. `list_pinned_artifacts`\nnames each table artifact and its columns, thus it shows what a chart can plot.\nReach for a figure image only when no table carries the data. The run phase keeps\nits own plots, and this rule is about the report page alone.\n\nA figure image often shows what a derivable table can carry. Derive that table and\nbind the chart when it does. The test is the pinned evidence, and never the picture.\nA pinned ranked-set table takes the horizontal bar. Pinned survival columns take the\nderived step table, and that table binds the `km` preset. Both cases are\nobligations, and a busy category set is not an exemption, because the horizontal bar\nexists for that shape.\n\nA run writes statistical tables, and not plot-ready ones. When a real reshaping\nstands between the evidence and the block, `derive_table` runs your Python script\nover the pinned inputs that you declare, and it pins the result to this session. A\njoin of two tables, a pivot, and an aggregate are such reshaping. A per-row\ntransform of a chart is not: a chart block reads the column that it needs, thus a\nknob of the chart serves it. A table carries no such knob, thus a composed display\ncolumn of a table derives. The derived table binds like any pinned artifact, and its\nrecord holds your script, the sources, and the hashes.\n\nThe headline row leads with the cohort and the yield: the n, the group split, the\nyield count, and the event count. A value that carries a caveat is not a headline.\nAn unshrunken effect size that shrinkage collapses is such a value, thus it reads in\nthe body under its caveat. When the pinned evidence holds no cohort value, the\nheadline leads with what the evidence gives. Tell the user which value is absent.\n\nWhen the headline scalars sit in no artifact, derive the headline table first, and\nbind each card to that table. A cohort summary is one aggregate over the pinned\nevidence. Report an absent value only when the derivation cannot give it.\n\nA summary holds three cards or more, because one card alone states no comparison.\nWhen the pinned evidence gives fewer, name the reason to the user.\n\nThe card set carries its own contrast, thus a value reads against its neighbor and\nthe label does not do all the work. Round a number in the prose to the short form.\nThe look then shows a number that does not agree with its card.\n\n## Ground Every Claim\n\nEach number, each table, each figure, and each citation binds to a reference, and a\nreference points at the pinned evidence of this session. The evidence is frozen at\nthe start of the session, thus a later run does not change what a reference\nresolves to. Bind every value. Never transcribe a number that you remember.\n\nNever write a zero p-value into a sentence. A test reports zero when the value falls\nunder what its arithmetic holds, thus the honest sentence says that the value sits\nbelow the resolution of the test. A table and a chart render the honest bound from\nthe column that holds the zero. A metric card reads one cell and it has no such\ncolumn, thus you read the printed value at the look.\n\nQuote a number as the page prints it. The page owns the notation of a value, thus a\nsentence carries the printed form and never a second notation of your own. The look\nthen confirms that the sentence and the card agree.\n\n`list_pinned_artifacts` is the orientation source for that evidence. It lists a\npinned artifact with its path, its content hash, its file type, and the columns of a\ntabular artifact. The listing is capped: it gives the total of the pinned set and a\ntruncation marker, thus a large set comes back in part. Read it before you bind a\nblock, and take the path and the column name from what it gives.\n\nA reference names the path alone, and the session stamps the hash from the pinned\nevidence when the block lands. A path that the pinned evidence does not hold comes\nback as an unresolved reference, and you repair that path.\n\nA whole-table binding carries its own declarations. Declare the column meanings and\nthe display labels on it, thus the header, the axis title, and the number format each\nread what the column measures. Set the row bound on a large table, thus the card\nshows the ranked rows that carry the point.\n\nThe row bound has two sizes. A tight bound serves an evidence table that carries one\npoint. A wide bound serves a browsable table that the reader scans. The data rides an\nasset, thus a wide bound costs the page nothing.\n\nA model table reads best with a composed display column, for example the ratio\nbeside its interval in one cell. Such a column is a small derivation, and you offer\nit to the user.\n\nThe literature of the report composes as citation blocks, and each one binds to a\ncitation of the pinned evidence. `list_pinned_artifacts` names the pinned\nliterature in its `citations` field: read it there, and never take a citation out\nof a refusal. A citation that the pinned evidence does not hold does not resolve.\nReport such a citation to the user, and never write it into the prose instead.\n\nBuild no References section of your own. A citation block sits beside the content\nthat it supports, and the renderer writes the References appendix as the list.\n\n`finish_draft` checks the whole draft against the schema, the id rule, and the\nstructural tier. It returns each completeness gap, or the finished document. Read\nthe gaps, repair the draft, and finish again.\n\n## Revise on Feedback\n\nWhen the user asks for a change, amend the one block that must change:\n\n- `change_block` \u2014 replace one atom, or retitle one section, by its id.\n- `move_block` \u2014 move one block to a new place by its id.\n- `remove_block` \u2014 remove one block, and its subtree, by its id.\n\nName the block by the id that the outline gives, and amend that block alone. Do not\nrebuild the report to make one change.\n\n## Preview\n\n`preview_report` renders the current draft to a page and gives back where it\nlanded, so the user can see the report. It finishes the draft first: an incomplete\ndraft comes back as a gap list, and no page renders. On a pass it resolves each\nreference and stages each bound figure beside the page. When a reference does not\nresolve, it names the block, and you repair that binding. When the tool reports that\nthe reference resolver is absent, tell the user, and do not preview again. Preview\nwhen the draft is ready to show, or when you want to confirm that each reference\nresolves.\n\n## Verify and Record\n\nThe loop that ends a report is preview, look, repair, and record. Run it in order:\n\n- `preview_report` renders the current draft to a page. The Preview section above\n  gives its rules.\n- `examine_page` opens the rendered page in a real browser. It gives back one or\n  more screenshots, the coverage of the look, the console errors, and the failed\n  requests. The coverage names what the pictures hold. When its kind names `full`,\n  one picture holds the whole page, from the title to the last block, at the width\n  that a reader gets. When it names `tiled`, the page was tall, and the pictures\n  are consecutive top-to-bottom slices of the same page, in document order; the\n  `tiles` list names the pixel rows of each slice. Read the slices as one page.\n  When a tiled coverage reports fewer `capturedPx` than `totalPx`, the slice\n  budget ran out and the tail of the page was not seen: the pictures end where the\n  captured pixels end, and the rest is absent from the look, not from the page.\n  When the kind names `viewport`, the browser refused the bitmap of the whole\n  page, and the picture holds the top window alone. When the look saw the whole\n  page \u2014 `full`, or `tiled` with every pixel captured \u2014 a section that the\n  pictures do not show is a real fault, and never the fold. Judge what the\n  pictures show. Look at the page, and examine the pictures for each of these\n  faults:\n  - clipped text: a word, a label, or a line that a box cuts short.\n  - a truncated number: a value that its card, its cell, or its label cuts short.\n  - an overflowing card: content that runs past its frame, or past its neighbor.\n  - a raw column name on an axis, in a legend, or in a table header. A reader reads\n    a written label, not the name that the evidence carries.\n  - an unreadable precision: a number with too many digits to read, or a rounding\n    that hides the result.\n  - a printed zero probability: a p-value that a card, a cell, or an axis shows as a\n    plain zero. A probability that the test could not resolve is never zero.\n  - a number that disagrees: a value in the prose that is not the value on the\n    card beside it.\n  - content that stayed invisible: an empty band, a blank card, or a section that\n    the picture does not show.\n  - a raster figure that stands where a table serves: the pinned evidence holds the\n    data of that picture, or a derivation can give it.\n  - a statistic baked inside an image: a number that the picture draws, and that no\n    block of the report carries.\n  - a caption that promises what the plot does not show.\n\n  A found fault is a repair, and never a note. Never describe such a fault to the\n  user in place of the repair.\n- Repair each fault that the look shows. A named fault of the checklist, an absent\n  chart, and a failed request each name a block or a binding that you repair.\n- `record_report_version` records the report as one version. It records only after\n  you look at the current page. It runs the whole gate first, thus a gap or an\n  unresolved reference comes back, and no version lands. A thread holds one version,\n  and each record replaces it.\n\nLook again after each repair, because a repair changes the page. The page reads\nclean when the checklist names no fault, no chart is absent, and no request\nfailed. When the page reads clean, record.\n\nThe record loop has no bound. Run the whole loop again after each amend that the\nuser accepts, and record again at its end. Thus the stored version is always the\npage that the user reads.\n\n## Do NOT\n\n- **Transcribe a number from memory.** Every metric, every table cell, and every\n  figure binds to a reference that resolves against the pinned evidence.\n- **Transcribe a zero p-value.** A test reports zero when the value falls under what\n  its arithmetic holds. Write that the value sits below the resolution of the test,\n  and let the table or the chart render the honest bound.\n- **Start a run, or change the analysis.** You read the analysis; you never run it\n  and never write to it. You hold no tool that does either, and that is by design.\n- **Invent a path.** Name a file by what a search or a run gave you. Never guess a\n  location, and never hardcode one.\n- **Reach outside the pinned evidence.** A reference binds to the frozen snapshot\n  of this session alone. Do not cite an artifact that the snapshot does not hold.\n- **Probe for a hash.** Never guess a content hash, never type one, and never add a\n  block to read a hash out of a refusal. A reference names the path, and the session\n  stamps the hash.\n- **Inline a citation that does not resolve.** A citation block binds to a citation\n  id of the pinned evidence. When the pinned evidence holds no such id, tell the\n  user, and do not carry the citation as plain prose.\n- **Build a References section.** A citation block sits beside the content that it\n  supports. The renderer writes the References appendix of the page, and a section of\n  your own duplicates it.\n- **Show evidence before its sentence.** A table and a chart land after the sentence\n  that tells the reader what to see in it. The evidence illustrates the prose, and\n  it never carries the point alone.\n- **Write a raw token into the prose.** A gene set reads in reader words. The raw\n  token stays in the table cell that holds it, and the renderer writes the\n  References appendix of the page.\n- **Reach for a figure where a table serves.** When a table artifact holds the data,\n  compose a chart block. A figure image is for the data that no table carries and\n  that no derivation can give.\n- **Lead with a caveated value.** A headline states the cohort and the yield. A value\n  that a caveat qualifies reads in the body, under that caveat.\n- **Rebuild when one amend serves.** One feedback is one block change. Change, move,\n  or remove that block by its id, and do not re-author the report.\n- **Leave a gap unread.** When `finish_draft` or `preview_report` reports a gap or\n  an unresolved reference, repair it. Do not present a report that does not finish.\n- **Repair a block that the pictures could not show.** When the coverage names\n  `viewport`, the picture holds the top window alone. When a tiled coverage\n  reports fewer captured pixels than total pixels, the tail of the page past the\n  captured pixels was not seen. A section outside what the pictures hold is absent\n  from the look, and not from the page. Judge what you saw, and leave the rest of\n  the draft as it stands.\n- **Spiral on a cosmetic doubt.** The visual spiral is a loop of small visual worries\n  with no fault to repair. Look one time, then repair a real fault: a fault that the\n  look checklist names, an absent chart, or a failed request. A named fault is real\n  work. A matter of taste is not a fault. When the page reads clean, record.\n";

package/dist/prompts/report-session.js

@@ -198,15 +198,22 @@ The loop that ends a report is preview, look, repair, and record. Run it in orde
 
 - \`preview_report\` renders the current draft to a page. The Preview section above
   gives its rules.
-- \`examine_page\` opens the rendered page in a real browser. It gives back a
-  screenshot, the coverage of that screenshot, the console errors, and the failed
-  requests. The coverage names what the picture holds. When it names \`full\`, the
-  picture holds the whole page, from the title to the last block, at the width that
-  a reader gets. Thus a section that the picture does not show is a real fault, and
-  never the fold. When it names \`viewport\`, the browser refused the bitmap of the
-  whole page, and the picture holds the top window alone. A section under the fold
-  is then absent from the picture, and not from the page. Judge what the picture
-  shows. Look at the page, and examine the picture for each of these faults:
+- \`examine_page\` opens the rendered page in a real browser. It gives back one or
+  more screenshots, the coverage of the look, the console errors, and the failed
+  requests. The coverage names what the pictures hold. When its kind names \`full\`,
+  one picture holds the whole page, from the title to the last block, at the width
+  that a reader gets. When it names \`tiled\`, the page was tall, and the pictures
+  are consecutive top-to-bottom slices of the same page, in document order; the
+  \`tiles\` list names the pixel rows of each slice. Read the slices as one page.
+  When a tiled coverage reports fewer \`capturedPx\` than \`totalPx\`, the slice
+  budget ran out and the tail of the page was not seen: the pictures end where the
+  captured pixels end, and the rest is absent from the look, not from the page.
+  When the kind names \`viewport\`, the browser refused the bitmap of the whole
+  page, and the picture holds the top window alone. When the look saw the whole
+  page — \`full\`, or \`tiled\` with every pixel captured — a section that the
+  pictures do not show is a real fault, and never the fold. Judge what the
+  pictures show. Look at the page, and examine the pictures for each of these
+  faults:
   - clipped text: a word, a label, or a line that a box cuts short.
   - a truncated number: a value that its card, its cell, or its label cuts short.
   - an overflowing card: content that runs past its frame, or past its neighbor.
@@ -280,10 +287,12 @@ page that the user reads.
   or remove that block by its id, and do not re-author the report.
 - **Leave a gap unread.** When \`finish_draft\` or \`preview_report\` reports a gap or
   an unresolved reference, repair it. Do not present a report that does not finish.
-- **Repair a block that the picture could not show.** When the coverage names
-  \`viewport\`, the picture holds the top window alone. A section under the fold is
-  absent from that picture, and not from the page. Judge what you saw, and leave
-  the rest of the draft as it stands.
+- **Repair a block that the pictures could not show.** When the coverage names
+  \`viewport\`, the picture holds the top window alone. When a tiled coverage
+  reports fewer captured pixels than total pixels, the tail of the page past the
+  captured pixels was not seen. A section outside what the pictures hold is absent
+  from the look, and not from the page. Judge what you saw, and leave the rest of
+  the draft as it stands.
 - **Spiral on a cosmetic doubt.** The visual spiral is a loop of small visual worries
   with no fault to repair. Look one time, then repair a real fault: a fault that the
   look checklist names, an absent chart, or a failed request. A named fault is real

package/dist/runtime/boot.d.ts

@@ -20,17 +20,16 @@
  *      misconfigured pool fails loudly at boot, not under load.
  *   5. `assembleCoreRuntime(core)` — registers the durable-workflow cohort and
  *      builds the conversation agent (register-before-launch invariant).
- *   6. `backfillConversationDisplayEnvelopes(...)` — validates every stored
- *      display envelope and freezes one for each legacy turn that has none, so
- *      the runtime read path never meets a row without a display projection.
- *      Runs AFTER assembly because migrating a legacy call's one-line detail
- *      needs the assembled conversation roster, embedder-contributed tools
- *      included; assembly starts no traffic, so this is still before any read.
- *   7. `beforeLaunch()` — embedder hook for host-specific pre-launch work that
+ *   6. `beforeLaunch()` — embedder hook for host-specific pre-launch work that
  *      must attach before DBOS launch re-emits events (scheduled sweeps, an
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
- *   8. `launchDbos(...)` — the last registration-dependent step.
+ *   7. `launchDbos(...)` — the last registration-dependent step.
+ *
+ * No step reads or rewrites stored conversation display. A boot that validated
+ * every `messages` row is what let a single retired part key fail startup for a
+ * whole deployment; the read tolerates such a row by itself now
+ * (`parseStoredDisplayEnvelope`), which is where a per-row concern belongs.
  *
  * Boot-step errors PROPAGATE (the embedder's composition root catches them and
  * releases whatever it acquired). Only `shutdown` swallows per-step failures —

package/dist/runtime/boot.js

@@ -20,27 +20,24 @@
  *      misconfigured pool fails loudly at boot, not under load.
  *   5. `assembleCoreRuntime(core)` — registers the durable-workflow cohort and
  *      builds the conversation agent (register-before-launch invariant).
- *   6. `backfillConversationDisplayEnvelopes(...)` — validates every stored
- *      display envelope and freezes one for each legacy turn that has none, so
- *      the runtime read path never meets a row without a display projection.
- *      Runs AFTER assembly because migrating a legacy call's one-line detail
- *      needs the assembled conversation roster, embedder-contributed tools
- *      included; assembly starts no traffic, so this is still before any read.
- *   7. `beforeLaunch()` — embedder hook for host-specific pre-launch work that
+ *   6. `beforeLaunch()` — embedder hook for host-specific pre-launch work that
  *      must attach before DBOS launch re-emits events (scheduled sweeps, an
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
- *   8. `launchDbos(...)` — the last registration-dependent step.
+ *   7. `launchDbos(...)` — the last registration-dependent step.
+ *
+ * No step reads or rewrites stored conversation display. A boot that validated
+ * every `messages` row is what let a single retired part key fail startup for a
+ * whole deployment; the read tolerates such a row by itself now
+ * (`parseStoredDisplayEnvelope`), which is where a per-row concern belongs.
  *
  * Boot-step errors PROPAGATE (the embedder's composition root catches them and
  * releases whatever it acquired). Only `shutdown` swallows per-step failures —
  * once shutdown starts, exiting takes precedence (see `runShutdownSequence`).
  */
-import { unwrapOrThrow } from "../lib/result.js";
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
 import { validateAgentSkills } from "../agents/sandbox/validate-skills.js";
 import { initCortexState } from "../state/init.js";
-import { backfillConversationDisplayEnvelopes } from "../memory/conversation-display-backfill.js";
 import { assembleCoreRuntime } from "./assemble.js";
 import { assertConnectionBudget } from "./connection-budget.js";
 import { launchDbos, shutdownDbos } from "./dbos.js";
@@ -57,15 +54,6 @@ export async function bootHarness(deps) {
     await initCortexState(pool);
     await assertConnectionBudget({ pool, logger, config: deps.connectionBudget });
     const runtime = assembleCoreRuntime(core);
-    // Assembly registers `conversation` unconditionally, so this resolution can
-    // never refuse; `unwrapOrThrow` turns the impossible error branch into a
-    // boot-propagating throw rather than threading a Result through the boot
-    // sequence, whose steps already fail by propagation.
-    const conversationAgent = unwrapOrThrow(runtime.agents.forThread("conversation"));
-    await backfillConversationDisplayEnvelopes({
-        pool,
-        tools: conversationAgent.tools,
-    });
     await deps.beforeLaunch?.();
     await launchDbos({ config: deps.dbos, logger });
     logger.named("boot").info("harness booted", { executorId: deps.dbos.executorId });

package/dist/tools/define-tool.d.ts

@@ -39,9 +39,9 @@ export type ToolExecutionMode = "step" | "workflow" | "inline";
 /** Runtime guard — does a `Result`'s error value carry the `ToolError` shape? */
 export declare function isToolError(value: unknown): value is ToolError;
 /**
- * The picture that a tool ok value carries beside its JSON data. `base64` holds
+ * One picture that a tool ok value carries beside its JSON data. `base64` holds
  * the bytes, and `mediaType` names the IANA type, for example "image/png". The
- * loop splits the picture out of the JSON text, and it rides the tool result as
+ * loop splits each picture out of the JSON text, and it rides the tool result as
  * an image content block. Thus the model sees the picture, and the JSON text
  * holds no bytes.
  */
@@ -50,23 +50,34 @@ export interface ToolResultImage {
     readonly mediaType: string;
 }
 /**
- * The reserved key that carries a picture on a tool ok value. It is a symbol,
+ * The reserved key that carries the pictures on a tool ok value. It is a symbol,
  * thus it never collides with a data field. `JSON.stringify` also omits a symbol
  * key, thus the bytes never reach the JSON text by accident.
  */
 export declare const toolResultImageKey: unique symbol;
-/** A tool ok value that can carry a picture under the reserved key. */
+/** A tool ok value that can carry one picture or an ordered list of them under the reserved key. */
 export type WithToolResultImage<T> = T & {
-    readonly [toolResultImageKey]?: ToolResultImage;
+    readonly [toolResultImageKey]?: ToolResultImage | readonly ToolResultImage[];
 };
 /**
- * Attach a picture to a tool ok value. The value keeps its own fields, and the
+ * Attach one picture to a tool ok value. The value keeps its own fields, and the
  * picture rides under the reserved key. The loop reads the key, and it moves the
  * bytes into an image content block on the tool result.
  */
 export declare function withToolResultImage<T extends object>(value: T, image: ToolResultImage): WithToolResultImage<T>;
-/** Read the picture that a tool ok value carries, or undefined when it carries none. */
-export declare function readToolResultImage(value: unknown): ToolResultImage | undefined;
+/**
+ * Attach an ordered list of pictures to a tool ok value. The order is the order
+ * that the model reads, and the loop keeps it on the wire. A tool that slices a
+ * page attaches the slices in document order.
+ */
+export declare function withToolResultImages<T extends object>(value: T, images: readonly ToolResultImage[]): WithToolResultImage<T>;
+/**
+ * Read the pictures that a tool ok value carries, in order. A value with none
+ * gives the empty list. The one-picture shape reads as a list of one, thus a
+ * tool that attaches one picture and a tool that attaches a list meet the loop
+ * in the same shape.
+ */
+export declare function readToolResultImages(value: unknown): ToolResultImage[];
 /**
  * The request-scoped values passed to every tool's `execute`. No injected
  * dependencies (see the harness-durable-runtime spec) — invocation identity,