@inflexa-ai/harness 0.25.0 → 0.26.0

package/dist/index.d.ts

@@ -77,7 +77,7 @@ export type { PrepareChatTurnDeps, PrepareChatTurnParams, PrepareChatTurnResult
 export { createThreadStore } from "./memory/thread-store.js";
 export type { ThreadStore, Thread, ThreadType, ThreadInputError, CreateThreadInput, ListThreadsInput, ThreadPage } from "./memory/thread-store.js";
 export { createThreadHistory, conversationRecordTurn } from "./memory/thread-history.js";
-export type { ThreadHistory, StoredMessage, MessagePage, RetractOutcome, ConversationTurn } from "./memory/thread-history.js";
+export type { ThreadHistory, StoredMessage, RetractOutcome, ConversationTurn } from "./memory/thread-history.js";
 export { syntheticUserMessage, syntheticRecordMessage, isSyntheticUserMessage, isSyntheticRecordMessage } from "./memory/ai-sdk-message-storage.js";
 export { createConversationDisplayRecorder } from "./memory/conversation-display-recorder.js";
 export type { ConversationDisplayRecorder, ConversationDisplayRecorderOptions } from "./memory/conversation-display-recorder.js";

package/dist/index.js

@@ -141,9 +141,11 @@ export { createConversationDisplayRecorder } from "./memory/conversation-display
 export { envelopeDisplayMessages, parseStoredDisplayEnvelope } from "./memory/conversation-display-storage.js";
 // The transcript read. Every append persists what it displayed, so replay concatenates stored
 // projections and consults nothing else — no tool names, no card builders, no workspace or database
-// lookups. The migration renderer that DOES consult those (`content-to-cortex.js`,
-// `reconstruct-cards.js`, `tools/detail-resolver.js`) is deliberately absent from this barrel: it
-// runs once per legacy row at startup and has no runtime caller.
+// lookups. A row written before the projection existed carries none and is skipped; there is no
+// reconstruction to fall back to, the migration renderer that once supplied one having been deleted
+// along with the startup backfill that was its only caller. `parseStoredDisplayEnvelope` absorbs the
+// one thing a read can now meet and not understand — a part whose key this vocabulary has retired —
+// by dropping that part, so one stale row cannot fail a whole thread.
 export { storedMessagesToCortex } from "./memory/conversation-display-replay.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
 // Embedder runtime surface — what a same-process host needs to run durable

package/dist/lib/page-capture.d.ts

@@ -2,8 +2,15 @@
  * The one page capture over the Chrome sidecar.
  *
  * A capture navigates to a page URL, collects the console errors and the failed requests, waits for the
- * readiness signal of the page, and gives back a base64 screenshot. Two tools capture a report page: the
- * preview snapshot of the old report path and the eyes tool of a report session. Both read this module.
+ * readiness signal of the page, and gives back base64 screenshots. The eyes tool of a report session reads
+ * this module.
+ *
+ * A short page captures as one full-page shot. A tall page captures as consecutive vertical slices, because
+ * one tall picture dies twice on the provider path: a picture past the hard dimension cap rejects the whole
+ * request, and a legal tall picture downscales to about 1568 pixels on the long side, which compresses the
+ * text past legibility. A slice of about two window heights survives both. The slice budget bounds what one
+ * look costs, and a page past the budget truncates with the captured and the total pixels on the coverage,
+ * thus the truncation is never silent.
  *
  * The readiness contract is the reason for one shared body. The renderer emits the event name and the
  * sentinel name, and `report-render/page.ts` owns both constants together with the two budgets. This module
@@ -23,20 +30,41 @@ export interface FailedRequest {
     url: string;
     reason: string;
 }
-/** The picture and the faults of one page capture. */
+/** One picture of a capture: the base64 bytes, and the document rows that a slice holds. */
+export interface CapturedShot {
+    readonly base64: string;
+    /** The vertical document range of a slice, in CSS pixels. Absent on a whole-document or window picture. */
+    readonly range?: {
+        readonly fromY: number;
+        readonly toY: number;
+    };
+}
+/**
+ * What the pictures hold together. `full` is one shot of the whole document. `tiled` is consecutive vertical
+ * slices in document order; `capturedPx` is the height the slices cover and `totalPx` is the document height,
+ * thus `capturedPx < totalPx` says that the slice budget ran out and the tail of the page is absent. `viewport`
+ * appears when a screenshot threw and the retry at the window passed, thus the one picture shows the top
+ * window alone and a section below the fold is absent from it.
+ */
+export type CaptureCoverage = {
+    readonly kind: "full";
+} | {
+    readonly kind: "tiled";
+    readonly capturedPx: number;
+    readonly totalPx: number;
+} | {
+    readonly kind: "viewport";
+};
+/** The pictures and the faults of one page capture. */
 export interface PageCapture {
-    screenshotBase64: string;
-    /**
-     * What the picture holds. `full` is the whole document, and it is the shape of a capture that passed at
-     * the first attempt. `viewport` appears when the full-page screenshot threw and the retry at the window
-     * passed, thus the picture shows the top window alone and a section below the fold is absent from it.
-     */
-    coverage: "full" | "viewport";
+    /** The pictures in document order: one shot under `full` and `viewport`, the slices under `tiled`. */
+    screenshots: CapturedShot[];
+    coverage: CaptureCoverage;
     consoleErrors: string[];
     failedRequests: FailedRequest[];
 }
 /**
- * The capture seam. It navigates to a page URL, and it gives back the screenshot and the faults. The seam
+ * The capture seam. It navigates to a page URL, and it gives back the screenshots and the faults. The seam
  * speaks the throw protocol, because the chrome connection does. A test injects a seam that reads no
  * browser, thus a tool orchestration runs with no chrome sidecar.
  */
@@ -49,11 +77,12 @@ export interface CaptureOptions {
     readonly waitMs?: number;
 }
 /**
- * Capture one page: the screenshot, the console errors, and the failed requests.
+ * Capture one page: the screenshots, the console errors, and the failed requests.
  *
- * The picture holds the whole document, and not the window alone. Thus a caller can judge a section that a
- * reader reaches by a scroll. A refused full-page bitmap degrades to the window, and the coverage of the
- * result names which of the two pictures arrived.
+ * The pictures hold the document, and not the window alone. Thus a caller can judge a section that a reader
+ * reaches by a scroll. A short page arrives as one full-page shot, and a tall page arrives as consecutive
+ * slices in document order. A refused bitmap degrades to the window, and the coverage of the result names
+ * what the pictures hold.
  *
  * The readiness wait is best-effort. A page that never signals still captures at the readiness budget, thus
  * a broken page gives a picture that shows what broke.

package/dist/lib/page-capture.js

@@ -2,8 +2,15 @@
  * The one page capture over the Chrome sidecar.
  *
  * A capture navigates to a page URL, collects the console errors and the failed requests, waits for the
- * readiness signal of the page, and gives back a base64 screenshot. Two tools capture a report page: the
- * preview snapshot of the old report path and the eyes tool of a report session. Both read this module.
+ * readiness signal of the page, and gives back base64 screenshots. The eyes tool of a report session reads
+ * this module.
+ *
+ * A short page captures as one full-page shot. A tall page captures as consecutive vertical slices, because
+ * one tall picture dies twice on the provider path: a picture past the hard dimension cap rejects the whole
+ * request, and a legal tall picture downscales to about 1568 pixels on the long side, which compresses the
+ * text past legibility. A slice of about two window heights survives both. The slice budget bounds what one
+ * look costs, and a page past the budget truncates with the captured and the total pixels on the coverage,
+ * thus the truncation is never silent.
  *
  * The readiness contract is the reason for one shared body. The renderer emits the event name and the
  * sentinel name, and `report-render/page.ts` owns both constants together with the two budgets. This module
@@ -29,6 +36,23 @@ const SELECTOR_TIMEOUT_MS = 5_000;
  */
 const VIEWPORT_WIDTH = 1440;
 const VIEWPORT_HEIGHT = 900;
+/**
+ * The height of one capture slice, in CSS pixels, and the bound of a single-shot page.
+ *
+ * The provider downscales every picture to about 1568 pixels on the long side before the model reads it. Two
+ * window heights survive that downscale with readable text, and a taller picture reaches the model compressed
+ * past that. Thus a page at this height or under captures as one full-page shot, and a taller page captures
+ * as slices of this height.
+ */
+const TILE_HEIGHT_PX = VIEWPORT_HEIGHT * 2;
+/**
+ * The most slices of one capture.
+ *
+ * Each slice is one picture on the tool result, and the budget bounds what one look costs the context. A page
+ * taller than the budget covers truncates, and the coverage carries the captured and the total pixels, thus
+ * the truncation is never silent.
+ */
+const MAX_TILES = 6;
 /**
  * The body of the readiness wait, in the browser context. The sentinel arm resolves a page that dispatched
  * the event before this wait registered, thus a plain listener never blocks forever. The timer arm bounds a
@@ -57,37 +81,72 @@ function waitForThemeReady(sentinel, event, timeout) {
 function toBase64(shot) {
     return typeof shot === "string" ? shot : Buffer.from(shot).toString("base64");
 }
+/** The body of the height measure, in the browser context. */
+function measureScrollHeight() {
+    return document.documentElement.scrollHeight;
+}
 /**
- * Take the picture of one settled page, at the whole document or at the window alone.
+ * Measure the document height, in CSS pixels. A page that refuses the measure reads as a short one, thus the
+ * capture takes the one full-page shot and the refusal costs no look.
+ */
+async function measureTotalHeight(page) {
+    const measured = await page.evaluate(measureScrollHeight).catch(() => undefined);
+    return typeof measured === "number" && Number.isFinite(measured) ? measured : 0;
+}
+/**
+ * Capture the slices of one tall page, in document order. Each slice clips {@link TILE_HEIGHT_PX} rows at the
+ * reader width, and the last slice ends at the document height or at the budget, whichever comes first.
+ */
+async function captureTiles(page, totalPx) {
+    const tileCount = Math.min(Math.ceil(totalPx / TILE_HEIGHT_PX), MAX_TILES);
+    const screenshots = [];
+    for (let index = 0; index < tileCount; index++) {
+        const fromY = index * TILE_HEIGHT_PX;
+        const toY = Math.min(fromY + TILE_HEIGHT_PX, totalPx);
+        const clip = { x: 0, y: fromY, width: VIEWPORT_WIDTH, height: toY - fromY };
+        screenshots.push({ base64: toBase64(await page.screenshot({ encoding: "base64", clip })), range: { fromY, toY } });
+    }
+    const capturedPx = Math.min(tileCount * TILE_HEIGHT_PX, totalPx);
+    return { screenshots, coverage: { kind: "tiled", capturedPx, totalPx } };
+}
+/**
+ * Take the pictures of one settled page.
+ *
+ * A page at the single-shot bound or under gives one full-page shot. A taller page gives consecutive slices,
+ * because the provider path compresses or rejects one tall picture; the module comment carries the account.
  *
- * The compositor can refuse a full-page bitmap of a tall page while the bitmap of the window is fine. A
- * degraded picture beats a dead look, thus a refused full page retries one time at the window. A second throw
- * names a broken browser and not a tall page, thus it propagates to the caller.
+ * The compositor can refuse a bitmap of either shape while the bitmap of the window is fine. A degraded
+ * picture beats a dead look, thus a refusal retries one time at the window. A second throw names a broken
+ * browser and not a tall page, thus it propagates to the caller.
  */
-async function captureShot(page) {
+async function captureShots(page) {
+    const totalPx = await measureTotalHeight(page);
     try {
-        return { screenshotBase64: toBase64(await page.screenshot({ encoding: "base64", fullPage: true })), coverage: "full" };
+        if (totalPx > TILE_HEIGHT_PX)
+            return await captureTiles(page, totalPx);
+        return { screenshots: [{ base64: toBase64(await page.screenshot({ encoding: "base64", fullPage: true })) }], coverage: { kind: "full" } };
     }
-    catch (refusedFullPage) {
+    catch (refused) {
         try {
-            return { screenshotBase64: toBase64(await page.screenshot({ encoding: "base64" })), coverage: "viewport" };
+            return { screenshots: [{ base64: toBase64(await page.screenshot({ encoding: "base64" })) }], coverage: { kind: "viewport" } };
         }
         catch (refusedViewport) {
             // The two refusals together are the account of a dead look, and the caller reports the second one
             // alone. Thus the first one rides as the cause, and no reader of that report loses half of it.
             if (refusedViewport instanceof Error && refusedViewport.cause === undefined) {
-                refusedViewport.cause = refusedFullPage;
+                refusedViewport.cause = refused;
             }
             throw refusedViewport;
         }
     }
 }
 /**
- * Capture one page: the screenshot, the console errors, and the failed requests.
+ * Capture one page: the screenshots, the console errors, and the failed requests.
  *
- * The picture holds the whole document, and not the window alone. Thus a caller can judge a section that a
- * reader reaches by a scroll. A refused full-page bitmap degrades to the window, and the coverage of the
- * result names which of the two pictures arrived.
+ * The pictures hold the document, and not the window alone. Thus a caller can judge a section that a reader
+ * reaches by a scroll. A short page arrives as one full-page shot, and a tall page arrives as consecutive
+ * slices in document order. A refused bitmap degrades to the window, and the coverage of the result names
+ * what the pictures hold.
  *
  * The readiness wait is best-effort. A page that never signals still captures at the readiness budget, thus
  * a broken page gives a picture that shows what broke.
@@ -124,12 +183,12 @@ export function capturePage(chrome, url, options = {}) {
             const settle = options.waitMs;
             await new Promise((resolve) => setTimeout(resolve, settle));
         }
-        // The picture must show the whole document at the layout that a reader gets. Thus a defect below the
+        // The pictures must show the whole document at the layout that a reader gets. Thus a defect below the
         // fold is visible, and a question about content that never appeared has an answer.
-        const shot = await captureShot(page);
+        const shots = await captureShots(page);
         return {
-            screenshotBase64: shot.screenshotBase64,
-            coverage: shot.coverage,
+            screenshots: shots.screenshots,
+            coverage: shots.coverage,
             consoleErrors,
             failedRequests,
         };

package/dist/loop/run-agent.js

@@ -10,7 +10,7 @@ import { classifyProviderError } from "../providers/errors.js";
 import { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "../providers/prompt-cache.js";
 import { resultStep } from "./run-step.js";
 import { AskRejectedError, UnavailableAsk } from "../tools/approval/contract.js";
-import { isToolError, readToolResultImage } from "../tools/define-tool.js";
+import { isToolError, readToolResultImages } from "../tools/define-tool.js";
 import { addChatUsage, hasReportedUsage, recordAgentRun } from "./metrics.js";
 import { computeDetail, computeResultDetail } from "./tool-detail.js";
 import { toolOutcomeForOutputType } from "./tool-outcome.js";
@@ -457,6 +457,16 @@ function imagePlacementFor(capabilities) {
         return "user-message";
     return "drop";
 }
+/**
+ * The text part that names one deferred picture. The wire holds no structural
+ * link between a user message and a tool call, thus the line names the call. A
+ * result with several pictures numbers each one, thus the model reads which
+ * slice it looks at.
+ */
+function deferredImageLabel(deferred, index) {
+    const call = `the tool result ${deferred.toolCallId} of ${deferred.toolName}`;
+    return deferred.images.length === 1 ? `The picture of ${call}.` : `The picture ${index + 1} of ${deferred.images.length} of ${call}.`;
+}
 /**
  * Append one user message that carries each deferred picture of the round, then
  * empty the collector.
@@ -464,10 +474,11 @@ function imagePlacementFor(capabilities) {
  * The tool message must come directly after the assistant message with the
  * tool calls. Thus a picture rides a separate message after the whole tool
  * message, and one message batches the round. The parts obey the order of
- * `results`, which is the order of the tool calls. Each deferred picture has a
- * result of this round, because the collector fills during the dispatch and it
- * empties here. A text part names the tool call of each picture, because the wire
- * holds no structural link between a user message and a tool call.
+ * `results`, which is the order of the tool calls, and the pictures of one
+ * result keep the order that the tool gave. Each deferred picture has a result
+ * of this round, because the collector fills during the dispatch and it empties
+ * here. A text part names the tool call of each picture, because the wire holds
+ * no structural link between a user message and a tool call.
  *
  * The message carries the synthetic marker, because a `user` message opens a
  * conversation turn. An unmarked one is loop machinery that reads as a turn
@@ -482,8 +493,10 @@ function appendDeferredImages(messages, results, deferredImages) {
         const deferred = byToolCallId.get(result.toolCallId);
         if (deferred === undefined)
             continue;
-        content.push({ type: "text", text: `The picture of the tool result ${deferred.toolCallId} of ${deferred.toolName}.` });
-        content.push({ type: "file", mediaType: deferred.image.mediaType, data: { type: "data", data: deferred.image.base64 } });
+        for (const [index, image] of deferred.images.entries()) {
+            content.push({ type: "text", text: deferredImageLabel(deferred, index) });
+            content.push({ type: "file", mediaType: image.mediaType, data: { type: "data", data: image.base64 } });
+        }
     }
     messages.push(syntheticUserMessage(content));
     deferredImages.length = 0;
@@ -615,15 +628,16 @@ function jsonValue(value) {
  * Encode a tool ok value onto a tool-result message. A value with no picture
  * stays a plain JSON result, byte-identical to a value that never carried one.
  *
- * A value that carries a picture splits: the JSON data goes to a text part, and
- * the bytes ride as an image content block. Thus the model sees the picture, and
- * the JSON text holds no bytes. When the wire carries no picture, the block drops
- * and the text stays, because base64 text floods the context and the model cannot
- * see it. The drop rides the log, thus an operator sees that the picture did not
- * reach the model.
+ * A value that carries pictures splits: the JSON data goes to a text part, and
+ * the bytes ride as image content blocks after it, in the order that the tool
+ * gave. Thus the model sees each picture, and the JSON text holds no bytes. When
+ * the wire carries no picture, the blocks drop and the text stays, because
+ * base64 text floods the context and the model cannot see it. One warn with the
+ * count rides the log, thus an operator sees how many pictures did not reach the
+ * model.
  *
  * A wire that renders a picture on a user message only gets the fallback: the
- * result keeps its JSON text, and the picture goes to the collector of the round.
+ * result keeps its JSON text, and the pictures go to the collector of the round.
  * The round then sends the bytes after the tool message.
  */
 function successResult(toolCall, value, encoding) {
@@ -634,15 +648,18 @@ function successResult(toolCall, value, encoding) {
         toolName: toolCall.toolName,
         output: { type: "json", value: jsonData },
     };
-    const image = readToolResultImage(value);
-    if (image === undefined)
+    const images = readToolResultImages(value);
+    if (images.length === 0)
         return jsonOnly;
     if (encoding.placement === "drop") {
-        encoding.log.warn("the wired provider carries no picture in a tool result, thus the picture is dropped", { toolName: toolCall.toolName });
+        encoding.log.warn("the wired provider carries no picture in a tool result, thus the pictures are dropped", {
+            toolName: toolCall.toolName,
+            imageCount: images.length,
+        });
         return jsonOnly;
     }
     if (encoding.placement === "user-message") {
-        encoding.deferredImages.push({ toolCallId: toolCall.toolCallId, toolName: toolCall.toolName, image });
+        encoding.deferredImages.push({ toolCallId: toolCall.toolCallId, toolName: toolCall.toolName, images });
         return jsonOnly;
     }
     return {
@@ -653,7 +670,7 @@ function successResult(toolCall, value, encoding) {
             type: "content",
             value: [
                 { type: "text", text: JSON.stringify(jsonData) },
-                { type: "file", mediaType: image.mediaType, data: { type: "data", data: image.base64 } },
+                ...images.map((image) => ({ type: "file", mediaType: image.mediaType, data: { type: "data", data: image.base64 } })),
             ],
         },
     };

package/dist/memory/card-builders.d.ts

@@ -3,12 +3,10 @@
  * `data-presentation`, `data-run-card`, `data-file-reference`).
  *
  * Display tools (`show_plan`, `show_user`, `show_file`) emit these cards live
- * over the chat SSE stream, but the persisted turn keeps only the Anthropic
- * transcript (text / tool_use / tool_result) — the cards are not stored. To
- * re-render a card on reload, `content-to-cortex` reconstructs it from the
- * tool_use block via these same builders, so the live and replayed cards are
- * byte-identical (the deterministic `id` matches, enabling downstream
- * reconciliation).
+ * over the chat SSE stream, and the turn persists what it emitted, so a reload
+ * replays the built card rather than rebuilding it. These builders therefore run
+ * once per card, on the live path only. The `id` stays deterministic all the
+ * same: it is what a re-emission of the same card reconciles on.
  *
  * The builders return the FLAT wire `data` payload (no `type` wrapper, no
  * `source`): the tool emits `{ type, source, data }` (the emit pipeline

package/dist/memory/card-builders.js

@@ -3,12 +3,10 @@
  * `data-presentation`, `data-run-card`, `data-file-reference`).
  *
  * Display tools (`show_plan`, `show_user`, `show_file`) emit these cards live
- * over the chat SSE stream, but the persisted turn keeps only the Anthropic
- * transcript (text / tool_use / tool_result) — the cards are not stored. To
- * re-render a card on reload, `content-to-cortex` reconstructs it from the
- * tool_use block via these same builders, so the live and replayed cards are
- * byte-identical (the deterministic `id` matches, enabling downstream
- * reconciliation).
+ * over the chat SSE stream, and the turn persists what it emitted, so a reload
+ * replays the built card rather than rebuilding it. These builders therefore run
+ * once per card, on the live path only. The `id` stays deterministic all the
+ * same: it is what a re-emission of the same card reconciles on.
  *
  * The builders return the FLAT wire `data` payload (no `type` wrapper, no
  * `source`): the tool emits `{ type, source, data }` (the emit pipeline

package/dist/memory/conversation-display-replay.d.ts

@@ -1,18 +1,19 @@
 /**
  * The runtime transcript read: stored display projections → `CortexMessage[]`.
  *
- * `ThreadHistory.loadPage` returns a thread's rows in `seq` order, and every
+ * `ThreadHistory.loadAll` returns a thread's rows in `seq` order, and every
  * append's first row carries the display projection for that append. Replay is
  * therefore a concatenation: walk the rows, emit each envelope's messages in
  * order, done. No turn grouping, no tool-name recognition, no card rebuilding,
  * no filesystem or database lookup — nothing that could render a reloaded
  * conversation differently from the one the user was shown.
  *
- * A row with no envelope predates the display projection and is skipped. The
- * startup backfill (`conversation-display-backfill.ts`) writes one for every such
- * row before the runtime serves traffic, so in a booted harness there are none;
- * skipping rather than falling back to the migration renderer is what keeps the
- * reconstruction path out of the runtime entirely.
+ * A row with no envelope predates the display projection and is skipped — the
+ * only handling there is or will be. Reconstructing one from the model
+ * transcript instead is what the deleted migration renderer did, and rebuilding
+ * a display from a transcript that never carried one makes every later change to
+ * a tool or a card silently rewrite history. Skipping keeps the gap observable
+ * and the read total in what it consults: the stored projection, nothing else.
  */
 import type { CortexMessage } from "../contracts/message.js";
 import type { StoredMessage } from "./thread-history.js";

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

@@ -1,18 +1,19 @@
 /**
  * The runtime transcript read: stored display projections → `CortexMessage[]`.
  *
- * `ThreadHistory.loadPage` returns a thread's rows in `seq` order, and every
+ * `ThreadHistory.loadAll` returns a thread's rows in `seq` order, and every
  * append's first row carries the display projection for that append. Replay is
  * therefore a concatenation: walk the rows, emit each envelope's messages in
  * order, done. No turn grouping, no tool-name recognition, no card rebuilding,
  * no filesystem or database lookup — nothing that could render a reloaded
  * conversation differently from the one the user was shown.
  *
- * A row with no envelope predates the display projection and is skipped. The
- * startup backfill (`conversation-display-backfill.ts`) writes one for every such
- * row before the runtime serves traffic, so in a booted harness there are none;
- * skipping rather than falling back to the migration renderer is what keeps the
- * reconstruction path out of the runtime entirely.
+ * A row with no envelope predates the display projection and is skipped — the
+ * only handling there is or will be. Reconstructing one from the model
+ * transcript instead is what the deleted migration renderer did, and rebuilding
+ * a display from a transcript that never carried one makes every later change to
+ * a tool or a card silently rewrite history. Skipping keeps the gap observable
+ * and the read total in what it consults: the stored projection, nothing else.
  */
 import { conversationUIToCortexMessages } from "./conversation-display-storage.js";
 export function storedMessagesToCortex(messages) {

package/dist/memory/conversation-display-storage.d.ts

@@ -18,6 +18,7 @@ import { type DataUIPart, type UIMessage } from "ai";
 import type { AskPart, ChildSessionStartedPart, FileReferencePart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
 import type { CortexMessage, CortexPart, ToolCallPart } from "../contracts/message.js";
+import type { Logger } from "../lib/logger.js";
 export declare const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 type Payload<T extends {
     type: string;
@@ -52,7 +53,7 @@ export interface StoredDisplayEnvelope {
     readonly messages: ConversationUIMessage[];
 }
 export declare function envelopeDisplayMessages(messages: readonly ConversationUIMessage[]): StoredDisplayEnvelope;
-export declare function parseStoredDisplayEnvelope(value: unknown, identity: string): Promise<StoredDisplayEnvelope>;
+export declare function parseStoredDisplayEnvelope(value: unknown, identity: string, logger?: Logger): Promise<StoredDisplayEnvelope>;
 /**
  * Build the stored form of one non-text Cortex part.
  *
@@ -66,15 +67,6 @@ export declare function parseStoredDisplayEnvelope(value: unknown, identity: str
 export declare function conversationDisplayPart(part: Exclude<CortexPart, {
     type: "text";
 }>): DataUIPart<ConversationUIData>;
-/**
- * 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 declare function cortexMessagesToConversationUI(messages: readonly CortexMessage[]): ConversationUIMessage[];
 /**
  * Read the durable representation back as Cortex display messages.
  *