@inflexa-ai/harness 0.39.1 → 0.40.0

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>>;

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

@@ -204,7 +204,6 @@ export declare const DagStatePartSchema: z.ZodObject<{
 export declare const StepPhaseSchema: z.ZodEnum<{
     failed: "failed";
     complete: "complete";
-    warning: "warning";
     "sandbox-init": "sandbox-init";
     executing: "executing";
     "generating-metadata": "generating-metadata";
@@ -212,6 +211,7 @@ export declare const StepPhaseSchema: z.ZodEnum<{
     indexing: "indexing";
     persisting: "persisting";
     retrying: "retrying";
+    warning: "warning";
 }>;
 export declare const StepActivityPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-step-activity">;
@@ -221,7 +221,6 @@ export declare const StepActivityPartSchema: z.ZodObject<{
     phase: z.ZodEnum<{
         failed: "failed";
         complete: "complete";
-        warning: "warning";
         "sandbox-init": "sandbox-init";
         executing: "executing";
         "generating-metadata": "generating-metadata";
@@ -229,6 +228,7 @@ export declare const StepActivityPartSchema: z.ZodObject<{
         indexing: "indexing";
         persisting: "persisting";
         retrying: "retrying";
+        warning: "warning";
     }>;
     activity: z.ZodString;
 }, z.core.$strip>;
@@ -260,9 +260,9 @@ export declare const StepOutputFileSchema: z.ZodObject<{
     fileType: z.ZodEnum<{
         output: "output";
         summary: "summary";
-        log: "log";
-        figure: "figure";
         script: "script";
+        figure: "figure";
+        log: "log";
         notebook: "notebook";
     }>;
     description: z.ZodString;
@@ -279,9 +279,9 @@ export declare const StepOutputPartSchema: z.ZodObject<{
         fileType: z.ZodEnum<{
             output: "output";
             summary: "summary";
-            log: "log";
-            figure: "figure";
             script: "script";
+            figure: "figure";
+            log: "log";
             notebook: "notebook";
         }>;
         description: z.ZodString;
@@ -473,6 +473,18 @@ export declare const ReportRenderedPartSchema: z.ZodObject<{
     renderedAt: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const CompactionPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-compaction">;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        done: "done";
+        running: "running";
+    }>;
+    tokensBefore: z.ZodNumber;
+    tokensAfter: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"data-presentation">;
     id: z.ZodString;
@@ -592,7 +604,6 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     phase: z.ZodEnum<{
         failed: "failed";
         complete: "complete";
-        warning: "warning";
         "sandbox-init": "sandbox-init";
         executing: "executing";
         "generating-metadata": "generating-metadata";
@@ -600,6 +611,7 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         indexing: "indexing";
         persisting: "persisting";
         retrying: "retrying";
+        warning: "warning";
     }>;
     activity: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
@@ -627,9 +639,9 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         fileType: z.ZodEnum<{
             output: "output";
             summary: "summary";
-            log: "log";
-            figure: "figure";
             script: "script";
+            figure: "figure";
+            log: "log";
             notebook: "notebook";
         }>;
         description: z.ZodString;
@@ -765,4 +777,15 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     id: z.ZodString;
     renderedAt: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-compaction">;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        done: "done";
+        running: "running";
+    }>;
+    tokensBefore: z.ZodNumber;
+    tokensAfter: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>], "type">;

package/dist/contracts/schemas/chat-parts.js

@@ -299,6 +299,15 @@ export const ReportRenderedPartSchema = z.object({
     renderedAt: z.string(),
     title: z.string().optional(),
 });
+// ── Compaction ──────────────────────────────────────────────────────
+export const CompactionPartSchema = z.object({
+    type: z.literal("data-compaction"),
+    id: z.string(),
+    status: z.enum(["running", "done", "failed"]),
+    tokensBefore: z.number().int().nonnegative(),
+    tokensAfter: z.number().int().nonnegative().optional(),
+    durationMs: z.number().int().nonnegative().optional(),
+});
 // ── Union ───────────────────────────────────────────────────────────
 export const CortexChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
@@ -320,4 +329,5 @@ export const CortexChatPartSchema = z.discriminatedUnion("type", [
     RunFailedPartSchema,
     ChildSessionStartedPartSchema,
     ReportRenderedPartSchema,
+    CompactionPartSchema,
 ]);