@inflexa-ai/harness 0.25.0 → 0.26.0

package/dist/tools/define-tool.js

@@ -21,30 +21,46 @@ export function isToolError(value) {
     return typeof value === "object" && value !== null && typeof value.error === "string" && typeof value.retryable === "boolean";
 }
 /**
- * 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 const toolResultImageKey = Symbol("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 function withToolResultImage(value, image) {
     return { ...value, [toolResultImageKey]: image };
 }
-/** Read the picture that a tool ok value carries, or undefined when it carries none. */
-export function readToolResultImage(value) {
+/**
+ * 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 function withToolResultImages(value, images) {
+    return { ...value, [toolResultImageKey]: images };
+}
+/** Does one entry under the reserved key carry the picture shape? */
+function isToolResultImage(entry) {
+    if (typeof entry !== "object" || entry === null)
+        return false;
+    const { base64, mediaType } = entry;
+    return typeof base64 === "string" && typeof mediaType === "string";
+}
+/**
+ * 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 function readToolResultImages(value) {
     if (typeof value !== "object" || value === null)
-        return undefined;
-    const image = value[toolResultImageKey];
-    if (typeof image !== "object" || image === null)
-        return undefined;
-    const { base64, mediaType } = image;
-    if (typeof base64 !== "string" || typeof mediaType !== "string")
-        return undefined;
-    return { base64, mediaType };
+        return [];
+    const carried = value[toolResultImageKey];
+    const entries = Array.isArray(carried) ? carried : [carried];
+    return entries.filter(isToolResultImage);
 }
 /**
  * Package a `Tool`. The emitted JSON Schema must have a top-level

package/dist/tools/report-session/examine-page.d.ts

@@ -29,9 +29,9 @@
  *
  * On a capture the tool copies the rendered hash onto the seen hash through the gateway. Thus the look
  * counts, and the record tool lets the current draft record. The copy takes the rendered hash and never the
- * current one, thus a later edit makes the look stale and the record refuses. A picture of the window alone
- * is a true picture of the current document, thus it stamps the same and the coverage of the result is what
- * tells the agent what it saw.
+ * current one, thus a later edit makes the look stale and the record refuses. A partial look — the window
+ * alone, or slices that a budget truncated — is a true look at the current document, thus it stamps the same
+ * and the coverage of the result is what tells the agent what it saw.
  *
  * The gateway reports whether a rendered hash existed to copy. When the row holds none, no preview stamped
  * one and the look cannot count. The tool then gives a missed-stamp outcome that directs a new preview,
@@ -49,11 +49,11 @@ import type { AuthContext } from "../../auth/types.js";
 import { type ChromeConfig } from "../../lib/chrome.js";
 import { type AcquireEyes } from "../../lib/eyes.js";
 import { type Logger } from "../../lib/logger.js";
-import { type CapturePage, type FailedRequest, type PageCapture } from "../../lib/page-capture.js";
+import { type CaptureCoverage, type CapturePage, type FailedRequest, type PageCapture } from "../../lib/page-capture.js";
 import { type ResolveWorkspaceRoot } from "../../workspace/paths.js";
 import { type Tool } from "../define-tool.js";
 import { type ReportSessionStateGateway, type SessionRefusal } from "../report-authoring/authoring-tools.js";
-export type { CapturePage, FailedRequest, PageCapture };
+export type { CaptureCoverage, CapturePage, FailedRequest, PageCapture };
 /**
  * The URL formation of one look. It maps the page of the thread onto the URL that the browser opens.
  * A composition whose browser cannot reach the workspace tree binds a resolver that names a served URL.
@@ -69,15 +69,23 @@ export type ResolvePageUrl = (args: {
 /** The empty input. The tool examines the current page of the thread, thus it needs no field. */
 declare const examinePageInput: z.ZodObject<{}, z.core.$strip>;
 export type ExaminePageInput = z.infer<typeof examinePageInput>;
+/** The document range of one slice of a tiled look, in the order that the pictures ride. */
+export interface ExaminedTile {
+    index: number;
+    fromY: number;
+    toY: number;
+}
 /**
  * The typed outcome of the eyes tool. Each arm is ok-channel data, thus the tool never throws for a
- * degraded condition. `examined` carries the coverage of the picture, the console errors, the failed
- * requests, and the page path. The coverage names what the agent saw: the whole document, or the window
- * alone when the browser refused a full-page bitmap. The screenshot does not ride the JSON. It rides the
- * image path of the tool result, thus the model sees the picture and the JSON text holds no bytes.
- * `missed-stamp` means that the row holds no rendered hash, thus no preview stamped one and the agent must
- * run a new preview before the next look. `no-browser` means that the composition gives no browser, thus no
- * look is possible at all and a repeat gives the same answer.
+ * degraded condition. `examined` carries the coverage of the look, the console errors, the failed
+ * requests, and the page path. The coverage names what the agent saw: the whole document in one shot,
+ * consecutive slices with the captured and the total pixels, or the window alone when the browser refused
+ * the bitmap. A tiled look carries `tiles` — the document range of each slice, in the order of the
+ * pictures — thus the model reads which rows each picture holds. The screenshots do not ride the JSON.
+ * They ride the image path of the tool result in document order, thus the model sees the pictures and the
+ * JSON text holds no bytes. `missed-stamp` means that the row holds no rendered hash, thus no preview
+ * stamped one and the agent must run a new preview before the next look. `no-browser` means that the
+ * composition gives no browser, thus no look is possible at all and a repeat gives the same answer.
  */
 export type ExaminePageResult = {
     outcome: "refused";
@@ -94,7 +102,8 @@ export type ExaminePageResult = {
     detail: string;
 } | {
     outcome: "examined";
-    coverage: PageCapture["coverage"];
+    coverage: CaptureCoverage;
+    tiles?: ExaminedTile[];
     consoleErrors: string[];
     failedRequests: FailedRequest[];
     pagePath: string;

package/dist/tools/report-session/examine-page.js

@@ -29,9 +29,9 @@
  *
  * On a capture the tool copies the rendered hash onto the seen hash through the gateway. Thus the look
  * counts, and the record tool lets the current draft record. The copy takes the rendered hash and never the
- * current one, thus a later edit makes the look stale and the record refuses. A picture of the window alone
- * is a true picture of the current document, thus it stamps the same and the coverage of the result is what
- * tells the agent what it saw.
+ * current one, thus a later edit makes the look stale and the record refuses. A partial look — the window
+ * alone, or slices that a budget truncated — is a true look at the current document, thus it stamps the same
+ * and the coverage of the result is what tells the agent what it saw.
  *
  * The gateway reports whether a rendered hash existed to copy. When the row holds none, no preview stamped
  * one and the look cannot count. The tool then gives a missed-stamp outcome that directs a new preview,
@@ -55,7 +55,7 @@ import { createStaticEyes } from "../../lib/eyes.js";
 import { defaultErrorFields } from "../../lib/logger.js";
 import { capturePage } from "../../lib/page-capture.js";
 import { reportSessionDir } from "../../workspace/paths.js";
-import { defineTool, withToolResultImage } from "../define-tool.js";
+import { defineTool, withToolResultImages } from "../define-tool.js";
 import { openReportThread } from "../report-authoring/authoring-tools.js";
 /** The empty input. The tool examines the current page of the thread, thus it needs no field. */
 const examinePageInput = z.object({});
@@ -226,8 +226,9 @@ export function createExaminePageTool(deps) {
     return defineTool({
         id: "examine_page",
         description: "Open the rendered report page in a real headless browser, and report what you see. " +
-            "Give back a screenshot, the coverage of that screenshot, the console errors, and the failed requests. " +
-            "The coverage says whether the picture holds the whole page, or the top window alone. " +
+            "Give back one or more screenshots, the coverage of the look, the console errors, and the failed requests. " +
+            "A tall page arrives as consecutive top-to-bottom slices in document order, and the tiles list names the rows of each slice. " +
+            "The coverage says whether the pictures hold the whole page, a truncated top portion of it, or the top window alone. " +
             "Run it after the preview to look at the current page, and to confirm that the layout and the charts read clean. " +
             "The report tool records a version only after you look at the current page. " +
             "If the page has no confirmed render, run the preview again first.",
@@ -317,15 +318,19 @@ export function createExaminePageTool(deps) {
                 const detail = stamped.outcome === "failed" ? stamped.detail : "the session state row is absent";
                 logger.warn("the seen hash did not stamp", { threadId, analysisId, detail });
             }
-            // The screenshot rides the image path of the tool result, thus the model sees the picture. The
-            // JSON keeps the faults and the page path only, thus the JSON text holds no bytes.
-            return ok(withToolResultImage({
+            // The screenshots ride the image path of the tool result in document order, thus the model sees
+            // the pictures. The JSON keeps the faults, the tile ranges, and the page path only, thus the
+            // JSON text holds no bytes. The tiles list mirrors the picture order, thus the model reads which
+            // rows each picture holds.
+            const tiles = captured.screenshots.flatMap((shot, index) => shot.range === undefined ? [] : [{ index, fromY: shot.range.fromY, toY: shot.range.toY }]);
+            return ok(withToolResultImages({
                 outcome: "examined",
                 coverage: captured.coverage,
+                ...(tiles.length === 0 ? {} : { tiles }),
                 consoleErrors: captured.consoleErrors,
                 failedRequests: captured.failedRequests,
                 pagePath: relativePagePath,
-            }, { base64: captured.screenshotBase64, mediaType: SCREENSHOT_MEDIA_TYPE }));
+            }, captured.screenshots.map((shot) => ({ base64: shot.base64, mediaType: SCREENSHOT_MEDIA_TYPE }))));
         },
     });
 }

package/dist/tools/report-session/index.d.ts

@@ -6,7 +6,7 @@
  * the factories and their public types for the composition root.
  */
 export { createPreviewReportTool, type PreviewReportInput, type PreviewReportResult, type PreviewReportToolDeps, type ResolvePageAsset, type SessionPageAccess, } from "./preview-report.js";
-export { createExaminePageTool, type CapturePage, type ExaminePageInput, type ExaminePageResult, type ExaminePageToolDeps, type FailedRequest, type PageCapture, type ResolvePageUrl, } from "./examine-page.js";
+export { createExaminePageTool, type CaptureCoverage, type CapturePage, type ExaminedTile, type ExaminePageInput, type ExaminePageResult, type ExaminePageToolDeps, type FailedRequest, type PageCapture, type ResolvePageUrl, } from "./examine-page.js";
 export { describeSessionPageMintFailure, UnavailableSessionPagePublisher, type MakeSessionPagePublisher, type SessionPageMintFailure, type SessionPageMintResult, type SessionPagePublisher, } from "./session-page-publisher.js";
 export { createRecordVersionTool, type RecordVersionInput, type RecordVersionResult, type RecordVersionToolDeps } from "./record-version.js";
 export { createDeriveTableTool, type DeriveTableInput, type DeriveTableResult, type DeriveTableToolDeps } from "./derive-table.js";

package/dist/tools/research/generate-plan.js

@@ -36,7 +36,6 @@ import { createListAvailablePackagesTool } from "../sandbox/list-available-packa
 import { createListAvailableRefsTool } from "../sandbox/list-available-refs.js";
 import { createReportBlockerToolFor } from "../sandbox/report-blocker.js";
 import { DATA_PROFILE_ORIENTATION_MAX_CHARS, buildDataProfileOrientation } from "../../app/data-profile-orientation.js";
-import { isDataProfileStale } from "../../app/data-profile-policy.js";
 import { DEFAULT_SANDBOX_MAX_STEPS } from "../../config/resource-limits.js";
 import { plannerPrompt } from "../../prompts/planner.js";
 import { hydratePlanSteps, PlannerPlanSchema } from "../../schemas/plan-schemas.js";
@@ -157,10 +156,9 @@ function formatPriorPlan(parentPlanId, plan) {
 /**
  * Read the profile ledger row into a grounding variant.
  *
- * Staleness is `isDataProfileStale` — the single definition in
- * `app/data-profile-policy.ts` that the embedder's re-trigger policy and
- * `inspect_data_profile` also use, so the planner and the conversation agent can
- * never disagree about whether a profile still describes the data.
+ * A profile is re-invoked by the embedder when the input set changes, never derived
+ * as stale on read, so the only qualification this can raise is one the ledger row
+ * states outright: an attempt that superseded this result is running, or failed.
  */
 function classifyGrounding(status) {
     // `loadDataProfileStatus` collapses "no analysis row" and "profile cleared"
@@ -182,9 +180,6 @@ function classifyGrounding(status) {
     // preserve `data_profile_result` on purpose, so a non-`completed` status
     // carrying a result means what is on the row is the PREVIOUS profile.
     const reasons = [];
-    if (isDataProfileStale({ fileIds: status.seedInputFileIds ?? [] }, result)) {
-        reasons.push("the analysis's input file set changed after this profile was taken");
-    }
     if (status.status === "pending" || status.status === "running") {
         reasons.push("a re-profile is in progress — this is the previous profile");
     }

package/dist/tools/research/inspect-data-profile.js

@@ -22,7 +22,6 @@
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
-import { isDataProfileStale } from "../../app/data-profile-policy.js";
 import { scopeResource } from "../../auth/types.js";
 import { unwrapOrThrow } from "../../lib/result.js";
 import { loadDataProfileStatus } from "../../state/index.js";
@@ -48,19 +47,19 @@ function datasetFileCount(result) {
 /**
  * Name every reason the served profile may not describe the current inputs.
  *
- * Two independent things make a profile stale, and both are ordinary. The input set can
- * change under a completed profile (`isDataProfileStale` — the same predicate the
- * embedder's re-trigger policy uses; staleness is defined once, in
- * `app/data-profile-policy.ts`, not re-derived here). And the ledger can have moved off
- * `completed` while an older result is still on the row: `tryRerun`/`tryRetry` preserve
+ * Every reason is one the ledger row states outright: the row has moved off `completed`
+ * while an older result is still on it, because `tryRerun`/`tryRetry` preserve
  * `data_profile_result` precisely so a prior profile stays servable while the next
  * attempt runs or after it fails.
+ *
+ * A changed input set is deliberately NOT among them. Re-profiling is invoked by the
+ * embedder that owns the input mutation — it knows the set changed at the moment it
+ * changed — so a row still reading `completed` is a row nothing has superseded. Deriving
+ * a verdict here would mean re-deciding, from one table row, a question already answered
+ * by the party that watched it happen.
  */
-function stalenessReasons(status, result) {
+function stalenessReasons(status) {
     const reasons = [];
-    if (isDataProfileStale({ fileIds: status.seedInputFileIds ?? [] }, result)) {
-        reasons.push("the analysis's input file set changed after this profile was taken");
-    }
     if (status.status === "running" || status.status === "pending") {
         reasons.push("a re-profile is in progress — this is the previous profile");
     }
@@ -163,7 +162,7 @@ export function createInspectDataProfileTool(pool) {
                     message: "Data profiling is still running; no profile is available yet. Proceed without it or ask the user to wait.",
                 });
             }
-            const reasons = stalenessReasons(status, result);
+            const reasons = stalenessReasons(status);
             const envelope = reasons.length > 0
                 ? { state: "stale", staleReason: reasons.join("; "), profiledAt: result.profiledAt }
                 : { state: "ready", profiledAt: result.profiledAt };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.25.0",
+    "version": "0.26.0",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",

package/dist/app/data-profile-policy.d.ts

@@ -1,62 +0,0 @@
-/**
- * Data-profile policy — the pure decision an embedder applies when it reads a
- * data-profile status (see CONTEXT.md "Application service layer"). It decides
- * whether to (re)trigger profiling; the embedder executes the staging + trigger
- * — staging stays embedder-side per the data-profile-init spec, and the atomic running→expired
- * flip stays an SQL guard (`expireStaleDataProfile`), not part of this decision.
- */
-import type { DataProfileInputSignature, DataProfileLifecycleStatus } from "../contracts/data-profile.js";
-export type { DataProfileLifecycleStatus };
-/**
- * The analysis's inputs as they are NOW. A caller holding sizes and mtimes supplies
- * the signature; one holding only the ledger's seeded ids supplies just those, and the
- * comparison degrades honestly to what those ids can settle.
- */
-export interface CurrentInputSet {
-    readonly fileIds: readonly string[];
-    readonly signature?: DataProfileInputSignature;
-}
-/** The comparand a profile snapshot carries. Which one is present depends on its era. */
-export interface ProfiledInputSnapshot {
-    readonly inputSignature?: DataProfileInputSignature;
-    readonly inputFileIds?: readonly string[];
-}
-/**
- * A completed profile is stale when the analysis's current input set no longer matches
- * the set the profile actually covered.
- *
- * The signature is preferred where both sides carry one: it covers size and mtime as
- * well as identity, so an in-place edit is drift too. A snapshot predating the
- * signature falls back to its identity list rather than being treated as drift, since
- * that list answers the same question for the set it covered. A snapshot carrying
- * NEITHER is drift: nothing establishes what it covered, and one re-profile heals it —
- * exactly how a wholly absent `result` is already treated.
- *
- * An empty current set is never stale: there is nothing to compare, and an analysis
- * whose inputs were removed is handled by clearing the profile, not by re-profiling it.
- */
-export declare function isDataProfileStale(current: CurrentInputSet, profiled: ProfiledInputSnapshot | null | undefined): boolean;
-export type DataProfileAction = {
-    readonly kind: "none";
-} | {
-    readonly kind: "trigger";
-} | {
-    readonly kind: "retrigger";
-};
-export interface DataProfileDecisionInput {
-    readonly status: DataProfileLifecycleStatus;
-    /** The analysis's inputs as they are now — the seeded ids, plus a signature where the caller has one. */
-    readonly current: CurrentInputSet;
-    /** The comparand the stored profile carries, or null when it holds none. */
-    readonly profiled: ProfiledInputSnapshot | null;
-}
-/**
- * Decide the next profiling action from a (post-expire) status:
- *   - `pending`            → `trigger`   (first profile)
- *   - `completed` && stale → `retrigger` (inputs changed since profiling)
- *   - anything else        → `none`
- *
- * `running` is left to finish (or to the SQL expiry guard); `failed` is retried
- * explicitly via the retry route, never implicitly on read.
- */
-export declare function decideDataProfileAction(input: DataProfileDecisionInput): DataProfileAction;

package/dist/app/data-profile-policy.js

@@ -1,59 +0,0 @@
-/**
- * Data-profile policy — the pure decision an embedder applies when it reads a
- * data-profile status (see CONTEXT.md "Application service layer"). It decides
- * whether to (re)trigger profiling; the embedder executes the staging + trigger
- * — staging stays embedder-side per the data-profile-init spec, and the atomic running→expired
- * flip stays an SQL guard (`expireStaleDataProfile`), not part of this decision.
- */
-/**
- * A completed profile is stale when the analysis's current input set no longer matches
- * the set the profile actually covered.
- *
- * The signature is preferred where both sides carry one: it covers size and mtime as
- * well as identity, so an in-place edit is drift too. A snapshot predating the
- * signature falls back to its identity list rather than being treated as drift, since
- * that list answers the same question for the set it covered. A snapshot carrying
- * NEITHER is drift: nothing establishes what it covered, and one re-profile heals it —
- * exactly how a wholly absent `result` is already treated.
- *
- * An empty current set is never stale: there is nothing to compare, and an analysis
- * whose inputs were removed is handled by clearing the profile, not by re-profiling it.
- */
-export function isDataProfileStale(current, profiled) {
-    if (current.fileIds.length === 0 && current.signature === undefined)
-        return false;
-    if (!profiled)
-        return true;
-    if (profiled.inputSignature) {
-        // A caller with no signature of its own can still compare counts, which catches
-        // an added or removed file. It cannot catch a same-count swap, and claiming
-        // otherwise would be a verdict the comparand does not support.
-        if (!current.signature)
-            return profiled.inputSignature.count !== current.fileIds.length;
-        return profiled.inputSignature.digest !== current.signature.digest || profiled.inputSignature.count !== current.signature.count;
-    }
-    if (profiled.inputFileIds) {
-        if (current.fileIds.length !== profiled.inputFileIds.length)
-            return true;
-        const covered = new Set(profiled.inputFileIds);
-        return current.fileIds.some((id) => !covered.has(id));
-    }
-    return true;
-}
-/**
- * Decide the next profiling action from a (post-expire) status:
- *   - `pending`            → `trigger`   (first profile)
- *   - `completed` && stale → `retrigger` (inputs changed since profiling)
- *   - anything else        → `none`
- *
- * `running` is left to finish (or to the SQL expiry guard); `failed` is retried
- * explicitly via the retry route, never implicitly on read.
- */
-export function decideDataProfileAction(input) {
-    if (input.status === "pending")
-        return { kind: "trigger" };
-    if (input.status === "completed" && isDataProfileStale(input.current, input.profiled)) {
-        return { kind: "retrigger" };
-    }
-    return { kind: "none" };
-}

package/dist/memory/content-to-cortex.d.ts

@@ -1,75 +0,0 @@
-/**
- * The MIGRATION renderer: stored AI SDK model messages → `CortexMessage[]`.
- *
- * This is how a conversation written before display projections were persisted
- * is rendered ONCE, at startup, so it can be frozen into a display envelope
- * (`conversation-display-backfill.ts`). It is not a runtime read path — the
- * runtime reads the stored projection (`conversation-display-replay.ts`) and
- * never consults a tool name, a card builder, or the filesystem.
- *
- * Everything it does is inference from a transcript that was never meant to
- * carry display, which is why it belongs to the migration and nothing else:
- *
- *   - text part         → text part
- *   - tool-call part    → a reconstructed display card (`data-plan`,
- *                         `data-presentation`) when `resolveCard` recognises
- *                         the tool, else a generic tool-call part whose detail
- *                         `resolveDetail` recomputes from the persisted input
- *   - everything else   → dropped (reasoning, tool-result, etc.) — the UI
- *                         does not render them
- *
- * A `tool-result` block is not rendered, but it is not ignored either: it is the
- * only record of how its call ended. The blocks are indexed by `toolCallId`
- * before conversion so each tool-call part can report its own outcome — without
- * that pass every migrated call would report success, including the failed ones.
- *
- * A row that yields no renderable parts (e.g. a `tool`-role message carrying
- * only tool-result continuation parts) is omitted entirely, so the rendered
- * conversation has no empty bubbles. Storage is never mutated.
- */
-import type { CortexMessage } from "@inflexa-ai/harness/contracts/message.js";
-import type { ToolDetailResolver } from "../tools/detail-resolver.js";
-import type { ToolCardResolver } from "./reconstruct-cards.js";
-import type { StoredMessage } from "./thread-history.js";
-/**
- * The resolvers a caller may supply, as one object.
- *
- * An options bag rather than a growing positional list: both are optional, both
- * are function-typed, and a second positional parameter of the same shape is a
- * call site that silently does the wrong thing when the two are swapped.
- */
-export interface ContentToCortexOptions {
-    /** Rebuilds a display card (`data-plan`, `data-presentation`) from a persisted tool call. */
-    readonly resolveCard?: ToolCardResolver;
-    /** Rebuilds a call's one-line detail from its tool name and persisted input. */
-    readonly resolveDetail?: ToolDetailResolver;
-}
-/**
- * Map stored messages (oldest-first) to `CortexMessage[]`. Rows that produce
- * no renderable parts are dropped, and consecutive assistant rows are coalesced
- * into one message. The first row's `seq` becomes the stable message id.
- * `options.resolveCard` reconstructs display cards from `tool_use` blocks and
- * `options.resolveDetail` reconstructs each call's one-line detail; both are
- * optional and each tool-call part reports its outcome either way.
- * A row carrying the interruption marker sets `interrupted: true` on the message
- * it lands in, including when coalesced into an assistant run; a row carrying a
- * stored turn rollup sets `usage` the same way. A row that carries a stored turn
- * duration sets `durationMs` the same way too. Thus a reloaded conversation shows
- * the cost and the time that the live turn showed, with no second query.
- *
- * Coalescing mirrors the live SSE shape. The agent loop persists each assistant
- * step (typically a single `tool_use`) as its own row, and the `tool_result`
- * `user` rows between them drop to zero renderable parts above — so one assistant
- * turn is stored as a run of adjacent assistant rows. The live chat stream
- * accumulates that whole turn into a single assistant message whose `parts` hold
- * every step; reconstructing it row-by-row instead would emit one message per
- * tool call, which the UI renders as a stack of single-tool boxes. Merging the
- * run restores the one-bubble-per-turn shape (and lets the UI collapse the tool
- * calls into one group) regardless of how the loop split the turn into rows.
- *
- * Coalescing is assistant-only. User rows never legitimately split into a run —
- * adjacent `user` rows arise only from turns that persisted no reply (an aborted
- * turn's lone user message followed by the next turn's), and merging them would
- * fabricate one bubble from two messages the user sent separately.
- */
-export declare function contentToCortexMessages(messages: readonly StoredMessage[], options?: ContentToCortexOptions): Promise<CortexMessage[]>;