@inflexa-ai/harness 0.41.2 → 0.42.1

package/dist/agents/conversation-agent.js

@@ -44,6 +44,8 @@ import { createResolveCitationTool } from "../tools/research/resolve-citation.js
 export const CONVERSATION_AGENT_ID = "conversation-agent";
 /** Runaway guard — heavy tool-driving turns need generous headroom. */
 const CONVERSATION_MAX_ITERATIONS = 200;
+/** Compaction budgets, in the input tokens of a request. */
+const CONVERSATION_COMPACTION = { turnStartBudget: 150_000, budget: 200_000 };
 /** Build the conversation `AgentDefinition` with every tool fully dep-bound. */
 export function createConversationAgent(deps) {
     const { provider, pool, embedding, workspaceFs, model, utilityProvider, utilityModel, executeAnalysisWorkflow, runAuthorizer, runLauncher, bioKeys, chrome, resourcePolicy, hostTools, refStorePath, farmLockFile, imagePackagesFile, readPoolInventory, usageRecorder, toolOutputStore, citationResolver, } = deps;
@@ -195,5 +197,6 @@ export function createConversationAgent(deps) {
         model,
         tools,
         maxIterations: CONVERSATION_MAX_ITERATIONS,
+        compaction: CONVERSATION_COMPACTION,
     };
 }

package/dist/agents/report-session-agent.d.ts

@@ -77,8 +77,8 @@ export interface ReportSessionAgentDeps {
      * Omitted, the tool derives nothing, the same as an absent sandbox client.
      */
     readonly runAuthorizer?: RunAuthorizer;
-    /** Thread reader -- the record tool reads the anchor of the report thread. */
-    readonly threads: Pick<ThreadStore, "getThread">;
+    /** Thread store -- the record tool reads the anchor of the report thread, and the preview tool names it. */
+    readonly threads: Pick<ThreadStore, "getThread" | "setAutoTitle">;
     /** Headless-Chrome config -- the eyes tool opens the rendered page. */
     readonly chrome: ChromeConfig;
     /**

package/dist/agents/report-session-agent.js

@@ -37,6 +37,8 @@ export const REPORT_SESSION_AGENT_ID = "report-session";
  * gets the headroom of the report runner (REPORT_AGENT_MAX_STEPS).
  */
 const REPORT_SESSION_MAX_ITERATIONS = 200;
+/** A session is one long turn that holds page captures, thus it compacts only during the turn, at a higher budget. */
+const REPORT_SESSION_COMPACTION = { budget: 250_000 };
 /** Build the report `AgentDefinition` with every tool bound to its deps. */
 export function createReportSessionAgent(deps) {
     const { model, pool, embedding, workspaceFs, gateway, resolveWorkspaceRoot, store, threads, chrome, eyes, makeResolver, resolvePageAsset, logger } = deps;
@@ -87,6 +89,7 @@ export function createReportSessionAgent(deps) {
         createPreviewReportTool({
             gateway,
             resolveWorkspaceRoot,
+            threads,
             ...(makeResolver ? { makeResolver } : {}),
             ...(resolvePageAsset ? { resolvePageAsset } : {}),
             ...(makeSessionPages ? { makeSessionPages } : {}),
@@ -122,5 +125,6 @@ export function createReportSessionAgent(deps) {
         model,
         tools,
         maxIterations: REPORT_SESSION_MAX_ITERATIONS,
+        compaction: REPORT_SESSION_COMPACTION,
     };
 }

package/dist/app/chat-turn.d.ts

@@ -49,8 +49,6 @@ export type PrepareChatTurnResult = ({
  * inside {@link assembleMessages} (applied once to the new user input only).
  */
 export declare function prepareChatTurn(deps: PrepareChatTurnDeps, params: PrepareChatTurnParams): Promise<PrepareChatTurnResult>;
-/** The root loop of a chat turn compacts its view past this estimate, in tokens. */
-export declare const DEFAULT_CONVERSATION_BUDGET = 150000;
 export interface RunChatTurnDeps extends PrepareChatTurnDeps {
     /** The agent of a turn comes from the thread type, which only the preparation knows. */
     readonly agents: ThreadAgentResolver;
@@ -82,8 +80,6 @@ export interface RunOpenChatTurnParams {
     readonly startedAtMs?: number;
     /** The cache policy of the root loop. Absent gives {@link CONVERSATION_PROMPT_CACHE}. */
     readonly promptCache?: PromptCachePolicy;
-    /** The budget of the view of the root loop. Absent gives {@link DEFAULT_CONVERSATION_BUDGET}. */
-    readonly conversationBudget?: number;
 }
 /** The values of one whole turn. */
 export type RunChatTurnParams = OpenChatTurnParams & RunOpenChatTurnParams;

package/dist/app/chat-turn.js

@@ -73,24 +73,23 @@ export async function prepareChatTurn(deps, params) {
             }
         }
         else if (!existing.title || existing.title.length === 0) {
-            unwrapOrThrow(await store.updateTitle(threadId, deriveThreadTitle(userInput)));
+            unwrapOrThrow(await store.setAutoTitle(threadId, deriveThreadTitle(userInput)));
         }
     }
     catch (err) {
         logger.warn("title-seed failed (non-fatal)", logger.errorFields(err));
     }
-    const history = createThreadHistory(pool);
-    const { messages, userMessage, contextRecords } = await assembleMessages({
+    const assembled = await assembleMessages({
         threadId,
         threadType,
         analysisId,
         userInput,
         ...(await readTurnContext(pool, analysisId)),
-        history,
+        history: createThreadHistory(pool),
         workingMemory: createWorkingMemory(pool),
         ...(deps.logger ? { logger: deps.logger } : {}),
     });
-    return { kind: "ok", threadType, messages, userMessage, contextRecords };
+    return { kind: "ok", threadType, ...assembled };
 }
 /** The analysis context and the run activity of a turn. A failed read gives the fallback of its kind. */
 async function readTurnContext(pool, analysisId) {
@@ -98,8 +97,6 @@ async function readTurnContext(pool, analysisId) {
     const runActivityContext = await queryNonTerminalRunsByAnalysis(pool, analysisId, RUN_ACTIVITY_DETAIL_LIMIT).match((activity) => renderRunActivity(activity), () => renderRunActivityUnavailable());
     return { analysisContext: analysisState?.context ?? null, runActivityContext };
 }
-/** The root loop of a chat turn compacts its view past this estimate, in tokens. */
-export const DEFAULT_CONVERSATION_BUDGET = 150_000;
 /**
  * Open one chat turn: prepare it and resolve its agent. A refusal comes back before any row of the
  * turn exists, thus a host can answer it before it starts a stream.
@@ -142,22 +139,18 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
     const history = createThreadHistory(deps.pool, deps.logger);
     const recorder = createConversationDisplayRecorder({
         userText: userTextOf(prepared.userMessage),
-        topLevelCallPath: session.provenance.callPath,
+        agentId: agent.id,
         sink: params.emit,
     });
     // The groups that did not land yet, in the order of the turn. A failed write keeps them for the next write.
-    let pending = [
-        {
-            modelMessages: [prepared.userMessage, ...prepared.contextRecords],
-            displayMessages: recorder.takeOpening(),
-            ...(params.author === undefined ? {} : { author: params.author }),
-        },
-    ];
+    let pending = [];
     let startSeq;
     let storeError;
+    const opened = () => startSeq !== undefined || pending.length > 0;
     // A store fault never stops the turn: the error rides the result.
     const flush = async (close) => {
-        if (pending.length === 0 && close === undefined)
+        // A turn that ends before its user message was sent has no rows to close.
+        if (!opened() || (pending.length === 0 && close === undefined))
             return;
         const closing = close === undefined ? {} : { close };
         const write = startSeq === undefined ? { opening: pending[0], rounds: pending.slice(1), ...closing } : { startSeq, rounds: pending, ...closing };
@@ -170,12 +163,32 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
             logger.warn("chat turn write failed", { threadId: turn.threadId, op: error.op, ...logger.errorFields(error.cause) });
         });
     };
-    await flush();
+    const storeRound = async (round) => {
+        if (!opened() && round.messages[0] !== prepared.userMessage) {
+            // A turn-start compaction comes before the user message, thus its rows land before the turn opens. A later
+            // write cannot keep that order, thus a failed write is not tried again, and the next turn compacts again.
+            const appended = await history.appendTurn(turn.threadId, { modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) });
+            if (appended.isErr()) {
+                logger.warn("chat turn compaction write failed", {
+                    threadId: turn.threadId,
+                    op: appended.error.op,
+                    ...logger.errorFields(appended.error.cause),
+                });
+            }
+            return;
+        }
+        const author = params.author === undefined ? {} : { author: params.author };
+        pending.push(opened()
+            ? { modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) }
+            : { modelMessages: round.messages, displayMessages: recorder.takeOpening(), ...author });
+        await flush();
+    };
     const { ask } = params;
+    const compaction = compactionPolicy(deps, turn.analysisId, params, prepared.threadType, agent, recorder.emit);
     let outcome;
     let fallbackText;
     try {
-        const run = await runAgent(agent, prepared.messages, session, {
+        const run = await runAgent(agent, prepared.history, session, {
             provider: params.chat(recorder.emit),
             signal: params.signal,
             emit: recorder.emit,
@@ -183,17 +196,16 @@ async function runOpenTurn(deps, turn, prepared, agent, params) {
             usageRecorder: params.usageRecorder,
             toolOutputStore: createToolOutputStore(deps.pool),
             promptCache: params.promptCache ?? CONVERSATION_PROMPT_CACHE,
-            compaction: compactionPolicy(deps, turn.analysisId, params, prepared.threadType, agent, recorder.emit),
+            turnInput: [prepared.userMessage, ...prepared.contextRecords],
+            ...(compaction === undefined ? {} : { compaction }),
             ...(deps.logger === undefined ? {} : { logger: deps.logger }),
             ...(ask === undefined ? {} : { ask: (request) => ask(request, recorder.emit) }),
-            onRound: async (round) => {
-                pending.push({ modelMessages: round.messages, displayMessages: recorder.takeRound(round.messages) });
-                await flush();
-            },
+            onRound: storeRound,
         });
         outcome = run.finish.reason === "aborted" ? { status: "aborted", finish: run.finish } : { status: "done", finish: run.finish };
         // An abort can end the run inside an exchange, and the text of an exchange is a summary, and no reply.
-        fallbackText = finalText(run.messages.filter((message) => compactionExchangeOf(message) === undefined));
+        // The history ends on the reply of the last turn, thus only the messages of this run can give the text.
+        fallbackText = finalText(run.messages.slice(prepared.history.length).filter((message) => compactionExchangeOf(message) === undefined));
     }
     catch (cause) {
         // A provider failure that races an abort stays a failure, thus both facts must hold.
@@ -226,11 +238,13 @@ function userTextOf(message) {
 }
 const WORKING_MEMORY_TOOL_ID = "update_working_memory";
 function compactionPolicy(deps, analysisId, params, threadType, agent, emit) {
+    if (agent.compaction === undefined)
+        return undefined;
     // A report thread reads a frozen copy of the working memory, thus its agent declares no memory tool.
     const remembers = agent.tools.some((tool) => tool.id === WORKING_MEMORY_TOOL_ID);
     const workingMemory = createWorkingMemory(deps.pool);
     return {
-        budget: params.conversationBudget ?? DEFAULT_CONVERSATION_BUDGET,
+        ...agent.compaction,
         // A streaming provider sends each text delta with no source, thus a delta of the summary would show as a reply.
         provider: params.chat((event) => (event.type === "text-delta" ? undefined : emit(event))),
         request: remembers ? MEMORY_COMPACTION_REQUEST : SUMMARY_COMPACTION_REQUEST,

package/dist/app/message-assembly.d.ts

@@ -33,8 +33,8 @@ export interface AssembleMessagesArgs {
     readonly logger?: Logger;
 }
 export interface AssembledMessages {
-    /** The full message array for `runAgent`. */
-    readonly messages: LoopMessage[];
+    /** The view of the thread before the turn. */
+    readonly history: LoopMessage[];
     /** The sanitized user input as its own message — the genuine turn start. */
     readonly userMessage: ModelMessage;
     /** The context records after the user message. The turn stores them with the user message. */

package/dist/app/message-assembly.js

@@ -39,7 +39,7 @@ export async function assembleMessages(args) {
         content: normalizeUnicode(redactSecrets(args.userInput)),
     };
     const contextRecords = await contextRecordsFor(args, history);
-    return { messages: [...history, userMessage, ...contextRecords], userMessage, contextRecords };
+    return { history, userMessage, contextRecords };
 }
 /** The context records of one turn, in the order analysis context, run activity, working memory. */
 export async function contextRecordsFor(args, history) {

package/dist/contracts/chat-events.d.ts

@@ -1,15 +1,16 @@
 /**
- * Cortex-native chat-stream events — the harness wire vocabulary.
+ * Chat-stream events — the harness wire vocabulary.
  *
  * Distinct from the 15 `data-*` chat parts (`chat-parts.ts`): those are UI
  * presentation payloads a tool emits; these are the agent-loop stream events
- * the harness chat route frames as Cortex-native SSE. Together they are the
- * sole Cortex↔frontend wire contract — there is no AI SDK UI Message Stream
+ * the host chat route frames as SSE. Together they are the sole
+ * host↔frontend wire contract — there is no AI SDK UI Message Stream
  * Protocol and no translation layer.
  *
  * Every event carries `source` — the agent call chain at the point of
  * emission, derived from the harness `Session.callPath`.
  */
+import type { ChatPart } from "./chat-parts.js";
 import type { TokenUsageRollup } from "./usage.js";
 /**
  * Provenance stamped on every chat-stream event: the emitting agent and the
@@ -131,5 +132,11 @@ export interface ChatErrorEvent {
     reason?: string;
     source: EventSource;
 }
-/** The discriminated union of all Cortex-native chat-stream events. */
-export type CortexChatEvent = TextDeltaEvent | ToolStartedEvent | ToolFinishedEvent | FinishEvent | ChatErrorEvent;
+/** The discriminated union of all chat-stream events. */
+export type ChatEvent = TextDeltaEvent | ToolStartedEvent | ToolFinishedEvent | FinishEvent | ChatErrorEvent;
+/** A `data-*` part as a frame, with the source of its emitter when the emitter stamped one. */
+export type ChatPartFrame = ChatPart & {
+    source?: EventSource;
+};
+/** One frame of a chat stream or a run stream: a loop event or a `data-*` part. */
+export type ChatFrame = ChatEvent | ChatPartFrame;

package/dist/contracts/chat-events.js

@@ -1,10 +1,10 @@
 /**
- * Cortex-native chat-stream events — the harness wire vocabulary.
+ * Chat-stream events — the harness wire vocabulary.
  *
  * Distinct from the 15 `data-*` chat parts (`chat-parts.ts`): those are UI
  * presentation payloads a tool emits; these are the agent-loop stream events
- * the harness chat route frames as Cortex-native SSE. Together they are the
- * sole Cortex↔frontend wire contract — there is no AI SDK UI Message Stream
+ * the host chat route frames as SSE. Together they are the sole
+ * host↔frontend wire contract — there is no AI SDK UI Message Stream
  * Protocol and no translation layer.
  *
  * Every event carries `source` — the agent call chain at the point of

package/dist/contracts/chat-frame.d.ts

@@ -0,0 +1,41 @@
+import type { ChatDataPart, EmitEvent } from "../loop/types.js";
+import type { ChatStreamEvent } from "../providers/types.js";
+import type { ChatErrorEvent, ChatFrame, ChatPartFrame } from "./chat-events.js";
+import type { ChatMessage, MessagePart } from "./message.js";
+export type TurnTerminal = null | "finish" | {
+    error: ChatErrorEvent;
+};
+export interface ApplyFrameResult {
+    messages: ChatMessage[];
+    terminal: TurnTerminal;
+}
+export type ChatPartCheck = {
+    readonly ok: true;
+    readonly frame: ChatPartFrame;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * The frame of one emitted event, or `null` for `iteration` and `done`. A frame of a sub-agent keeps its source, thus a
+ * consumer can filter it. A `text-delta` has no source, thus its frame gets `fallbackSource`, the source of the root agent.
+ * A part frame is not checked here: {@link checkChatPart} checks it where it arrives.
+ */
+export declare function toChatFrame(event: EmitEvent | ChatStreamEvent | ChatDataPart, fallbackSource: EmitEvent["source"]): ChatFrame | null;
+/**
+ * Check a part frame against the schema of its type, one time, where it arrives. The schema drops a field that it
+ * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it. The
+ * source is checked for each type, because {@link isRootFrame} reads its call path.
+ */
+export declare function checkChatPart(frame: ChatPartFrame): ChatPartCheck;
+/** A frame of the root agent of a chat turn, whose call path is `[agent.id]`. A longer path is a sub-agent. */
+export declare function isRootFrame(frame: ChatFrame): boolean;
+/**
+ * The key that a part reconciles on: a tool call by its call id, and a part of a `reconciling` type by its type and
+ * id. A part with no key always appends. The type is part of the key, because an id is unique only in its own type.
+ */
+export declare function reconcileKey(part: MessagePart): string | undefined;
+/** Add a part, or replace the part with the same {@link reconcileKey} in the position of that part. */
+export declare function upsertPart(parts: readonly MessagePart[], part: MessagePart): MessagePart[];
+/** Apply one frame to the messages of a live turn, with no change to the input. A frame of a sub-agent changes nothing. */
+export declare function applyChatFrame(messages: ChatMessage[], frame: ChatFrame, assistantId: string): ApplyFrameResult;

package/dist/contracts/chat-frame.js

@@ -0,0 +1,173 @@
+// The one translation path of a chat stream. Browser-safe: each import from outside `contracts/` is a type import.
+import { isReconciling, PART_REGISTRY } from "./part-registry.js";
+import { EventSourceSchema } from "./schemas/chat-events.js";
+import { ChatPartSchema } from "./schemas/chat-parts.js";
+function toSource(source) {
+    return { agentId: source.agentId, callPath: [...source.callPath] };
+}
+/**
+ * The frame of one emitted event, or `null` for `iteration` and `done`. A frame of a sub-agent keeps its source, thus a
+ * consumer can filter it. A `text-delta` has no source, thus its frame gets `fallbackSource`, the source of the root agent.
+ * A part frame is not checked here: {@link checkChatPart} checks it where it arrives.
+ */
+export function toChatFrame(event, fallbackSource) {
+    switch (event.type) {
+        case "iteration":
+        case "done":
+            return null;
+        case "tool-started":
+            return {
+                type: "tool-started",
+                toolUseId: event.toolUseId,
+                name: event.name,
+                ...(event.detail === undefined ? {} : { detail: event.detail }),
+                source: toSource(event.source),
+            };
+        case "tool-finished":
+            return {
+                type: "tool-finished",
+                toolUseId: event.toolUseId,
+                name: event.name,
+                outcome: event.outcome,
+                ...(event.detail === undefined ? {} : { detail: event.detail }),
+                ...(event.durationMs === undefined ? {} : { durationMs: event.durationMs }),
+                source: toSource(event.source),
+            };
+        case "text-delta":
+            return { type: "text-delta", text: event.text, source: toSource(fallbackSource) };
+        default: {
+            // A `ChatDataPart`, whose payload the emitter types as `unknown`. The wire part is flat: `{ type, ...data }`.
+            // The cast names the frame that the type claims. `checkChatPart` is the check.
+            const data = (event.data ?? {});
+            return { ...data, type: event.type, ...(event.source === undefined ? {} : { source: toSource(event.source) }) };
+        }
+    }
+}
+/**
+ * Check a part frame against the schema of its type, one time, where it arrives. The schema drops a field that it
+ * does not know. A type that the registry does not know passes unchanged, because a newer emitter can send it. The
+ * source is checked for each type, because {@link isRootFrame} reads its call path.
+ */
+export function checkChatPart(frame) {
+    const { source, ...part } = frame;
+    if (source !== undefined) {
+        const checkedSource = EventSourceSchema.safeParse(source);
+        if (!checkedSource.success)
+            return { ok: false, error: checkedSource.error.message };
+    }
+    if (!Object.hasOwn(PART_REGISTRY, frame.type))
+        return { ok: true, frame };
+    const parsed = ChatPartSchema.safeParse(part);
+    if (!parsed.success)
+        return { ok: false, error: parsed.error.message };
+    return { ok: true, frame: source === undefined ? parsed.data : { ...parsed.data, source } };
+}
+/** A frame of the root agent of a chat turn, whose call path is `[agent.id]`. A longer path is a sub-agent. */
+export function isRootFrame(frame) {
+    return frame.source === undefined || frame.source.callPath.length <= 1;
+}
+/**
+ * The key that a part reconciles on: a tool call by its call id, and a part of a `reconciling` type by its type and
+ * id. A part with no key always appends. The type is part of the key, because an id is unique only in its own type.
+ */
+export function reconcileKey(part) {
+    if (part.type === "tool-call")
+        return `tool-call:${part.toolCallId}`;
+    if (part.type === "text" || !Object.hasOwn(PART_REGISTRY, part.type) || !isReconciling(part.type))
+        return undefined;
+    return "id" in part && typeof part.id === "string" ? `${part.type}:${part.id}` : undefined;
+}
+/** Add a part, or replace the part with the same {@link reconcileKey} in the position of that part. */
+export function upsertPart(parts, part) {
+    const key = reconcileKey(part);
+    const index = key === undefined ? -1 : parts.findIndex((candidate) => reconcileKey(candidate) === key);
+    if (index === -1)
+        return [...parts, part];
+    const next = parts.slice();
+    next[index] = part;
+    return next;
+}
+/** Apply one frame to the messages of a live turn, with no change to the input. A frame of a sub-agent changes nothing. */
+export function applyChatFrame(messages, frame, assistantId) {
+    if (!isRootFrame(frame))
+        return { messages, terminal: null };
+    if (frame.type === "finish") {
+        return {
+            messages: frame.turnUsage === undefined ? messages : stampUsage(messages, assistantId, frame.turnUsage),
+            terminal: "finish",
+        };
+    }
+    if (frame.type === "error") {
+        return { messages, terminal: { error: frame } };
+    }
+    const partFrame = frame;
+    const next = updateAssistant(messages, assistantId, (parts) => applyPartFrame(parts, partFrame));
+    return { messages: next, terminal: null };
+}
+function applyPartFrame(parts, frame) {
+    switch (frame.type) {
+        case "text-delta":
+            return mergeTextDelta(parts, frame.text);
+        case "tool-started":
+            return [
+                ...parts,
+                {
+                    type: "tool-call",
+                    toolCallId: frame.toolUseId,
+                    toolName: frame.name,
+                    ...(frame.detail === undefined ? {} : { detail: frame.detail }),
+                },
+            ];
+        case "tool-finished": {
+            const finished = {
+                type: "tool-call",
+                toolCallId: frame.toolUseId,
+                toolName: frame.name,
+                outcome: frame.outcome,
+                ...(frame.detail === undefined ? {} : { detail: frame.detail }),
+                ...(frame.durationMs === undefined ? {} : { durationMs: frame.durationMs }),
+            };
+            let started = false;
+            const next = parts.map((p) => {
+                if (p.type !== "tool-call" || p.toolCallId !== frame.toolUseId)
+                    return p;
+                started = true;
+                return { ...p, ...finished };
+            });
+            // The stored transcript keeps a call whose start never arrived, thus a live view keeps it too.
+            return started ? next : [...parts, finished];
+        }
+        default: {
+            // The source routes the frame, and it is not a field of the part. A rest type does not distribute over the
+            // union of the part frames, thus the cast names the part that remains.
+            const { source: _source, ...part } = frame;
+            return upsertPart(parts, part);
+        }
+    }
+}
+function mergeTextDelta(parts, delta) {
+    const last = parts[parts.length - 1];
+    if (last && last.type === "text") {
+        const merged = { type: "text", text: last.text + delta };
+        return [...parts.slice(0, -1), merged];
+    }
+    return [...parts, { type: "text", text: delta }];
+}
+function stampUsage(messages, assistantId, usage) {
+    const idx = messages.findIndex((m) => m.id === assistantId);
+    const message = messages[idx];
+    if (message === undefined)
+        return messages;
+    const next = messages.slice();
+    next[idx] = { ...message, usage };
+    return next;
+}
+function updateAssistant(messages, assistantId, updater) {
+    const idx = messages.findIndex((m) => m.id === assistantId);
+    const existing = messages[idx];
+    if (existing === undefined)
+        return [...messages, { id: assistantId, role: "assistant", parts: updater([]) }];
+    const next = messages.slice();
+    next[idx] = { ...existing, parts: updater(existing.parts) };
+    return next;
+}

package/dist/contracts/chat-parts.d.ts

@@ -1,6 +1,6 @@
 /**
- * Cortex chat data parts — custom parts emitted via writer.write() / writer.custom()
- * that flow through the chat stream and are rendered by the frontend.
+ * Chat data parts — the `data-*` parts that a tool or a workflow emits, and that
+ * a surface renders from the chat stream or the run stream.
  *
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),
@@ -22,8 +22,16 @@ export interface PlanStep {
     resources?: {
         cpu: number;
         memoryGb: number;
+        gpu?: {
+            count: number;
+        };
     };
     maxSteps: number;
+    track?: string;
+    step_type?: string;
+    acceptance_criteria?: string[];
+    constraints?: string[];
+    caveats?: string[];
 }
 export type PresentationContent = 
 /** `dataPath` (optional): an analysis-rooted CSV artifact path the host loads and injects as the
@@ -388,8 +396,12 @@ export interface CompactionPart {
     type: "data-compaction";
     id: string;
     status: "running" | "done" | "failed";
+    /** The input tokens that the provider reported for the last request before the compaction. */
     tokensBefore: number;
+    /** Only a part that an older harness stored carries it: an estimate of the view after the compaction. */
     tokensAfter?: number;
     durationMs?: number;
+    /** Before the user message of a turn, or before a later request. */
+    trigger?: "turn-start" | "mid-turn";
 }
-export type CortexChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart;
+export type ChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart;

package/dist/contracts/chat-parts.js

@@ -1,6 +1,6 @@
 /**
- * Cortex chat data parts — custom parts emitted via writer.write() / writer.custom()
- * that flow through the chat stream and are rendered by the frontend.
+ * Chat data parts — the `data-*` parts that a tool or a workflow emits, and that
+ * a surface renders from the chat stream or the run stream.
  *
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),

package/dist/contracts/index.d.ts

@@ -2,16 +2,18 @@ export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel
 export type { OrganSystem } from "./organ-system.js";
 export { SEVERITIES, SeveritySchema } from "./severity.js";
 export type { Severity } from "./severity.js";
-export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, DagStatePart, StepPhase, StepActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, CortexChatPart, } from "./chat-parts.js";
-export type { EventSource, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, CortexChatEvent } from "./chat-events.js";
+export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, DagStatePart, StepPhase, StepActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, ChatPart, } from "./chat-parts.js";
+export type { EventSource, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export type { DataProfileAxis, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileCoverage, DataProfileDimension, DataProfileFile, DataProfileGroup, DataProfileGroupSlot, DataProfileInputSignature, DataProfileKind, DataProfileLifecycleStatus, DataProfileMemberAnnotation, DataProfileObservation, DataProfileOrganism, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileResult, DataProfileSubjectSource, } from "./data-profile.js";
 export { DIMENSION_CATEGORIES, DIMENSION_CATEGORY_IDS, DIMENSION_PROBE_IDS, DIMENSION_PROBES, GROUP_CATEGORIES, GROUP_CATEGORY_IDS, GROUP_ROLE_IDS, GROUP_ROLES, PROBE_OUTCOME_IDS, dimensionCategoryEntry, dimensionScope, groupCategoryEntry, } from "./profile-vocabulary.js";
 export type { DimensionCategory, DimensionCategoryEntry, DimensionProbe, DimensionProbeEntry, DimensionScope, DimensionTreatment, GroupCategory, GroupCategoryEntry, GroupRole, GroupRoleEntry, ProbeOutcome, } from "./profile-vocabulary.js";
-export type { TextPart, ToolCallPart, CortexPart, CortexMessage } from "./message.js";
+export type { TextPart, ToolCallPart, MessagePart, ChatMessage } from "./message.js";
+export { toChatFrame, applyChatFrame, checkChatPart } from "./chat-frame.js";
+export type { TurnTerminal, ApplyFrameResult, ChatPartCheck } from "./chat-frame.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
-export type { CortexChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./part-registry.js";
+export type { ChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
 export type { AnalogyCoverage, AnalogyReport, AnalogyReportError, AnalogicalReasonerOutput } from "./analogy-report.js";
 export { buildReportSessionUrl, reportSessionResourceId } from "./content-url.js";

package/dist/contracts/index.js

@@ -2,6 +2,7 @@ export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel
 export { SEVERITIES, SeveritySchema } from "./severity.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export { DIMENSION_CATEGORIES, DIMENSION_CATEGORY_IDS, DIMENSION_PROBE_IDS, DIMENSION_PROBES, GROUP_CATEGORIES, GROUP_CATEGORY_IDS, GROUP_ROLE_IDS, GROUP_ROLES, PROBE_OUTCOME_IDS, dimensionCategoryEntry, dimensionScope, groupCategoryEntry, } from "./profile-vocabulary.js";
+export { toChatFrame, applyChatFrame, checkChatPart } from "./chat-frame.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
 export { buildReportSessionUrl, reportSessionResourceId } from "./content-url.js";

package/dist/contracts/message.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cortex-owned chat message types — the wire shape, the in-memory shape,
+ * Chat message types — the wire shape, the in-memory shape,
  * and the public API for everything the chat path exchanges.
  *
  * No AI SDK types appear here or anywhere else in the package. The
@@ -7,7 +7,7 @@
  * narrows the union member without any `as` cast.
  */
 import type { ToolCallDetail, ToolCallOutcome } from "./chat-events.js";
-import type { CortexChatPart } from "./chat-parts.js";
+import type { ChatPart } from "./chat-parts.js";
 import type { TokenUsageRollup } from "./usage.js";
 /** A plain assistant/user text run. */
 export interface TextPart {
@@ -38,14 +38,16 @@ export interface ToolCallPart {
     outcome?: ToolCallOutcome;
     /** See {@link ToolCallDetail}. Absent when no detail was produced. */
     detail?: ToolCallDetail;
+    /** The time in milliseconds around the dispatch of the call, from `tool-finished`. Absent when no measurement was taken. */
+    durationMs?: number;
 }
 /** The discriminated union of every part the chat path can carry. */
-export type CortexPart = TextPart | ToolCallPart | CortexChatPart;
+export type MessagePart = TextPart | ToolCallPart | ChatPart;
 /** A single chat message — user, assistant, or system. */
-export interface CortexMessage {
+export interface ChatMessage {
     id: string;
     role: "user" | "assistant" | "system";
-    parts: CortexPart[];
+    parts: MessagePart[];
     /**
      * Set when this message's production was cut off by a client abort, so the UI
      * can badge it. Absent means not interrupted — the field is optional so every

package/dist/contracts/message.js

@@ -1,5 +1,5 @@
 /**
- * Cortex-owned chat message types — the wire shape, the in-memory shape,
+ * Chat message types — the wire shape, the in-memory shape,
  * and the public API for everything the chat path exchanges.
  *
  * No AI SDK types appear here or anywhere else in the package. The