@inflexa-ai/harness 0.41.2 → 0.42.1

package/dist/contracts/part-registry.d.ts

@@ -1,5 +1,5 @@
-import type { CortexChatPart } from "./chat-parts.js";
-export type CortexChatPartType = CortexChatPart["type"];
+import type { ChatPart } from "./chat-parts.js";
+export type ChatPartType = ChatPart["type"];
 export type PartEmitter = "workflow" | "conversation";
 export type PartConsumer = "sidebar" | "conversation";
 export interface PartDescriptor {
@@ -12,7 +12,7 @@ export interface PartDescriptor {
     /** If true, multiple emissions share the same id — latest wins. */
     reconciling: boolean;
 }
-export declare const PART_REGISTRY: Record<CortexChatPartType, PartDescriptor>;
-export declare function isTransient(type: CortexChatPartType): boolean;
-export declare function isReconciling(type: CortexChatPartType): boolean;
-export declare function isSidebarPart(type: CortexChatPartType): boolean;
+export declare const PART_REGISTRY: Record<ChatPartType, PartDescriptor>;
+export declare function isTransient(type: ChatPartType): boolean;
+export declare function isReconciling(type: ChatPartType): boolean;
+export declare function isSidebarPart(type: ChatPartType): boolean;

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

@@ -1,5 +1,5 @@
 /**
- * Zod schemas for Cortex-native chat-stream events — validation at boundaries.
+ * Zod schemas for chat-stream events — validation at boundaries.
  */
 import { z } from "zod";
 export declare const EventSourceSchema: z.ZodObject<{
@@ -83,7 +83,7 @@ export declare const ChatErrorEventSchema: z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const CortexChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"text-delta">;
     text: z.ZodString;
     source: z.ZodObject<{

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

@@ -1,5 +1,5 @@
 /**
- * Zod schemas for Cortex-native chat-stream events — validation at boundaries.
+ * Zod schemas for chat-stream events — validation at boundaries.
  */
 import { z } from "zod";
 import { TokenUsageRollupSchema } from "./usage.js";
@@ -45,7 +45,7 @@ export const ChatErrorEventSchema = z.object({
     reason: z.string().optional(),
     source: EventSourceSchema,
 });
-export const CortexChatEventSchema = z.discriminatedUnion("type", [
+export const ChatEventSchema = z.discriminatedUnion("type", [
     TextDeltaEventSchema,
     ToolStartedEventSchema,
     ToolFinishedEventSchema,

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

@@ -1,5 +1,5 @@
 /**
- * Zod schemas for Cortex chat data parts — validation at boundaries.
+ * Zod schemas for chat data parts — validation at boundaries.
  */
 import { z } from "zod";
 export declare const PlanStepSchema: z.ZodObject<{
@@ -11,8 +11,16 @@ export declare const PlanStepSchema: z.ZodObject<{
     resources: z.ZodOptional<z.ZodObject<{
         cpu: z.ZodNumber;
         memoryGb: z.ZodNumber;
+        gpu: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     maxSteps: z.ZodNumber;
+    track: z.ZodOptional<z.ZodString>;
+    step_type: z.ZodOptional<z.ZodString>;
+    acceptance_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export declare const PresentationContentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"echart">;
@@ -93,8 +101,16 @@ export declare const PlanPartSchema: z.ZodObject<{
         resources: z.ZodOptional<z.ZodObject<{
             cpu: z.ZodNumber;
             memoryGb: z.ZodNumber;
+            gpu: z.ZodOptional<z.ZodObject<{
+                count: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         maxSteps: z.ZodNumber;
+        track: z.ZodOptional<z.ZodString>;
+        step_type: z.ZodOptional<z.ZodString>;
+        acceptance_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
     analytical_narrative: z.ZodOptional<z.ZodString>;
     omicsType: z.ZodOptional<z.ZodString>;
@@ -484,8 +500,12 @@ export declare const CompactionPartSchema: z.ZodObject<{
     tokensBefore: z.ZodNumber;
     tokensAfter: z.ZodOptional<z.ZodNumber>;
     durationMs: z.ZodOptional<z.ZodNumber>;
+    trigger: z.ZodOptional<z.ZodEnum<{
+        "turn-start": "turn-start";
+        "mid-turn": "mid-turn";
+    }>>;
 }, z.core.$strip>;
-export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"data-presentation">;
     id: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
@@ -533,8 +553,16 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         resources: z.ZodOptional<z.ZodObject<{
             cpu: z.ZodNumber;
             memoryGb: z.ZodNumber;
+            gpu: z.ZodOptional<z.ZodObject<{
+                count: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
         maxSteps: z.ZodNumber;
+        track: z.ZodOptional<z.ZodString>;
+        step_type: z.ZodOptional<z.ZodString>;
+        acceptance_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
     analytical_narrative: z.ZodOptional<z.ZodString>;
     omicsType: z.ZodOptional<z.ZodString>;
@@ -788,4 +816,8 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     tokensBefore: z.ZodNumber;
     tokensAfter: z.ZodOptional<z.ZodNumber>;
     durationMs: z.ZodOptional<z.ZodNumber>;
+    trigger: z.ZodOptional<z.ZodEnum<{
+        "turn-start": "turn-start";
+        "mid-turn": "mid-turn";
+    }>>;
 }, z.core.$strip>], "type">;

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

@@ -1,5 +1,5 @@
 /**
- * Zod schemas for Cortex chat data parts — validation at boundaries.
+ * Zod schemas for chat data parts — validation at boundaries.
  */
 import { z } from "zod";
 import { TokenUsageRollupSchema } from "./usage.js";
@@ -10,8 +10,13 @@ export const PlanStepSchema = z.object({
     agent: z.string(),
     question: z.string(),
     depends_on: z.array(z.string()),
-    resources: z.object({ cpu: z.number(), memoryGb: z.number() }).optional(),
+    resources: z.object({ cpu: z.number(), memoryGb: z.number(), gpu: z.object({ count: z.number() }).optional() }).optional(),
     maxSteps: z.number(),
+    track: z.string().optional(),
+    step_type: z.string().optional(),
+    acceptance_criteria: z.array(z.string()).optional(),
+    constraints: z.array(z.string()).optional(),
+    caveats: z.array(z.string()).optional(),
 });
 export const PresentationContentSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -307,9 +312,10 @@ export const CompactionPartSchema = z.object({
     tokensBefore: z.number().int().nonnegative(),
     tokensAfter: z.number().int().nonnegative().optional(),
     durationMs: z.number().int().nonnegative().optional(),
+    trigger: z.enum(["turn-start", "mid-turn"]).optional(),
 });
 // ── Union ───────────────────────────────────────────────────────────
-export const CortexChatPartSchema = z.discriminatedUnion("type", [
+export const ChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
     PlanPartSchema,
     RunCardPartSchema,

package/dist/contracts/schemas/index.d.ts

@@ -1,3 +1,3 @@
-export { PlanStepSchema, PresentationContentSchema, PresentationPartSchema, PlanPartSchema, RunCardPartSchema, FileReferenceEntrySchema, FileReferencePartSchema, RunStartedPartSchema, StepStatusSchema, DagStepStateSchema, DagStatePartSchema, StepPhaseSchema, StepActivityPartSchema, FileTreeEntrySchema, StepFileTreePartSchema, StepOutputFileSchema, StepOutputPartSchema, StepSummaryPartSchema, StepUsagePartSchema, StepBlockedPartSchema, SynthesizedFindingSchema, BiologicalThemeSchema, RunSynthesisPartSchema, SynthesisPhaseSchema, SynthesisProgressPartSchema, RunCompletedFindingSchema, RunCompletedPartSchema, RunFailedPartSchema, CortexChatPartSchema, } from "./chat-parts.js";
-export { EventSourceSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolFinishedEventSchema, FinishEventSchema, ChatErrorEventSchema, CortexChatEventSchema, } from "./chat-events.js";
+export { PlanStepSchema, PresentationContentSchema, PresentationPartSchema, PlanPartSchema, RunCardPartSchema, FileReferenceEntrySchema, FileReferencePartSchema, RunStartedPartSchema, StepStatusSchema, DagStepStateSchema, DagStatePartSchema, StepPhaseSchema, StepActivityPartSchema, FileTreeEntrySchema, StepFileTreePartSchema, StepOutputFileSchema, StepOutputPartSchema, StepSummaryPartSchema, StepUsagePartSchema, StepBlockedPartSchema, SynthesizedFindingSchema, BiologicalThemeSchema, RunSynthesisPartSchema, SynthesisPhaseSchema, SynthesisProgressPartSchema, RunCompletedFindingSchema, RunCompletedPartSchema, RunFailedPartSchema, ChatPartSchema, } from "./chat-parts.js";
+export { EventSourceSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolFinishedEventSchema, FinishEventSchema, ChatErrorEventSchema, ChatEventSchema, } from "./chat-events.js";
 export { TokenUsageRollupSchema } from "./usage.js";

package/dist/contracts/schemas/index.js

@@ -1,3 +1,3 @@
-export { PlanStepSchema, PresentationContentSchema, PresentationPartSchema, PlanPartSchema, RunCardPartSchema, FileReferenceEntrySchema, FileReferencePartSchema, RunStartedPartSchema, StepStatusSchema, DagStepStateSchema, DagStatePartSchema, StepPhaseSchema, StepActivityPartSchema, FileTreeEntrySchema, StepFileTreePartSchema, StepOutputFileSchema, StepOutputPartSchema, StepSummaryPartSchema, StepUsagePartSchema, StepBlockedPartSchema, SynthesizedFindingSchema, BiologicalThemeSchema, RunSynthesisPartSchema, SynthesisPhaseSchema, SynthesisProgressPartSchema, RunCompletedFindingSchema, RunCompletedPartSchema, RunFailedPartSchema, CortexChatPartSchema, } from "./chat-parts.js";
-export { EventSourceSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolFinishedEventSchema, FinishEventSchema, ChatErrorEventSchema, CortexChatEventSchema, } from "./chat-events.js";
+export { PlanStepSchema, PresentationContentSchema, PresentationPartSchema, PlanPartSchema, RunCardPartSchema, FileReferenceEntrySchema, FileReferencePartSchema, RunStartedPartSchema, StepStatusSchema, DagStepStateSchema, DagStatePartSchema, StepPhaseSchema, StepActivityPartSchema, FileTreeEntrySchema, StepFileTreePartSchema, StepOutputFileSchema, StepOutputPartSchema, StepSummaryPartSchema, StepUsagePartSchema, StepBlockedPartSchema, SynthesizedFindingSchema, BiologicalThemeSchema, RunSynthesisPartSchema, SynthesisPhaseSchema, SynthesisProgressPartSchema, RunCompletedFindingSchema, RunCompletedPartSchema, RunFailedPartSchema, ChatPartSchema, } from "./chat-parts.js";
+export { EventSourceSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolFinishedEventSchema, FinishEventSchema, ChatErrorEventSchema, ChatEventSchema, } from "./chat-events.js";
 export { TokenUsageRollupSchema } from "./usage.js";

package/dist/execution/run-event-parts.d.ts

@@ -1,21 +1,20 @@
 /**
- * The two input-only rules of the run-event read seam: narrowing a raw durable
- * stream value to the chat data-part contract, and the latest-wins reconciling
- * fold applied before delivery.
+ * The rules of the run-event read side that need no database and no durability
+ * engine: narrowing a raw durable stream value to the chat data-part contract,
+ * and the latest-wins reconciling fold, as a batch for `createRunEventStream`
+ * and live for an embedder that reads the run streams itself.
  *
- * They live apart from the reader because they are the only part of the seam
- * whose correctness is a function of its argument alone — no database, no
- * durability engine, no clock — and keeping them here is what lets that be
- * proven directly instead of inferred from a driven subscription.
+ * They live apart from the reader, thus a test drives them directly instead of
+ * through a subscription.
  */
-import type { CortexChatPart } from "../contracts/chat-parts.js";
+import type { ChatPart } from "../contracts/chat-parts.js";
 /**
  * Narrow one raw stream value to a chat data part, or `null` when it is not one.
  *
  * A run's streams carry more than the contract: a sandbox step also writes its
  * loop orchestration under envelopes (`data-loop-event`, `data-sandbox-event`)
  * that belong to the workflow layer and have no registry entry. The seam's
- * contract is the `CortexChatPart` union, so anything the registry does not
+ * contract is the `ChatPart` union, so anything the registry does not
  * classify is not deliverable — which also covers a part written by a producer
  * newer than the reader.
  *
@@ -26,7 +25,7 @@ import type { CortexChatPart } from "../contracts/chat-parts.js";
  * the discriminant is the boundary that can actually drift (a producer emitting
  * something else entirely) and the one worth checking.
  */
-export declare function parseRunEventPart(value: unknown): CortexChatPart | null;
+export declare function parseRunEventPart(value: unknown): ChatPart | null;
 /**
  * Collapse a batch of parts so each reconciling id appears once, carrying its
  * latest value, and every other part survives untouched in write order.
@@ -41,4 +40,13 @@ export declare function parseRunEventPart(value: unknown): CortexChatPart | null
  * A survivor keeps the position of its LAST occurrence, so relative order among
  * the parts that are delivered is the order they were written.
  */
-export declare function foldRunEventParts(parts: readonly CortexChatPart[]): CortexChatPart[];
+export declare function foldRunEventParts(parts: readonly ChatPart[]): ChatPart[];
+/**
+ * The live form of {@link foldRunEventParts}, for a stream that stays open. An
+ * entry with a reconcile key waits `flushMs`, and a later entry with the same
+ * key replaces it. Thus a catch-up burst delivers each key once, and a live
+ * update lands one window later. Every other entry, also one of a type that the
+ * registry does not know, goes to `emit` at once, thus it can overtake a held
+ * entry. The held entries go to `emit` when the stream ends.
+ */
+export declare function pipeFoldedRunEvents<T>(entries: AsyncIterable<T>, emit: (entry: T) => Promise<void>, flushMs: number): Promise<void>;

package/dist/execution/run-event-stream.d.ts

@@ -31,7 +31,7 @@
  * writer it observes.
  */
 import type { Pool } from "pg";
-import type { CortexChatPart } from "../contracts/chat-parts.js";
+import type { ChatPart } from "../contracts/chat-parts.js";
 import type { Logger } from "../lib/logger.js";
 /**
  * Construction-time dependencies. The pool is the application pool the run
@@ -48,7 +48,7 @@ export interface RunEventStreamDeps {
  * never invoked concurrently with itself and back-pressure is the caller's to
  * exert by taking its time. A throw is logged and swallowed.
  */
-export type RunEventPartHandler = (part: CortexChatPart) => void | Promise<void>;
+export type RunEventPartHandler = (part: ChatPart) => void | Promise<void>;
 /** Call-time parameters of one subscription. */
 export interface RunEventSubscribeOptions {
     /** The run to observe. Also the parent workflow's id. */

package/dist/index.d.ts

@@ -60,7 +60,7 @@ export { UnavailableAsk, AskRejectedError } from "./tools/approval/contract.js";
 export type { Ask, AskRequest, AskReply, AskApproval } from "./tools/approval/contract.js";
 export { runAgent, finalText } from "./loop/run-agent.js";
 export type { RunAgentOptions, RunAgentResult, AgentFinish, AgentRound } from "./loop/run-agent.js";
-export type { CompactionPolicy } from "./loop/compaction.js";
+export type { CompactionPolicy, CompactionRules } from "./loop/compaction.js";
 export type { ToolMask } from "./loop/tool-mask.js";
 export type { AgentDefinition, RunStep, EmitFn, EmitEvent, EventSource } from "./loop/types.js";
 export type { KeptToolOutput, ToolOutputStore } from "./loop/tool-output.js";
@@ -82,7 +82,7 @@ export type { SuspendOn } from "./providers/errors.js";
 export { suspensionOfFailure } from "./workflows/suspension.js";
 export type { Suspension } from "./workflows/suspension.js";
 export { createStreamingChat } from "./providers/streaming-chat.js";
-export { DEFAULT_CONVERSATION_BUDGET, openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
+export { openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
 export type { ChatTurnOutcome, ChatTurnRan, ChatTurnRefusal, ChatTurnResult, ChatTurnSession, OpenChatTurn, OpenChatTurnParams, PrepareChatTurnDeps, PrepareChatTurnParams, PrepareChatTurnResult, RunChatTurnDeps, RunChatTurnParams, RunOpenChatTurnParams, } from "./app/chat-turn.js";
 export { createThreadStore } from "./memory/thread-store.js";
 export type { ThreadStore, Thread, ThreadType, ThreadInputError, CreateThreadInput, ListThreadsInput, ThreadPage } from "./memory/thread-store.js";
@@ -93,12 +93,15 @@ export { createConversationDisplayRecorder } from "./memory/conversation-display
 export type { ConversationDisplayRecorder, ConversationDisplayRecorderOptions } from "./memory/conversation-display-recorder.js";
 export { envelopeDisplayMessages, parseStoredDisplayEnvelope } from "./memory/conversation-display-storage.js";
 export type { ConversationDisplayMetadata, ConversationUIData, ConversationUIMessage, StoredDisplayEnvelope } from "./memory/conversation-display-storage.js";
-export { storedMessagesToCortex } from "./memory/conversation-display-replay.js";
-export type { CortexChatEvent, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, ToolOutcome, ToolCallOutcome, ToolCallDetail, FinishEvent, ChatErrorEvent, } from "./contracts/chat-events.js";
+export { storedMessagesToChat } from "./memory/conversation-display-replay.js";
+export type { ChatEvent, ChatFrame, ChatPartFrame, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, ToolOutcome, ToolCallOutcome, ToolCallDetail, FinishEvent, ChatErrorEvent, } from "./contracts/chat-events.js";
+export { toChatFrame, applyChatFrame, checkChatPart } from "./contracts/chat-frame.js";
+export type { TextPart, ToolCallPart, MessagePart, ChatMessage } from "./contracts/message.js";
+export type { TurnTerminal, ApplyFrameResult, ChatPartCheck } from "./contracts/chat-frame.js";
 export type { TokenUsageRollup } from "./contracts/usage.js";
-export type { CortexChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, StepStatus, StepActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, } from "./contracts/chat-parts.js";
+export type { ChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, StepStatus, StepActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, } from "./contracts/chat-parts.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
-export type { CortexChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./contracts/part-registry.js";
+export type { ChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./contracts/part-registry.js";
 export { parseStructureUrl, alphafoldEntryUrl, alphafoldPredictionUrl } from "./contracts/structure-source.js";
 export type { StructureSource, StructureFormat } from "./contracts/structure-source.js";
 export { launchDbos, shutdownDbos, sweepEphemeralWorkflows } from "./runtime/dbos.js";
@@ -167,6 +170,7 @@ export { registerSandboxStep } from "./workflows/sandbox-step.js";
 export type { SandboxStepDeps, SandboxStepInput, SandboxStepResult, SandboxAgentBuildContext } from "./workflows/sandbox-step.js";
 export { createRunEventStream } from "./execution/run-event-stream.js";
 export type { RunEventStream, RunEventStreamDeps, RunEventSubscribeOptions, RunEventPartHandler } from "./execution/run-event-stream.js";
+export { pipeFoldedRunEvents } from "./execution/run-event-parts.js";
 export { createSandboxAgents, SANDBOX_AGENT_META } from "./agents/sandbox/index.js";
 export type { SandboxAgentDeps, SandboxStepCoords, AgentMeta } from "./agents/sandbox/index.js";
 export { AnalysisPlanSchema } from "./schemas/workflow-state.js";

package/dist/index.js

@@ -130,7 +130,7 @@ export { createStreamingChat } from "./providers/streaming-chat.js";
 // and gives only its transport values: the harness stores the opening, each round,
 // and the outcome. `appendTurn` stays for a record of a host. `createThreadStore`
 // owns thread metadata (create/list/title).
-export { DEFAULT_CONVERSATION_BUDGET, openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
+export { openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
 export { createThreadStore } from "./memory/thread-store.js";
 export { createThreadHistory, conversationRecordTurn } from "./memory/thread-history.js";
 // The synthetic-message primitives. A host appends a record of out-of-band work (an analysis run's
@@ -154,7 +154,8 @@ export { envelopeDisplayMessages, parseStoredDisplayEnvelope } from "./memory/co
 // along with the startup backfill that was its only caller. `parseStoredDisplayEnvelope` absorbs the
 // one thing a read can now meet and not understand — a part whose key this vocabulary has retired —
 // by dropping that part, so one stale row cannot fail a whole thread.
-export { storedMessagesToCortex } from "./memory/conversation-display-replay.js";
+export { storedMessagesToChat } from "./memory/conversation-display-replay.js";
+export { toChatFrame, applyChatFrame, checkChatPart } from "./contracts/chat-frame.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
 // The source grammar of a `structure` presentation card — a host re-runs the same parse over a
 // persisted `url` before it fetches, so the rule lives in one place for both sides.
@@ -270,6 +271,7 @@ export { registerSandboxStep } from "./workflows/sandbox-step.js";
 // Nothing in the signature belongs to the durability engine, so an embedder
 // consumes run events without depending on it.
 export { createRunEventStream } from "./execution/run-event-stream.js";
+export { pipeFoldedRunEvents } from "./execution/run-event-parts.js";
 // Sandbox-agent catalog. `buildAgent` maps a `SandboxAgentBuildContext` onto
 // `SandboxAgentDeps`, then selects the per-step agent by id from this record;
 // `SANDBOX_AGENT_META` is the planner-facing meta the same ids key.

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

@@ -5,12 +5,16 @@
  * readiness signal of the page, and gives back base64 screenshots. The eyes tool of a report session reads
  * this module.
  *
+ * The layout resolves at the CSS width of a reader, and the picture renders at half the device scale. A
+ * picture costs tokens in proportion to its area, thus the half scale lets one look hold a whole report.
+ *
  * A short page captures as one full-page shot. A tall page captures as consecutive vertical slices, because
- * one tall picture dies twice on the provider path: a picture past the hard dimension cap rejects the whole
- * request, and a legal tall picture downscales to about 1568 pixels on the long side, which compresses the
- * text past legibility. A slice of about two window heights survives both. The slice budget bounds what one
- * look costs, and a page past the budget truncates with the captured and the total pixels on the coverage,
- * thus the truncation is never silent.
+ * the model reads a picture whole only up to a limit on the long edge, and a taller picture downscales or
+ * refuses the request. The slice budget bounds what one look costs, and a page past the budget truncates
+ * with the captured and the total pixels on the coverage, thus the truncation is never silent.
+ *
+ * A capture can also take one block alone. The renderer marks each block with its id, and the capture clips
+ * the union box of the marked elements with a margin. A page that holds no such mark gives no picture.
  *
  * The readiness contract is the reason for one shared body. The renderer emits the event name and the
  * sentinel name, and `report-render/page.ts` owns both constants together with the two budgets. This module
@@ -45,6 +49,9 @@ export interface CapturedShot {
  * thus `capturedPx < totalPx` says that the slice budget ran out and the tail of the page is absent. `viewport`
  * appears when a screenshot threw and the retry at the window passed, thus the one picture shows the top
  * window alone and a section below the fold is absent from it.
+ *
+ * `block` is the box of one block and its margin; `capturedPx < totalPx` says that the slice budget cut it.
+ * `no-block` means that no element of the page carries the mark of the block, thus no picture exists.
  */
 export type CaptureCoverage = {
     readonly kind: "full";
@@ -54,10 +61,19 @@ export type CaptureCoverage = {
     readonly totalPx: number;
 } | {
     readonly kind: "viewport";
+} | {
+    readonly kind: "block";
+    readonly capturedPx: number;
+    readonly totalPx: number;
+} | {
+    readonly kind: "no-block";
 };
 /** The pictures and the faults of one page capture. */
 export interface PageCapture {
-    /** The pictures in document order: one shot under `full` and `viewport`, the slices under `tiled`. */
+    /**
+     * The pictures in document order: one shot under `full` and `viewport`, the slices under `tiled` and
+     * `block`, and none under `no-block`.
+     */
     screenshots: CapturedShot[];
     coverage: CaptureCoverage;
     consoleErrors: string[];
@@ -68,13 +84,15 @@ export interface PageCapture {
  * speaks the throw protocol, because the chrome connection does. A test injects a seam that reads no
  * browser, thus a tool orchestration runs with no chrome sidecar.
  */
-export type CapturePage = (url: string) => Promise<PageCapture>;
-/** The extra settle steps that one call site needs. A call site that needs neither passes nothing. */
+export type CapturePage = (url: string, options?: CaptureOptions) => Promise<PageCapture>;
+/** The extra settle steps and the target of one capture. A call site that needs none passes nothing. */
 export interface CaptureOptions {
     /** A CSS selector to wait for after the readiness signal. The wait is best-effort. */
     readonly waitForSelector?: string;
     /** An extra settle time in milliseconds after the readiness signal, for a late paint. */
     readonly waitMs?: number;
+    /** The id of the one block to capture. Absent, the capture takes the whole document. */
+    readonly blockId?: string;
 }
 /**
  * Capture one page: the screenshots, the console errors, and the failed requests.
@@ -82,7 +100,7 @@ export interface CaptureOptions {
  * The pictures hold the document, and not the window alone. Thus a caller can judge a section that a reader
  * reaches by a scroll. A short page arrives as one full-page shot, and a tall page arrives as consecutive
  * slices in document order. A refused bitmap degrades to the window, and the coverage of the result names
- * what the pictures hold.
+ * what the pictures hold. A capture that names a block holds that block alone.
  *
  * The readiness wait is best-effort. A page that never signals still captures at the readiness budget, thus
  * a broken page gives a picture that shows what broke.

package/dist/lib/page-capture.js

@@ -5,12 +5,16 @@
  * readiness signal of the page, and gives back base64 screenshots. The eyes tool of a report session reads
  * this module.
  *
+ * The layout resolves at the CSS width of a reader, and the picture renders at half the device scale. A
+ * picture costs tokens in proportion to its area, thus the half scale lets one look hold a whole report.
+ *
  * A short page captures as one full-page shot. A tall page captures as consecutive vertical slices, because
- * one tall picture dies twice on the provider path: a picture past the hard dimension cap rejects the whole
- * request, and a legal tall picture downscales to about 1568 pixels on the long side, which compresses the
- * text past legibility. A slice of about two window heights survives both. The slice budget bounds what one
- * look costs, and a page past the budget truncates with the captured and the total pixels on the coverage,
- * thus the truncation is never silent.
+ * the model reads a picture whole only up to a limit on the long edge, and a taller picture downscales or
+ * refuses the request. The slice budget bounds what one look costs, and a page past the budget truncates
+ * with the captured and the total pixels on the coverage, thus the truncation is never silent.
+ *
+ * A capture can also take one block alone. The renderer marks each block with its id, and the capture clips
+ * the union box of the marked elements with a margin. A page that holds no such mark gives no picture.
  *
  * The readiness contract is the reason for one shared body. The renderer emits the event name and the
  * sentinel name, and `report-render/page.ts` owns both constants together with the two budgets. This module
@@ -26,6 +30,7 @@
  */
 import { withPage } from "./chrome.js";
 import { PAGE_NAV_TIMEOUT_MS, PAGE_READY_TIMEOUT_MS, THEME_READY_EVENT, THEME_READY_SENTINEL } from "../report-render/page.js";
+import { BLOCK_ID_ATTRIBUTE } from "../report-render/views/block-mark.js";
 /** The budget of the optional selector wait. The wait is best-effort, thus a miss captures the page anyway. */
 const SELECTOR_TIMEOUT_MS = 5_000;
 /**
@@ -37,22 +42,22 @@ const SELECTOR_TIMEOUT_MS = 5_000;
 const VIEWPORT_WIDTH = 1440;
 const VIEWPORT_HEIGHT = 900;
 /**
- * The height of one capture slice, in CSS pixels, and the bound of a single-shot page.
- *
- * The provider downscales every picture to about 1568 pixels on the long side before the model reads it. Two
- * window heights survive that downscale with readable text, and a taller picture reaches the model compressed
- * past that. Thus a page at this height or under captures as one full-page shot, and a taller page captures
- * as slices of this height.
+ * The device scale of one capture. The layout keeps the CSS width of a reader, and the picture holds half
+ * the pixels on each side. A picture costs about one token for each 750 pixels of its area.
  */
-const TILE_HEIGHT_PX = VIEWPORT_HEIGHT * 2;
+const DEVICE_SCALE_FACTOR = 0.5;
 /**
- * The most slices of one capture.
- *
- * Each slice is one picture on the tool result, and the budget bounds what one look costs the context. A page
- * taller than the budget covers truncates, and the coverage carries the captured and the total pixels, thus
- * the truncation is never silent.
+ * The height of one slice and the bound of a single-shot page, in CSS pixels. At the half scale a slice is
+ * 720 by 2000 pixels, under the long edge of 2576 pixels that the model reads with no downscale.
  */
-const MAX_TILES = 6;
+const TILE_HEIGHT_PX = 4_000;
+/**
+ * The most slices of one capture: 20,000 CSS pixels, about 9,600 tokens, thus a report of 16,000 pixels
+ * fits whole. A taller page truncates, and the coverage carries the captured and the total pixels.
+ */
+const MAX_TILES = 5;
+/** The margin around the box of one block, in CSS pixels. Content that overflows its box stays in the picture. */
+const BLOCK_MARGIN_PX = 16;
 /**
  * The body of the readiness wait, in the browser context. The sentinel arm resolves a page that dispatched
  * the event before this wait registered, thus a plain listener never blocks forever. The timer arm bounds a
@@ -94,26 +99,67 @@ async function measureTotalHeight(page) {
     return typeof measured === "number" && Number.isFinite(measured) ? measured : 0;
 }
 /**
- * Capture the slices of one tall page, in document order. Each slice clips {@link TILE_HEIGHT_PX} rows at the
- * reader width, and the last slice ends at the document height or at the budget, whichever comes first.
+ * Capture the rows of one area as slices, in document order. Each slice clips {@link TILE_HEIGHT_PX} rows,
+ * and the last slice ends at the area or at the budget, whichever comes first.
  */
-async function captureTiles(page, totalPx) {
-    const tileCount = Math.min(Math.ceil(totalPx / TILE_HEIGHT_PX), MAX_TILES);
+async function captureSlices(page, area) {
+    const heightPx = area.toY - area.fromY;
+    const tileCount = Math.min(Math.ceil(heightPx / TILE_HEIGHT_PX), MAX_TILES);
     const screenshots = [];
     for (let index = 0; index < tileCount; index++) {
-        const fromY = index * TILE_HEIGHT_PX;
-        const toY = Math.min(fromY + TILE_HEIGHT_PX, totalPx);
-        const clip = { x: 0, y: fromY, width: VIEWPORT_WIDTH, height: toY - fromY };
+        const fromY = area.fromY + index * TILE_HEIGHT_PX;
+        const toY = Math.min(fromY + TILE_HEIGHT_PX, area.toY);
+        const clip = { x: area.x, y: fromY, width: area.width, height: toY - fromY };
         screenshots.push({ base64: toBase64(await page.screenshot({ encoding: "base64", clip })), range: { fromY, toY } });
     }
-    const capturedPx = Math.min(tileCount * TILE_HEIGHT_PX, totalPx);
-    return { screenshots, coverage: { kind: "tiled", capturedPx, totalPx } };
+    return { screenshots, capturedPx: Math.min(tileCount * TILE_HEIGHT_PX, heightPx) };
+}
+/**
+ * The body of the block measure, in the browser context: the union box of the marked elements, with the
+ * margin, or `null`. The body compares each attribute value, thus an id never becomes part of a selector.
+ */
+function measureBlock(attribute, blockId, margin) {
+    let left = Number.POSITIVE_INFINITY;
+    let top = Number.POSITIVE_INFINITY;
+    let right = Number.NEGATIVE_INFINITY;
+    let bottom = Number.NEGATIVE_INFINITY;
+    for (const node of Array.from(document.querySelectorAll(`[${attribute}]`))) {
+        if (node.getAttribute(attribute) !== blockId)
+            continue;
+        const rect = node.getBoundingClientRect();
+        left = Math.min(left, rect.left + window.scrollX);
+        top = Math.min(top, rect.top + window.scrollY);
+        right = Math.max(right, rect.right + window.scrollX);
+        bottom = Math.max(bottom, rect.bottom + window.scrollY);
+    }
+    if (left === Number.POSITIVE_INFINITY) {
+        return null;
+    }
+    const root = document.documentElement;
+    const x = Math.max(0, Math.floor(left - margin));
+    const fromY = Math.max(0, Math.floor(top - margin));
+    const toX = Math.min(root.scrollWidth, Math.ceil(right + margin));
+    const toY = Math.min(root.scrollHeight, Math.ceil(bottom + margin));
+    // A block of no height still gives a strip, thus the picture shows the empty place of the block.
+    return { x, width: Math.max(1, toX - x), fromY, toY: Math.max(fromY + 1, toY) };
+}
+/**
+ * Take the pictures of one block. A refused bitmap propagates, because the window shows the top of the page
+ * and not the block.
+ */
+async function captureBlock(page, blockId) {
+    const area = await page.evaluate(measureBlock, BLOCK_ID_ATTRIBUTE, blockId, BLOCK_MARGIN_PX);
+    if (area === null) {
+        return { screenshots: [], coverage: { kind: "no-block" } };
+    }
+    const sliced = await captureSlices(page, area);
+    return { screenshots: sliced.screenshots, coverage: { kind: "block", capturedPx: sliced.capturedPx, totalPx: area.toY - area.fromY } };
 }
 /**
  * Take the pictures of one settled page.
  *
  * A page at the single-shot bound or under gives one full-page shot. A taller page gives consecutive slices,
- * because the provider path compresses or rejects one tall picture; the module comment carries the account.
+ * because the model downscales or refuses one tall picture; the module comment carries the account.
  *
  * The compositor can refuse a bitmap of either shape while the bitmap of the window is fine. A degraded
  * picture beats a dead look, thus a refusal retries one time at the window. A second throw names a broken
@@ -122,8 +168,10 @@ async function captureTiles(page, totalPx) {
 async function captureShots(page) {
     const totalPx = await measureTotalHeight(page);
     try {
-        if (totalPx > TILE_HEIGHT_PX)
-            return await captureTiles(page, totalPx);
+        if (totalPx > TILE_HEIGHT_PX) {
+            const sliced = await captureSlices(page, { x: 0, width: VIEWPORT_WIDTH, fromY: 0, toY: totalPx });
+            return { screenshots: sliced.screenshots, coverage: { kind: "tiled", capturedPx: sliced.capturedPx, totalPx } };
+        }
         return { screenshots: [{ base64: toBase64(await page.screenshot({ encoding: "base64", fullPage: true })) }], coverage: { kind: "full" } };
     }
     catch (refused) {
@@ -146,7 +194,7 @@ async function captureShots(page) {
  * The pictures hold the document, and not the window alone. Thus a caller can judge a section that a reader
  * reaches by a scroll. A short page arrives as one full-page shot, and a tall page arrives as consecutive
  * slices in document order. A refused bitmap degrades to the window, and the coverage of the result names
- * what the pictures hold.
+ * what the pictures hold. A capture that names a block holds that block alone.
  *
  * The readiness wait is best-effort. A page that never signals still captures at the readiness budget, thus
  * a broken page gives a picture that shows what broke.
@@ -165,7 +213,7 @@ export function capturePage(chrome, url, options = {}) {
         });
         // The size is set before the navigation, because a layout resolves at load time. The connection gives
         // a small default window, and that window collapses each multi-column band of the design.
-        await page.setViewport({ width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT });
+        await page.setViewport({ width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT, deviceScaleFactor: DEVICE_SCALE_FACTOR });
         // The preference is active before the navigation, because the page reveals its sections as it loads.
         // A preference that arrives after the load reaches a page that already runs its transitions.
         await page.emulateMediaFeatures([{ name: "prefers-reduced-motion", value: "reduce" }]);
@@ -185,7 +233,7 @@ export function capturePage(chrome, url, options = {}) {
         }
         // The pictures must show the whole document at the layout that a reader gets. Thus a defect below the
         // fold is visible, and a question about content that never appeared has an answer.
-        const shots = await captureShots(page);
+        const shots = options.blockId === undefined ? await captureShots(page) : await captureBlock(page, options.blockId);
         return {
             screenshots: shots.screenshots,
             coverage: shots.coverage,

package/dist/loop/compaction.d.ts

@@ -3,10 +3,15 @@ import type { ToolMask } from "./tool-mask.js";
 import type { LoopMessage } from "./types.js";
 /** The cap of requests of one compaction exchange: up to 3 rounds of memory edits, and then the summary. */
 export declare const COMPACTION_MAX_REQUESTS = 4;
-/** How the loop compacts its conversation when the view passes the budget. */
-export interface CompactionPolicy {
-    /** The budget of the view, in estimated tokens. */
+/** When an agent compacts its conversation, in the input tokens that the provider reported for the last request. */
+export interface CompactionRules {
+    /** The budget before each request of a turn. */
     readonly budget: number;
+    /** The budget before the user message of a turn joins the conversation. Absent: no compaction before the user message. */
+    readonly turnStartBudget?: number;
+}
+/** How the loop compacts its conversation when the last request passed a budget. */
+export interface CompactionPolicy extends CompactionRules {
     /** The provider of the conversation, with no text stream to the surface: the summary is no reply. */
     readonly provider: AgentChat;
     /** The text of the compaction request. */