@inflexa-ai/harness 0.39.2 → 0.40.0

package/dist/memory/conversation-display-recorder.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { PART_REGISTRY } from "../contracts/part-registry.js";
 import { CortexChatPartSchema } from "../contracts/schemas/chat-parts.js";
+import { compactionExchangeOf, compactionMarkerOf } from "./ai-sdk-message-storage.js";
 import { conversationDisplayPart } from "./conversation-display-storage.js";
 function jsonCopy(value) {
     return JSON.parse(JSON.stringify(value));
@@ -28,7 +29,34 @@ function dataPart(event) {
         data: jsonCopy(data),
     };
 }
+/** The text of the assistant messages of a round. The text of an exchange is a summary, and no reply. */
+function assistantText(messages) {
+    return messages
+        .filter((message) => message.role === "assistant" && compactionExchangeOf(message) === undefined)
+        .map((message) => typeof message.content === "string"
+        ? message.content
+        : message.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join(""))
+        .join("");
+}
+/** The divider of a compaction marker: a `system` message with the part at the final status of the compaction. */
+function compactionDivider(marker) {
+    const part = conversationDisplayPart({
+        type: "data-compaction",
+        id: marker.id,
+        status: marker.kind === "summary" ? "done" : "failed",
+        tokensBefore: marker.tokensBefore,
+        tokensAfter: marker.tokensAfter,
+        durationMs: marker.durationMs,
+    });
+    return { id: marker.id, role: "system", parts: [part] };
+}
 export function createConversationDisplayRecorder(options) {
+    // One id for each message of the turn, thus the rounds of a turn replay as one assistant message.
+    const userMessageId = options.userMessageId ?? randomUUID();
+    let assistantMessageId = options.assistantMessageId ?? randomUUID();
     const assistantParts = [];
     // Where a reconciling part lives, keyed by `type:id`. Type-qualified because a
     // stable id is only unique within its own family — a plan and a run card may
@@ -115,36 +143,50 @@ export function createConversationDisplayRecorder(options) {
         }
         return options.sink(event);
     };
+    function closeParts() {
+        // Calls need no closing pass: one that never reached `tool-finished` still holds
+        // the `incomplete` it was recorded with at dispatch, which is the whole of what
+        // the harness observed. An approval does need one — `pending` is a question, and
+        // a turn that ends without answering it aborted it.
+        for (const part of assistantParts) {
+            if (part.type === "data-ask" && part.data.status === "pending")
+                part.data.status = "aborted";
+            if (part.type === "text")
+                part.state = "done";
+        }
+    }
+    function takeOpening() {
+        return [{ id: userMessageId, role: "user", parts: [{ type: "text", text: options.userText, state: "done" }] }];
+    }
+    function takeRound(messages) {
+        if (!assistantParts.some((part) => part.type === "text"))
+            appendText(assistantText(messages));
+        // Only a round that a throw ends can hold a pending approval.
+        closeParts();
+        const round = assistantParts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(assistantParts) }];
+        // A later update of a part lands in the next round, and the replay replaces the earlier copy.
+        assistantParts.length = 0;
+        reconcileIndexes.clear();
+        const marker = messages.map(compactionMarkerOf).find((found) => found !== undefined);
+        if (marker !== undefined) {
+            round.push(compactionDivider(marker));
+            // The divider splits the turn into two assistant messages of the replay, and two messages must not share an id.
+            assistantMessageId = randomUUID();
+        }
+        return round;
+    }
     function finish(finishOptions) {
         if (!finished) {
             finished = true;
             if (!assistantParts.some((part) => part.type === "text") && finishOptions?.fallbackText) {
                 appendText(finishOptions.fallbackText);
             }
-            // Calls need no closing pass: one that never reached `tool-finished` still holds
-            // the `incomplete` it was recorded with at dispatch, which is the whole of what
-            // the harness observed. An approval does need one — `pending` is a question, and
-            // a turn that ends without answering it aborted it.
-            for (const part of assistantParts) {
-                if (part.type === "data-ask" && part.data.status === "pending") {
-                    part.data.status = "aborted";
-                }
-            }
-            for (const part of assistantParts) {
-                if (part.type === "text")
-                    part.state = "done";
-            }
+            closeParts();
         }
-        const messages = [
-            {
-                id: options.userMessageId ?? randomUUID(),
-                role: "user",
-                parts: [{ type: "text", text: options.userText, state: "done" }],
-            },
-        ];
+        const messages = takeOpening();
         if (assistantParts.length > 0) {
             messages.push({
-                id: options.assistantMessageId ?? randomUUID(),
+                id: assistantMessageId,
                 role: "assistant",
                 ...(finishOptions?.interrupted ? { metadata: { interrupted: true } } : {}),
                 parts: jsonCopy(assistantParts),
@@ -152,5 +194,5 @@ export function createConversationDisplayRecorder(options) {
         }
         return messages;
     }
-    return { emit, finish };
+    return { emit, takeOpening, takeRound, finish };
 }

package/dist/memory/conversation-display-replay.d.ts

@@ -1,19 +1,10 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`.
+ * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
+ * that message. It consults no tool name, no card builder, and no workspace or database.
  *
- * `ThreadHistory.loadAll` returns a thread's rows in `seq` order, and every
- * append's first row carries the display projection for that append. Replay is
- * therefore a concatenation: walk the rows, emit each envelope's messages in
- * order, done. No turn grouping, no tool-name recognition, no card rebuilding,
- * no filesystem or database lookup — nothing that could render a reloaded
- * conversation differently from the one the user was shown.
- *
- * A row with no envelope predates the display projection and is skipped — the
- * only handling there is or will be. Reconstructing one from the model
- * transcript instead is what the deleted migration renderer did, and rebuilding
- * a display from a transcript that never carried one makes every later change to
- * a tool or a card silently rewrite history. Skipping keeps the gap observable
- * and the read total in what it consults: the stored projection, nothing else.
+ * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
+ * model transcript would let each later change of a tool or a card rewrite history.
  */
 import type { CortexMessage } from "../contracts/message.js";
 import type { StoredMessage } from "./thread-history.js";

package/dist/memory/conversation-display-replay.js

@@ -1,27 +1,56 @@
 /**
- * The runtime transcript read: stored display projections → `CortexMessage[]`.
+ * The runtime transcript read: stored display projections → `CortexMessage[]`. It walks the rows in
+ * `seq` order, merges the rounds of a turn into one assistant message, and folds the turn record onto
+ * that message. It consults no tool name, no card builder, and no workspace or database.
  *
- * `ThreadHistory.loadAll` returns a thread's rows in `seq` order, and every
- * append's first row carries the display projection for that append. Replay is
- * therefore a concatenation: walk the rows, emit each envelope's messages in
- * order, done. No turn grouping, no tool-name recognition, no card rebuilding,
- * no filesystem or database lookup — nothing that could render a reloaded
- * conversation differently from the one the user was shown.
- *
- * A row with no envelope predates the display projection and is skipped — the
- * only handling there is or will be. Reconstructing one from the model
- * transcript instead is what the deleted migration renderer did, and rebuilding
- * a display from a transcript that never carried one makes every later change to
- * a tool or a card silently rewrite history. Skipping keeps the gap observable
- * and the read total in what it consults: the stored projection, nothing else.
+ * A row with no envelope predates the display projection and is skipped. A display rebuilt from the
+ * model transcript would let each later change of a tool or a card rewrite history.
  */
+import { isReconciling } from "../contracts/part-registry.js";
+import { isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
 import { conversationUIToCortexMessages } from "./conversation-display-storage.js";
+/** The key that a part reconciles on, or `undefined` for a part that each round adds again. */
+function reconcileKey(part) {
+    if (part.type === "tool-call")
+        return `tool-call:${part.toolCallId}`;
+    if (part.type === "text" || !isReconciling(part.type))
+        return undefined;
+    return "id" in part && typeof part.id === "string" ? `${part.type}:${part.id}` : undefined;
+}
+/** Add the parts of a later round to the assistant message of its turn. */
+function mergeRound(target, round) {
+    for (const part of round.parts) {
+        const key = reconcileKey(part);
+        const earlier = key === undefined ? -1 : target.parts.findIndex((candidate) => reconcileKey(candidate) === key);
+        if (earlier >= 0)
+            target.parts[earlier] = part;
+        else
+            target.parts.push(part);
+    }
+}
+function foldTurnRecord(message, record) {
+    if (message === undefined || record === undefined)
+        return;
+    if (record.usage)
+        message.usage = record.usage;
+    if (record.durationMs !== undefined)
+        message.durationMs = record.durationMs;
+    if (record.status === "aborted")
+        message.interrupted = true;
+}
 export function storedMessagesToCortex(messages) {
     const out = [];
-    // The messages the append currently being walked produced. A row bearing an
-    // envelope opens one; every row after it belongs to it until the next does.
-    let append = null;
+    // The last message of the group being walked, as `out` holds it.
+    let groupLast;
+    // The record of the turn being walked, and the last assistant message of that turn.
+    let turnRecord;
+    let turnAssistant;
     for (const row of messages) {
+        if (row.message.role === "user" && !isSyntheticUserMessage(row.message)) {
+            foldTurnRecord(turnAssistant, turnRecord);
+            turnRecord = row.turn;
+            turnAssistant = undefined;
+        }
         if (row.displayEnvelope) {
             // The author and the creation time are facts about the ROW, the same as
             // the rollup below, and the projection holds neither. Both ride the row
@@ -32,29 +61,34 @@ export function storedMessagesToCortex(messages) {
             // does not survive the JSON crossing typed, hence the ISO string here.
             const createdAt = row.createdAt === undefined ? {} : { createdAt: row.createdAt.toISOString() };
             const author = row.author === undefined ? {} : { author: row.author };
-            append = conversationUIToCortexMessages(row.displayEnvelope.messages).map((message) => ({
-                ...message,
-                ...createdAt,
-                ...(message.role === "user" ? author : {}),
-            }));
-            out.push(...append);
+            groupLast = undefined;
+            for (const message of conversationUIToCortexMessages(row.displayEnvelope.messages)) {
+                const stamped = { ...message, ...createdAt, ...(message.role === "user" ? author : {}) };
+                const previous = out.at(-1);
+                // The merged message keeps the creation time of its first round.
+                if (stamped.role === "assistant" && previous?.role === "assistant" && previous.id === stamped.id)
+                    mergeRound(previous, stamped);
+                else
+                    out.push(stamped);
+                groupLast = out.at(-1);
+                if (groupLast?.role === "assistant")
+                    turnAssistant = groupLast;
+            }
         }
-        // The reported rollup of the turn and its duration both ride the model row that
+        // The reported rollup of an older turn and its duration both ride the model row that
         // ENDED the turn, and not the display projection. Each one is a fact about what the
         // turn cost, and not about what the turn showed. A write in both places would let
         // the two disagree. Thus the replay folds them onto the assistant reply that a
         // reader ties to the figures. The duration reads against `undefined`, and never
         // against falsiness: a measured zero is a figure, and an absent value alone means
         // that nobody measured the turn.
-        if (append && (row.usage || row.durationMs !== undefined)) {
-            const last = append.at(-1);
-            if (last?.role === "assistant") {
-                if (row.usage)
-                    last.usage = row.usage;
-                if (row.durationMs !== undefined)
-                    last.durationMs = row.durationMs;
-            }
+        if (groupLast?.role === "assistant" && (row.usage || row.durationMs !== undefined)) {
+            if (row.usage)
+                groupLast.usage = row.usage;
+            if (row.durationMs !== undefined)
+                groupLast.durationMs = row.durationMs;
         }
     }
+    foldTurnRecord(turnAssistant, turnRecord);
     return out;
 }

package/dist/memory/conversation-display-storage.d.ts

@@ -15,7 +15,7 @@
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
-import type { AskPart, ChildSessionStartedPart, FileReferencePart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart } from "../contracts/chat-parts.js";
+import type { AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
 import type { CortexMessage, CortexPart, ToolCallPart } from "../contracts/message.js";
 import type { Logger } from "../lib/logger.js";
@@ -41,6 +41,7 @@ export type ConversationUIData = {
     ask: Payload<AskPart>;
     "child-session-started": Payload<ChildSessionStartedPart>;
     "report-rendered": Payload<ReportRenderedPart>;
+    compaction: Payload<CompactionPart>;
 };
 export interface ConversationDisplayMetadata {
     interrupted?: boolean;

package/dist/memory/conversation-display-storage.js

@@ -16,7 +16,7 @@
  */
 import { validateUIMessages } from "ai";
 import { z } from "zod";
-import { AskPartSchema, ChildSessionStartedPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, ReportRenderedPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
+import { AskPartSchema, ChildSessionStartedPartSchema, CompactionPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, ReportRenderedPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
 import { ToolCallOutcomeSchema } from "../contracts/schemas/chat-events.js";
 export const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 const DisplayEnvelopeHeaderSchema = z.object({
@@ -68,6 +68,7 @@ const dataSchemas = {
     ask: AskPartSchema.omit({ type: true }),
     "child-session-started": ChildSessionStartedPartSchema.omit({ type: true }),
     "report-rendered": ReportRenderedPartSchema.omit({ type: true }),
+    compaction: CompactionPartSchema.omit({ type: true }),
 };
 export function envelopeDisplayMessages(messages) {
     if (messages.length === 0)

package/dist/memory/conversation-view.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The view of a conversation, which the loop sends and `loadRecent` gives: the head, then the latest
+ * summary marker, then the body. An exchange message never joins it, and a drop marker keeps the last
+ * turns of the body without their reasoning. The loop and the reader call this one function, thus the
+ * next turn reads back the prefix that the last request sent.
+ */
+import type { ModelMessage } from "ai";
+/**
+ * A turn starts on a `user` message that a human actually sent. Two kinds of
+ * message carry the `user` role without opening a turn, and both are excluded
+ * here:
+ *
+ * - a tool result, which in AI SDK terms is a `tool`-role message, so a mid-turn
+ *   tool continuation never matches in the first place;
+ * - a message the LOOP or the HOST synthesized (`syntheticUserMessage`) — the
+ *   truncated-reply nudge the loop inserts mid-turn, and the record an embedder
+ *   appends between turns for work that happened outside the conversation, such as
+ *   an analysis run's outcome. Both carry the `user` role for the wire format and
+ *   neither is user input. Reading one as a boundary would split one turn into
+ *   two: a drop would keep half a turn, and `retractLastTurn` would cut
+ *   its tail in the middle of a turn rather than at its head.
+ *
+ *   A host-appended record therefore belongs to the turn preceding it, so a tail
+ *   retraction that removes that turn removes the record with it. That is the
+ *   accepted consequence of the exclusion, not a defect — the alternative, letting
+ *   it open a turn, is the exact failure the marker exists to prevent.
+ *
+ * `GENUINE_USER_START_SQL` in `thread-history.ts` is the twin of this predicate over stored
+ * envelopes; the two are built from the same constants so they cannot drift.
+ */
+export declare function isGenuineUserStart(message: ModelMessage): boolean;
+/**
+ * Group rows (oldest-first) into turns at genuine-user-start boundaries.
+ * Generic over the row shape so the view rule and the display read
+ * (`loadAll`) share it, each supplying its own start predicate.
+ */
+export declare function groupTurns<T>(rows: readonly T[], isStart: (row: T) => boolean): T[][];
+export interface ConversationViewOptions {
+    /** Keep the first turn in front of the view: the seed of a report thread. */
+    readonly keepFirstTurn?: boolean;
+}
+export interface ConversationView {
+    readonly messages: ModelMessage[];
+    /** `sources[i]` is the index of the input message that gives `messages[i]`. */
+    readonly sources: number[];
+}
+export declare function conversationView(messages: readonly ModelMessage[], options: ConversationViewOptions): ConversationView;
+/** The message with no reasoning part, or `undefined` for an assistant message with no part left. */
+export declare function withoutReasoning(message: ModelMessage): ModelMessage | undefined;
+/** The estimate of the messages, by the count that the store writes to the `tokens` column. */
+export declare function viewTokens(messages: readonly ModelMessage[]): number;
+/** The count of the turns that a drop keeps: the newest turn, and each older turn while the view stays within `budget`. */
+export declare function keptTurnsForDrop(messages: readonly ModelMessage[], options: ConversationViewOptions, budget: number): number;

package/dist/memory/conversation-view.js

@@ -0,0 +1,130 @@
+/**
+ * The view of a conversation, which the loop sends and `loadRecent` gives: the head, then the latest
+ * summary marker, then the body. An exchange message never joins it, and a drop marker keeps the last
+ * turns of the body without their reasoning. The loop and the reader call this one function, thus the
+ * next turn reads back the prefix that the last request sent.
+ */
+import { compactionExchangeOf, compactionMarkerOf, isSyntheticUserMessage } from "./ai-sdk-message-storage.js";
+import { countTokens } from "./count-tokens.js";
+/**
+ * A turn starts on a `user` message that a human actually sent. Two kinds of
+ * message carry the `user` role without opening a turn, and both are excluded
+ * here:
+ *
+ * - a tool result, which in AI SDK terms is a `tool`-role message, so a mid-turn
+ *   tool continuation never matches in the first place;
+ * - a message the LOOP or the HOST synthesized (`syntheticUserMessage`) — the
+ *   truncated-reply nudge the loop inserts mid-turn, and the record an embedder
+ *   appends between turns for work that happened outside the conversation, such as
+ *   an analysis run's outcome. Both carry the `user` role for the wire format and
+ *   neither is user input. Reading one as a boundary would split one turn into
+ *   two: a drop would keep half a turn, and `retractLastTurn` would cut
+ *   its tail in the middle of a turn rather than at its head.
+ *
+ *   A host-appended record therefore belongs to the turn preceding it, so a tail
+ *   retraction that removes that turn removes the record with it. That is the
+ *   accepted consequence of the exclusion, not a defect — the alternative, letting
+ *   it open a turn, is the exact failure the marker exists to prevent.
+ *
+ * `GENUINE_USER_START_SQL` in `thread-history.ts` is the twin of this predicate over stored
+ * envelopes; the two are built from the same constants so they cannot drift.
+ */
+export function isGenuineUserStart(message) {
+    return message.role === "user" && !isSyntheticUserMessage(message);
+}
+/**
+ * Group rows (oldest-first) into turns at genuine-user-start boundaries.
+ * Generic over the row shape so the view rule and the display read
+ * (`loadAll`) share it, each supplying its own start predicate.
+ */
+export function groupTurns(rows, isStart) {
+    const turns = [];
+    for (const row of rows) {
+        if (turns.length === 0 || isStart(row)) {
+            turns.push([row]);
+        }
+        else {
+            turns[turns.length - 1].push(row);
+        }
+    }
+    return turns;
+}
+function isCompactionMessage(message) {
+    return compactionMarkerOf(message) !== undefined || compactionExchangeOf(message) !== undefined;
+}
+function startsTurn(entry) {
+    return isGenuineUserStart(entry.message);
+}
+function withoutReasoningEntries(entries) {
+    return entries.flatMap((entry) => {
+        const message = withoutReasoning(entry.message);
+        return message === undefined ? [] : [{ message, source: entry.source }];
+    });
+}
+function viewParts(messages, options) {
+    // The head ends at a marker or an exchange message too, thus the stored rows and a view that
+    // starts with the seed and a summary give the same head.
+    let headEnd = 0;
+    if (options.keepFirstTurn === true) {
+        while (headEnd < messages.length) {
+            const message = messages[headEnd];
+            if (isCompactionMessage(message) || (headEnd > 0 && isGenuineUserStart(message)))
+                break;
+            headEnd++;
+        }
+    }
+    const head = messages.slice(0, headEnd).map((message, source) => ({ message, source }));
+    let front;
+    let body = [];
+    for (let source = headEnd; source < messages.length; source++) {
+        const message = messages[source];
+        if (compactionExchangeOf(message) !== undefined)
+            continue;
+        const marker = compactionMarkerOf(message);
+        if (marker?.kind === "summary") {
+            front = { message, source };
+            body = [];
+        }
+        else if (marker?.kind === "drop") {
+            // The drop changes the prefix that the signature of each kept reasoning part binds.
+            const turns = groupTurns(body, startsTurn);
+            body = withoutReasoningEntries(turns.slice(Math.max(turns.length - marker.keptTurns, 0)).flat());
+        }
+        else {
+            body.push({ message, source });
+        }
+    }
+    return { head, front, body };
+}
+export function conversationView(messages, options) {
+    const { head, front, body } = viewParts(messages, options);
+    const entries = [...head, ...(front === undefined ? [] : [front]), ...body];
+    return { messages: entries.map((entry) => entry.message), sources: entries.map((entry) => entry.source) };
+}
+/** The message with no reasoning part, or `undefined` for an assistant message with no part left. */
+export function withoutReasoning(message) {
+    if (message.role !== "assistant" || typeof message.content === "string")
+        return message;
+    const content = message.content.filter((part) => part.type !== "reasoning" && part.type !== "reasoning-file");
+    if (content.length === message.content.length)
+        return message;
+    return content.length === 0 ? undefined : { ...message, content };
+}
+/** The estimate of the messages, by the count that the store writes to the `tokens` column. */
+export function viewTokens(messages) {
+    return messages.reduce((sum, message) => sum + countTokens(message.content), 0);
+}
+/** The count of the turns that a drop keeps: the newest turn, and each older turn while the view stays within `budget`. */
+export function keptTurnsForDrop(messages, options, budget) {
+    const { head, front, body } = viewParts(messages, options);
+    const turnTokens = groupTurns(body, startsTurn).map((turn) => viewTokens(withoutReasoningEntries(turn).map((entry) => entry.message)));
+    let total = viewTokens([...head, ...(front === undefined ? [] : [front])].map((entry) => entry.message));
+    let kept = 0;
+    for (let t = turnTokens.length - 1; t >= 0; t--) {
+        if (kept > 0 && total + turnTokens[t] > budget)
+            break;
+        total += turnTokens[t];
+        kept++;
+    }
+    return kept;
+}

package/dist/memory/count-tokens.d.ts

@@ -1,9 +1,7 @@
 /**
- * Write-time token counting for the conversation message store.
- *
- * `appendTurn` stamps a `tokens` count on every message row so `loadRecent`
- * windows by token budget without tokenizing on the read path. Counted once
- * at write, applied at load.
+ * Token counting for the conversation. The store stamps the count of each message
+ * row as its `tokens` column, and the loop estimates the view of a request with the
+ * same count. `loadRecent` has no budget.
  *
  * Providers do not publish one shared offline tokenizer,
  * so this uses `js-tiktoken`'s `cl100k_base` BPE. It is an approximation:
@@ -12,7 +10,7 @@
  */
 import type { ModelMessage } from "ai";
 /**
- * Token count of a message's content. Used only at write time. Empty
- * content (an empty array or empty string) counts as `0`.
+ * Token count of a message's content. Empty content (an empty array or empty
+ * string) counts as `0`.
  */
 export declare function countTokens(content: ModelMessage["content"]): number;

package/dist/memory/count-tokens.js

@@ -1,9 +1,7 @@
 /**
- * Write-time token counting for the conversation message store.
- *
- * `appendTurn` stamps a `tokens` count on every message row so `loadRecent`
- * windows by token budget without tokenizing on the read path. Counted once
- * at write, applied at load.
+ * Token counting for the conversation. The store stamps the count of each message
+ * row as its `tokens` column, and the loop estimates the view of a request with the
+ * same count. `loadRecent` has no budget.
  *
  * Providers do not publish one shared offline tokenizer,
  * so this uses `js-tiktoken`'s `cl100k_base` BPE. It is an approximation:
@@ -23,8 +21,8 @@ function enc() {
  * the text is prompt text. A file rides the wire as an attachment, and the
  * provider bills it at its own rate, thus its bytes count as `0` — the same rule
  * as a top-level `file` block. A file that is stringified into the count inflates
- * the row of the message by tens of thousands of tokens, and the load window then
- * drops the true history.
+ * the row of the message by tens of thousands of tokens, and the loop then
+ * compacts the view too early.
  *
  * Each other output arm is plain JSON, thus it is stringified whole.
  */
@@ -76,8 +74,8 @@ function tokenizableText(block) {
     }
 }
 /**
- * Token count of a message's content. Used only at write time. Empty
- * content (an empty array or empty string) counts as `0`.
+ * Token count of a message's content. Empty content (an empty array or empty
+ * string) counts as `0`.
  */
 export function countTokens(content) {
     if (typeof content === "string") {