@inflexa-ai/harness 0.39.2 → 0.41.0

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

@@ -1,38 +1,10 @@
 /**
- * Chat-turn message assembly.
+ * Chat-turn message assembly: the view of the latest compaction marker, the user message, and then the
+ * context records. A kind gets a new record only when the view holds none of that kind, or when the hash
+ * of its text differs. The root loop compacts the view past its budget.
  *
- * Builds the `messages` array `runAgent` receives for one conversation turn:
- *
- *   [ ...loadRecent(threadId, budget)            ← stable, cacheable prefix
- *     {user: cortex_analysis_state.context},     ← tail
- *     {user: runActivityContext},                 ← tail
- *     {user: render(workingMemory)},             ← tail, `conversation` thread only
- *     {user: normalizeUnicode(redactSecrets(input))} ]  ← tail
- *
- * `system + tools + history` is the cacheable prefix — it only extends
- * turn-to-turn. Run activity, working memory, and analysis context go in the
- * **tail** as `user` messages: they change every turn, so a system-message
- * placement would bust the Anthropic cache prefix.
- *
- * A `report` thread does not get the working-memory tail. The spawn copies the
- * working-memory render into the child transcript at the anchor. A live render
- * sees state past that anchor, and that breaks the knowledge cap of a report
- * session. The analysis context and the run activity stay on both thread types.
- *
- * The history window of a `report` thread also keeps the first turn. That turn
- * is the seed, and it is the one record of the brief and of the copied render.
- * The window evicts the oldest turn first, thus a long session would drop its
- * own charter and keep only its tools. A `conversation` thread evicts as before,
- * because its live tail carries the working memory on each turn.
- *
- * Sanitization (`redactSecrets`, `normalizeUnicode`) is applied **once**, to
- * the new user input only — never to history, assistant messages, tool
- * results, the analysis context, or the rendered working memory.
- *
- * The returned `userMessage` is the sanitized user input on its own — the
- * route persists `[userMessage, ...loop output]` via `appendTurn`, so the
- * tail injections (ephemeral, re-derived each turn) are never written to the
- * thread store.
+ * The view of a `report` thread keeps the first turn, because that turn is the seed: the one record of
+ * the brief and of the copied working memory.
  */
 import type { ModelMessage } from "ai";
 import type { Logger } from "../lib/logger.js";
@@ -40,16 +12,10 @@ import type { LoopMessage } from "../loop/types.js";
 import type { ThreadHistory } from "../memory/thread-history.js";
 import type { ThreadType } from "../memory/thread-store.js";
 import type { WorkingMemoryStore } from "../memory/working-memory.js";
-/**
- * Token budget for the `loadRecent` history window. Sized to leave headroom
- * under the model context window for the system prompt, tool definitions,
- * the three tail messages, and the output budget.
- */
-export declare const DEFAULT_HISTORY_TOKEN_BUDGET = 120000;
 export interface AssembleMessagesArgs {
     /** The conversation thread — a UI-generated UUID, never the analysisId. */
     readonly threadId: string;
-    /** The type of the thread. A `report` thread drops the working-memory tail, and its window keeps the seed. */
+    /** The type of the thread. A `report` thread gets no working-memory record, and its view keeps the seed. */
     readonly threadType: ThreadType;
     /** The analysis scope — keys working memory and (separately) the context. */
     readonly analysisId: string;
@@ -57,29 +23,27 @@ export interface AssembleMessagesArgs {
     readonly userInput: string;
     /** `cortex_analysis_state.context`, already read by the route. `null` when absent. */
     readonly analysisContext: string | null;
-    /** Fresh, non-persisted analysis-wide run activity rendered by chat-turn preparation. */
+    /** The analysis-wide run activity that chat-turn preparation rendered for this turn. */
     readonly runActivityContext: string;
-    /** The conversation message store — supplies the history window. */
+    /** The conversation message store — supplies the view of the thread. */
     readonly history: ThreadHistory;
-    /** The working-memory store — rendered into the tail. */
+    /** The working-memory store — rendered into a context record. */
     readonly workingMemory: WorkingMemoryStore;
-    /** History-window token budget. Defaults to {@link DEFAULT_HISTORY_TOKEN_BUDGET}. */
-    readonly tokenBudget?: number;
     /** Diagnostic seam for the history repair record; omitted falls back to no-op. */
     readonly logger?: Logger;
 }
 export interface AssembledMessages {
     /** The full message array for `runAgent`. */
     readonly messages: LoopMessage[];
-    /**
-     * The sanitized user input as its own message — the genuine turn start.
-     * The route persists this plus the loop's output; the tail injections are
-     * not persisted.
-     */
+    /** 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. */
+    readonly contextRecords: readonly ModelMessage[];
 }
 /**
- * Assemble the message array for one chat turn. Async — it reads the history
- * window and renders working memory.
+ * Assemble the message array for one chat turn. Async — it reads the view of
+ * the thread and renders working memory.
  */
 export declare function assembleMessages(args: AssembleMessagesArgs): Promise<AssembledMessages>;
+/** The context records of one turn, in the order analysis context, run activity, working memory. */
+export declare function contextRecordsFor(args: Pick<AssembleMessagesArgs, "threadType" | "analysisId" | "analysisContext" | "runActivityContext" | "workingMemory">, history: readonly ModelMessage[]): Promise<ModelMessage[]>;

package/dist/app/message-assembly.js

@@ -1,66 +1,33 @@
 /**
- * Chat-turn message assembly.
+ * Chat-turn message assembly: the view of the latest compaction marker, the user message, and then the
+ * context records. A kind gets a new record only when the view holds none of that kind, or when the hash
+ * of its text differs. The root loop compacts the view past its budget.
  *
- * Builds the `messages` array `runAgent` receives for one conversation turn:
- *
- *   [ ...loadRecent(threadId, budget)            ← stable, cacheable prefix
- *     {user: cortex_analysis_state.context},     ← tail
- *     {user: runActivityContext},                 ← tail
- *     {user: render(workingMemory)},             ← tail, `conversation` thread only
- *     {user: normalizeUnicode(redactSecrets(input))} ]  ← tail
- *
- * `system + tools + history` is the cacheable prefix — it only extends
- * turn-to-turn. Run activity, working memory, and analysis context go in the
- * **tail** as `user` messages: they change every turn, so a system-message
- * placement would bust the Anthropic cache prefix.
- *
- * A `report` thread does not get the working-memory tail. The spawn copies the
- * working-memory render into the child transcript at the anchor. A live render
- * sees state past that anchor, and that breaks the knowledge cap of a report
- * session. The analysis context and the run activity stay on both thread types.
- *
- * The history window of a `report` thread also keeps the first turn. That turn
- * is the seed, and it is the one record of the brief and of the copied render.
- * The window evicts the oldest turn first, thus a long session would drop its
- * own charter and keep only its tools. A `conversation` thread evicts as before,
- * because its live tail carries the working memory on each turn.
- *
- * Sanitization (`redactSecrets`, `normalizeUnicode`) is applied **once**, to
- * the new user input only — never to history, assistant messages, tool
- * results, the analysis context, or the rendered working memory.
- *
- * The returned `userMessage` is the sanitized user input on its own — the
- * route persists `[userMessage, ...loop output]` via `appendTurn`, so the
- * tail injections (ephemeral, re-derived each turn) are never written to the
- * thread store.
+ * The view of a `report` thread keeps the first turn, because that turn is the seed: the one record of
+ * the brief and of the copied working memory.
  */
 import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
-import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
+import { contextRecordMessage, contextRecordOf } from "../memory/ai-sdk-message-storage.js";
+import { answerUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { normalizeUnicode, redactSecrets } from "../input-sanitization.js";
 /**
- * Token budget for the `loadRecent` history window. Sized to leave headroom
- * under the model context window for the system prompt, tool definitions,
- * the three tail messages, and the output budget.
- */
-export const DEFAULT_HISTORY_TOKEN_BUDGET = 120_000;
-/**
- * Assemble the message array for one chat turn. Async — it reads the history
- * window and renders working memory.
+ * Assemble the message array for one chat turn. Async — it reads the view of
+ * the thread and renders working memory.
  */
 export async function assembleMessages(args) {
-    const budget = args.tokenBudget ?? DEFAULT_HISTORY_TOKEN_BUDGET;
-    const history = unwrapOrThrow(await args.history.loadRecent(args.threadId, budget, { keepFirstTurn: args.threadType === "report" }));
+    const history = unwrapOrThrow(await args.history.loadRecent(args.threadId, { keepFirstTurn: args.threadType === "report" }));
     // Read-side safety net for the wire contract: every tool call carries a
     // result. The loop upholds it at every exit, but the store outlives any one
     // writer — a row an older build wrote, or a hand-edited database, can carry
     // an unanswered call, and the provider boundary then refuses the WHOLE
-    // transcript on every turn: the thread is wedged forever. Stripping the
-    // orphan here degrades one message instead. The warning is the only account
-    // a reader gets that the stored thread and the assembled one differ.
-    const repaired = stripUnansweredToolCalls(history);
+    // transcript on every turn: the thread is wedged forever. The fix inserts the
+    // same not-run result the loop gives, in place, so no stored message changes
+    // and the prefix stays identical across turns. The warning is the only
+    // account a reader gets that the stored thread and the assembled one differ.
+    const repaired = answerUnansweredToolCalls(history);
     if (repaired.length > 0) {
-        (args.logger ?? createNoopLogger()).named("assembly").warn("unanswered tool calls stripped from thread history", {
+        (args.logger ?? createNoopLogger()).named("assembly").warn("unanswered tool calls answered in thread history", {
             threadId: args.threadId,
             toolCallIds: repaired.map((d) => d.toolCallId),
             tools: repaired.map((d) => d.toolName),
@@ -71,27 +38,33 @@ export async function assembleMessages(args) {
         role: "user",
         content: normalizeUnicode(redactSecrets(args.userInput)),
     };
-    const tail = [];
-    // Analysis context — platform-supplied, trusted. Injected only when present.
+    const contextRecords = await contextRecordsFor(args, history);
+    return { messages: [...history, userMessage, ...contextRecords], userMessage, contextRecords };
+}
+/** The context records of one turn, in the order analysis context, run activity, working memory. */
+export async function contextRecordsFor(args, history) {
+    const texts = [];
     if (args.analysisContext && args.analysisContext.trim().length > 0) {
-        tail.push({
-            role: "user",
-            content: `[Analysis Context]\n${args.analysisContext}`,
-        });
+        texts.push(["analysis-context", `[Analysis Context]\n${args.analysisContext}`]);
     }
-    tail.push({
-        role: "user",
-        content: args.runActivityContext,
-    });
-    // Working memory — agent-authored and trusted. A `conversation` thread
-    // always gets it, because the render names each section even when it is
-    // empty. A `report` thread reads the frozen copy in its seed message.
+    texts.push(["run-activity", args.runActivityContext]);
+    // A `report` thread reads the frozen copy in its seed, because a live render sees state past its anchor.
     if (args.threadType !== "report") {
-        tail.push({
-            role: "user",
-            content: unwrapOrThrow(await args.workingMemory.render(args.analysisId)),
-        });
+        const render = unwrapOrThrow(await args.workingMemory.render(args.analysisId));
+        // An emptied memory needs a record of its own, or the last full copy would read as the current state.
+        texts.push(["working-memory", `[Working Memory]\n${render.length > 0 ? render : "The working memory is empty."}`]);
+    }
+    const latestHash = new Map();
+    for (const message of history) {
+        const record = contextRecordOf(message);
+        if (record !== undefined)
+            latestHash.set(record.kind, record.hash);
+    }
+    const records = [];
+    for (const [kind, text] of texts) {
+        const record = contextRecordMessage(kind, text);
+        if (contextRecordOf(record)?.hash !== latestHash.get(kind))
+            records.push(record);
     }
-    tail.push(userMessage);
-    return { messages: [...history, ...tail], userMessage };
+    return records;
 }

package/dist/app/run-activity.d.ts

@@ -1,13 +1,11 @@
 /**
- * Ephemeral conversation-tail projection of non-terminal analysis runs.
- *
- * This is derived operational state, not memory: callers render it afresh for
- * each turn and never persist it to the thread.
+ * The Run Activity record of a chat turn. The render holds no time of the call, thus a set of runs
+ * that does not change gives byte-identical text, and the turn stores no new record.
  */
 import type { RunPage } from "../state/runs.js";
 /** Maximum detailed run rows paid into every conversation turn. */
 export declare const RUN_ACTIVITY_DETAIL_LIMIT = 20;
-/** Render the bounded run-activity snapshot injected into a conversation tail. */
-export declare function renderRunActivity(activity: RunPage, nowMs?: number): string;
+/** Render the bounded run-activity snapshot of a conversation turn. */
+export declare function renderRunActivity(activity: RunPage): string;
 /** Render an honest degraded state when the activity projection cannot be read. */
 export declare function renderRunActivityUnavailable(): string;

package/dist/app/run-activity.js

@@ -1,36 +1,16 @@
 /**
- * Ephemeral conversation-tail projection of non-terminal analysis runs.
- *
- * This is derived operational state, not memory: callers render it afresh for
- * each turn and never persist it to the thread.
+ * The Run Activity record of a chat turn. The render holds no time of the call, thus a set of runs
+ * that does not change gives byte-identical text, and the turn stores no new record.
  */
 /** Maximum detailed run rows paid into every conversation turn. */
 export const RUN_ACTIVITY_DETAIL_LIMIT = 20;
-function compactAge(startedAt, nowMs) {
-    const startedMs = Date.parse(startedAt);
-    if (!Number.isFinite(startedMs))
-        return "unknown age";
-    const elapsedSeconds = Math.max(0, Math.floor((nowMs - startedMs) / 1_000));
-    if (elapsedSeconds < 60)
-        return `${elapsedSeconds}s ago`;
-    const elapsedMinutes = Math.floor(elapsedSeconds / 60);
-    if (elapsedMinutes < 60)
-        return `${elapsedMinutes}m ago`;
-    const elapsedHours = Math.floor(elapsedMinutes / 60);
-    if (elapsedHours < 24)
-        return `${elapsedHours}h ago`;
-    return `${Math.floor(elapsedHours / 24)}d ago`;
-}
-function renderRows(label, rows, nowMs) {
+function renderRows(label, rows) {
     if (rows.length === 0)
         return [];
-    return [
-        `${label}:`,
-        ...rows.map((run) => `- runId: ${run.runId} | planId: ${run.planId ?? "none"} | startedAt: ${run.startedAt} | started: ${compactAge(run.startedAt, nowMs)}`),
-    ];
+    return [`${label}:`, ...rows.map((run) => `- runId: ${run.runId} | planId: ${run.planId ?? "none"} | startedAt: ${run.startedAt}`)];
 }
-/** Render the bounded run-activity snapshot injected into a conversation tail. */
-export function renderRunActivity(activity, nowMs = Date.now()) {
+/** Render the bounded run-activity snapshot of a conversation turn. */
+export function renderRunActivity(activity) {
     const lines = ["[Run Activity]"];
     if (activity.total === 0) {
         lines.push("No runs are currently running or suspended.");
@@ -38,7 +18,7 @@ export function renderRunActivity(activity, nowMs = Date.now()) {
     }
     const running = activity.runs.filter((run) => run.status === "running");
     const suspended = activity.runs.filter((run) => run.status === "suspended_insufficient_funds");
-    lines.push(...renderRows("Running", running, nowMs), ...renderRows("Suspended", suspended, nowMs));
+    lines.push(...renderRows("Running", running), ...renderRows("Suspended", suspended));
     const omitted = activity.total - activity.runs.length;
     if (omitted > 0) {
         lines.push(`Showing ${activity.runs.length} of ${activity.total} non-terminal runs; ${omitted} omitted. Use inspect_run to page the full list.`);

package/dist/app/spawn-report-session.d.ts

@@ -77,11 +77,10 @@ import type { EnsureSessionStateResult } from "./report-session-runtime.js";
  * The set is closed. `parent_not_found` covers an absent parent and an archived
  * one alike, because `getThread` filters the tombstone and a spawn into hidden
  * state is not permitted. `parent_not_a_conversation` keeps the tree flat: a
- * report session cannot spawn another. `empty_parent_transcript` refuses a
- * report on a parent that holds no messages, because such a report reports
- * nothing. `no_browser` refuses every spawn under a composition that gives no
- * route to a look: no eyes seam, no capture seam, and no configured browser
- * endpoint. It carries the line that explains the absent capability.
+ * report session cannot spawn another. `no_browser` refuses every spawn under
+ * a composition that gives no route to a look: no eyes seam, no capture seam,
+ * and no configured browser endpoint. It carries the line that explains the
+ * absent capability.
  */
 export type SpawnRefusal = {
     readonly type: "no_browser";
@@ -97,10 +96,6 @@ export type SpawnRefusal = {
     readonly op: string;
     readonly parentThreadId: string;
     readonly threadType: ThreadType;
-} | {
-    readonly type: "empty_parent_transcript";
-    readonly op: string;
-    readonly parentThreadId: string;
 };
 /** The paging inputs `listReportSessions` forwards to the thread listing. */
 export interface ReportSessionPaging {
@@ -237,8 +232,8 @@ export interface ReportSessionSpawn {
      * result on the ok channel, thus the outcome vocabulary holds no pin arm.
      *
      * Refused with a `SpawnRefusal`, no row written: a composition with no
-     * eyes, an absent or archived parent, a parent that is not a conversation,
-     * and a parent with no messages. A store refusal (`DbError`,
+     * eyes, an absent or archived parent, and a parent that is not a
+     * conversation. A store refusal (`DbError`,
      * `ThreadInputError`) passes through unchanged. A failed seed write purges
      * the child and returns the fault, thus no context-less thread survives.
      */

package/dist/app/spawn-report-session.js

@@ -264,12 +264,11 @@ export function createReportSessionSpawn(deps) {
             if (parent.threadType !== "conversation") {
                 return errAsync({ type: "parent_not_a_conversation", op: OP, parentThreadId, threadType: parent.threadType });
             }
-            return history.latestSeq(parentThreadId).andThen((anchor) => {
-                // `null` is a parent with no messages. A report on an empty transcript
-                // reports nothing, so the refusal is the correct answer.
-                if (anchor === null) {
-                    return errAsync({ type: "empty_parent_transcript", op: OP, parentThreadId });
-                }
+            return history.latestSeq(parentThreadId).andThen((latest) => {
+                // A turn appends after its loop, thus the first ask of a chat finds
+                // no row. The seed and the tail carry the context, not the parent
+                // transcript. `-1` is the point before seq 0.
+                const anchor = latest ?? -1;
                 // `total`, not the page length: N counts every existing report child,
                 // not the count on one page. Two concurrent spawns can compose one N.
                 // The result is two titles a user renames, and no identifier collides.

package/dist/app/synthesize-run.d.ts

@@ -17,6 +17,7 @@
 import type { Pool } from "pg";
 import type { SynthesisPhase } from "@inflexa-ai/harness/contracts/chat-parts.js";
 import type { RunSession } from "../auth/types.js";
+import type { ToolOutputStore } from "../loop/tool-output.js";
 import type { EmitFn } from "../loop/types.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
@@ -43,6 +44,8 @@ export interface SynthesizeRunDeps {
     readonly citationResolver: CitationResolver;
     /** LLM usage-accounting seam for the synthesizer loop; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /** The store of the synthesizer and reviewer loops and of their read tools. */
+    readonly toolOutputStore?: ToolOutputStore;
 }
 /** Optional fields for a progress update, mirroring the wire part. */
 export interface SynthesisProgressExtra {

package/dist/app/synthesize-run.js

@@ -49,6 +49,7 @@ export async function synthesizeRun(deps, params) {
             bioKeys,
             citationResolver,
             usageRecorder,
+            ...(deps.toolOutputStore ? { toolOutputStore: deps.toolOutputStore } : {}),
             summaries,
             planNarrative,
             runId,

package/dist/billing/usage-recorder.d.ts

@@ -6,10 +6,9 @@
  * telemetry every completed LLM call produces. The harness names no storage or
  * display technology — it emits records; the embedder decides where they land.
  *
- * The loop is the single delivery site (it sees every reply in both execution
- * modes and already holds the session), so a realization is wired once at the
- * composition root and reaches every `runAgent` invocation through the deps
- * bags. OSS default: `createNoopUsageRecorder` (`./noop-usage-recorder.ts`).
+ * Delivery sites: the loop's `accountForChatCall`, and the two direct
+ * `provider.chat` callers outside a loop — the ad hoc router and the analogy
+ * conversion. OSS default: `createNoopUsageRecorder` (`./noop-usage-recorder.ts`).
  */
 import type { ResultAsync } from "neverthrow";
 import type { Scope } from "../auth/types.js";

package/dist/billing/usage-recorder.js

@@ -6,9 +6,8 @@
  * telemetry every completed LLM call produces. The harness names no storage or
  * display technology — it emits records; the embedder decides where they land.
  *
- * The loop is the single delivery site (it sees every reply in both execution
- * modes and already holds the session), so a realization is wired once at the
- * composition root and reaches every `runAgent` invocation through the deps
- * bags. OSS default: `createNoopUsageRecorder` (`./noop-usage-recorder.ts`).
+ * Delivery sites: the loop's `accountForChatCall`, and the two direct
+ * `provider.chat` callers outside a loop — the ad hoc router and the analogy
+ * conversion. OSS default: `createNoopUsageRecorder` (`./noop-usage-recorder.ts`).
  */
 export {};

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

@@ -6,6 +6,7 @@
  *   Presentation:    data-presentation (agent-synthesized content),
  *                    data-plan (plan by id), data-file-reference (files by path)
  *   Approval:        data-ask (a tool's pending user-approval prompt)
+ *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree
@@ -382,4 +383,13 @@ export interface ReportRenderedPart {
     /** The title of the rendered document. */
     title?: string;
 }
-export type CortexChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart;
+/** One compaction of the thread: `running`, then `done` or `failed` under the same id. A reload shows it as a divider. */
+export interface CompactionPart {
+    type: "data-compaction";
+    id: string;
+    status: "running" | "done" | "failed";
+    tokensBefore: number;
+    tokensAfter?: number;
+    durationMs?: number;
+}
+export type CortexChatPart = 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

@@ -6,6 +6,7 @@
  *   Presentation:    data-presentation (agent-synthesized content),
  *                    data-plan (plan by id), data-file-reference (files by path)
  *   Approval:        data-ask (a tool's pending user-approval prompt)
+ *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree

package/dist/contracts/index.d.ts

@@ -2,7 +2,7 @@ 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, CortexChatPart, } from "./chat-parts.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 { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";

package/dist/contracts/part-registry.js

@@ -18,6 +18,7 @@ export const PART_REGISTRY = {
     "data-run-failed": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: false },
     "data-child-session-started": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-report-rendered": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
+    "data-compaction": { emitter: "conversation", consumer: "conversation", transient: true, reconciling: true },
 };
 export function isTransient(type) {
     return PART_REGISTRY[type].transient;

package/dist/contracts/report-blocks.d.ts

@@ -200,15 +200,15 @@ export declare const ChartAxesSchema: z.ZodObject<{
     x: z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         scale: z.ZodOptional<z.ZodEnum<{
-            linear: "linear";
             log: "log";
+            linear: "linear";
         }>>;
     }, z.core.$strict>>;
     y: z.ZodOptional<z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         scale: z.ZodOptional<z.ZodEnum<{
-            linear: "linear";
             log: "log";
+            linear: "linear";
         }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
@@ -297,15 +297,15 @@ export declare const ChartCompositionSchema: z.ZodObject<{
         x: z.ZodOptional<z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             scale: z.ZodOptional<z.ZodEnum<{
-                linear: "linear";
                 log: "log";
+                linear: "linear";
             }>>;
         }, z.core.$strict>>;
         y: z.ZodOptional<z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             scale: z.ZodOptional<z.ZodEnum<{
-                linear: "linear";
                 log: "log";
+                linear: "linear";
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
@@ -724,15 +724,15 @@ export declare const ChartBlockSchema: z.ZodObject<{
             x: z.ZodOptional<z.ZodObject<{
                 title: z.ZodOptional<z.ZodString>;
                 scale: z.ZodOptional<z.ZodEnum<{
-                    linear: "linear";
                     log: "log";
+                    linear: "linear";
                 }>>;
             }, z.core.$strict>>;
             y: z.ZodOptional<z.ZodObject<{
                 title: z.ZodOptional<z.ZodString>;
                 scale: z.ZodOptional<z.ZodEnum<{
-                    linear: "linear";
                     log: "log";
+                    linear: "linear";
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
@@ -1168,15 +1168,15 @@ export declare const ATOM_BLOCK_SCHEMAS: readonly [z.ZodObject<{
             x: z.ZodOptional<z.ZodObject<{
                 title: z.ZodOptional<z.ZodString>;
                 scale: z.ZodOptional<z.ZodEnum<{
-                    linear: "linear";
                     log: "log";
+                    linear: "linear";
                 }>>;
             }, z.core.$strict>>;
             y: z.ZodOptional<z.ZodObject<{
                 title: z.ZodOptional<z.ZodString>;
                 scale: z.ZodOptional<z.ZodEnum<{
-                    linear: "linear";
                     log: "log";
+                    linear: "linear";
                 }>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;