@inhuman.tools/turn 0.0.0-stage → 0.1.0

package/dist/context/transcript.js

@@ -0,0 +1,659 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+/**
+ * Compact-strategy transcript: an ordered eat slice plus the cap that rides it.
+ *
+ * Cells are completions, tool calls, card/ack message chunks, or text cells.
+ *
+ * THE WALK: `walkTranscript` is the only eat iteration. A cutoff
+ * (`CompactJob`) projects the retained context; a completion anchors a round; tools and scheme
+ * programs attach to the open completion. Notification cells, approval notes,
+ * and steers collect parallel to tools — they never anchor or break a round.
+ * Inner scheme invocations
+ * live on `ProgrammaticJob` children, not this walk. `messagesFrom` and
+ * `Transcript.fromWork` walk it. Remaining eat cells
+ * (`MessageChunk`, text cell) yield `cell` so `fromWork` stays a walk —
+ * the last-eat and rounds views ignore them. A new chunk kind is a union
+ * member plus per-view handling. An uncommitted compact, prompt, ReACT, and
+ * non-eat values are silent.
+ *
+ * Rounds here group the materialized cell list so cutoff card cells
+ * can themselves be rounds. A successful `CompactJob` replaces the prefix and
+ * marks its `card` cells as prior cards
+ * (`transcript/compaction-results`). Cells before the first round anchor
+ * (prior cards) belong to the oldest slice: `sliceRounds(0, …)` starts at
+ * cell 0, so prefix ∪ keep = full.
+ *
+ * Occupancy: a stamped `totalTokens` is `usage.total_tokens` of that call —
+ * prompt + response, where the prompt carries the whole history. It is a
+ * monotone window GAUGE, not a per-cell weight; summing it across completions
+ * over-counts quadratically. `tokensUsed()` therefore diffs the gauge at the
+ * slice boundary (`baseGauge` = last reading before the slice) and falls back
+ * to `contentTokensOf` (ceil chars/4) for cells past the last reading.
+ * `contentTokensOf` is the raw content meter (`tokens/count`).
+ *
+ * There is no card-kind field on `CompletionExpectation`; card identity is the
+ * card set (plus `MessageChunk.card`). That is the hook the models
+ * give us today.
+ */
+import { arrival } from "@here.build/arrival/host-internals";
+import { CompactJob, CompletionExpectation, contextNeedFromChunks, DEFAULT_COMPACT_KEEP_TURNS as COMPACT_KEEP_DIAL, jobTriggersReactLoop, ProgrammaticJob, SessionRoot, SessionTurn, tapeCompletion, ToolCallJob, TurnApprovalNoteChunk, TurnNotificationChunk, TurnSteerChunk, } from "@inhuman.tools/harness-model";
+import { keepFloorsOfJob } from "./compact-floors.js";
+import { compactToolLine, toolCallRepresentation } from "./squeeze.js";
+export class MessageChunk {
+    role;
+    text;
+    ack;
+    checkIn;
+    constructor(role, text, flags) {
+        this.role = role;
+        this.text = text;
+        this.ack = flags?.ack === true;
+        this.checkIn = flags?.checkIn === true;
+    }
+    asCheckIn() {
+        return this.checkIn ? this : new MessageChunk(this.role, this.text, { ack: this.ack, checkIn: true });
+    }
+}
+export function turnSpine(turn) {
+    return [...turn.doneWork, ...turn.queue];
+}
+/** Compact-dropped `read_file` jobs are not in this projection (compact policy). */
+export function historyBehind(turn, read) {
+    const ctx = historyRead(turn, read);
+    const own = messagesFrom(turnSpine(turn), ctx, () => turn.turnTail instanceof SessionTurn ? historyBehind(turn.turnTail, read) : []);
+    return finishHistory(own, () => (turn.turnTail instanceof SessionTurn ? historyBehind(turn.turnTail, read) : []));
+}
+/** Eat a successful compact saw: history strictly before the job, tail included. */
+export function eatBeforeCompact(turn, job, read) {
+    const ctx = historyRead(turn, read);
+    const own = messagesFrom(turnSpine(turn), ctx, () => (turn.turnTail instanceof SessionTurn ? historyBehind(turn.turnTail, read) : []), job);
+    return finishHistory(own, () => (turn.turnTail instanceof SessionTurn ? historyBehind(turn.turnTail, read) : []));
+}
+function finishHistory(own, tail) {
+    if (own.anchored)
+        return own.messages;
+    if (own.replaced || own.messages.length > 0)
+        return [...own.messages, ...own.pending];
+    return [...tail(), ...own.pending];
+}
+function historyRead(turn, read) {
+    return {
+        tailNeed: turn.turnTail instanceof SessionTurn ? turn.turnTail.contextNeed : null,
+        kv: read?.kv ?? sessionKv(turn),
+        configFloor: read?.configFloor != null && read.configFloor >= 1 ? read.configFloor : COMPACT_KEEP_DIAL,
+    };
+}
+function sessionKv(turn) {
+    const parent = turn.parent;
+    if (parent instanceof SessionRoot)
+        return parent.kvs;
+    return {};
+}
+function messagesFrom(chunks, read, seed, stopBefore) {
+    let eaten = null;
+    let last = null;
+    const tools = [];
+    const notifies = [];
+    const notes = [];
+    const steers = [];
+    const resetRound = () => {
+        last = null;
+        tools.length = 0;
+        notifies.length = 0;
+        notes.length = 0;
+        steers.length = 0;
+    };
+    for (const event of walkTranscript(chunks)) {
+        switch (event.kind) {
+            case "compact": {
+                const eat = last != null
+                    ? [...last.messages, last, ...tools, ...notifies, ...notes, ...steers]
+                    : [...(eaten ?? seed()), ...notifies, ...notes, ...steers];
+                if (stopBefore != null && event.chunk === stopBefore) {
+                    return {
+                        messages: eat,
+                        anchored: last != null,
+                        replaced: true,
+                        pending: [],
+                    };
+                }
+                eaten = projectCompactMessages(eat, event.chunk, chunks, read);
+                resetRound();
+                break;
+            }
+            case "completion": {
+                last = event.chunk;
+                tools.length = 0;
+                notifies.length = 0;
+                notes.length = 0;
+                steers.length = 0;
+                break;
+            }
+            case "tool": {
+                if (jobTriggersReactLoop(event.chunk))
+                    tools.push(event.chunk);
+                break;
+            }
+            case "scheme": {
+                tools.push(event.chunk);
+                break;
+            }
+            case "notify": {
+                notifies.push(event.chunk);
+                break;
+            }
+            case "approval-note": {
+                notes.push(event.chunk);
+                break;
+            }
+            case "steer": {
+                steers.push(event.chunk);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (last != null) {
+        return {
+            messages: [...last.messages, last, ...tools, ...notifies, ...notes, ...steers],
+            anchored: true,
+            replaced: false,
+            pending: [],
+        };
+    }
+    return {
+        messages: eaten ?? [],
+        anchored: false,
+        replaced: eaten != null,
+        pending: [...notifies, ...notes, ...steers],
+    };
+}
+export function* walkTranscript(chunks) {
+    for (const chunk of chunks) {
+        if (chunk instanceof CompactJob && chunk.cutoff) {
+            yield { kind: "compact", chunk };
+            continue;
+        }
+        const pew = tapeCompletion(chunk);
+        if (pew != null) {
+            yield { kind: "completion", chunk: pew };
+            continue;
+        }
+        if (chunk instanceof CompletionExpectation) {
+            yield { kind: "completion", chunk };
+            continue;
+        }
+        if (chunk instanceof ToolCallJob) {
+            yield { kind: "tool", chunk };
+        }
+        else if (chunk instanceof ProgrammaticJob) {
+            yield { kind: "scheme", chunk };
+        }
+        else if (chunk instanceof TurnNotificationChunk) {
+            yield { kind: "notify", chunk };
+        }
+        else if (chunk instanceof TurnApprovalNoteChunk) {
+            yield { kind: "approval-note", chunk };
+        }
+        else if (chunk instanceof TurnSteerChunk) {
+            yield { kind: "steer", chunk };
+        }
+        else if (typeof chunk === "string" || chunk instanceof MessageChunk) {
+            yield { kind: "cell", chunk };
+        }
+    }
+}
+let Transcript = (() => {
+    var _a;
+    let _classDecorators = [(_a = arrival).private.bind(_a)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Transcript = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Transcript = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        cells;
+        cap;
+        static empty(cap = 0) {
+            return new Transcript([], cap);
+        }
+        static fromCells(cells, cap, cards) {
+            return new Transcript(cells, cap ?? inferCap(cells), cards);
+        }
+        static fromWork(work, cap) {
+            const cells = [];
+            const cards = new Set();
+            for (const event of walkTranscript(work)) {
+                if (event.kind === "compact") {
+                    const projected = projectCompactMessages(cells, event.chunk, work, {
+                        tailNeed: null,
+                        kv: {},
+                        configFloor: COMPACT_KEEP_DIAL,
+                    });
+                    cells.length = 0;
+                    cards.clear();
+                    for (const cell of projected) {
+                        cells.push(cell);
+                        if (cell instanceof CompactJob)
+                            cards.add(cell);
+                    }
+                    continue;
+                }
+                cells.push(event.chunk);
+            }
+            return new Transcript(cells, cap ?? inferCap(cells), cards);
+        }
+        /** Occupancy window start — see preamble. */
+        baseGauge;
+        checkIns;
+        constructor(cells, cap, checkIns, baseGauge = 0) {
+            this.cells = cells;
+            this.cap = cap;
+            this.baseGauge = baseGauge;
+            this.checkIns = checkIns instanceof Set ? checkIns : new Set(checkIns);
+        }
+        isCheckIn(cell) {
+            return this.checkIns.has(cell) || cell instanceof CompactJob || (cell instanceof MessageChunk && cell.checkIn);
+        }
+        checkInCells() {
+            return this.cells.filter((cell) => this.isCheckIn(cell));
+        }
+        /** The transcript without its prior-card cells: what happened since, not what was already folded. */
+        withoutCheckIns() {
+            return new Transcript(this.cells.filter((cell) => !this.isCheckIn(cell)), this.cap, [], this.baseGauge);
+        }
+        sliceCells(from, to = this.cells.length) {
+            const lo = Math.max(0, from);
+            const hi = Math.min(this.cells.length, to);
+            const sliced = this.cells.slice(lo, hi);
+            let baseGauge = this.baseGauge;
+            for (let i = Math.min(lo, this.cells.length) - 1; i >= 0; i--) {
+                const cell = this.cells[i];
+                if (cell instanceof CompletionExpectation && cell.totalTokens != null && cell.totalTokens > 0) {
+                    baseGauge = cell.totalTokens;
+                    break;
+                }
+            }
+            return new Transcript(sliced, this.cap, this.checkIns, baseGauge);
+        }
+        /** `sliceRounds(0, …)` includes prior cards — see preamble. */
+        sliceRounds(from, to) {
+            const rounds = this.rounds();
+            if (from >= to || rounds.length === 0) {
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            }
+            const start = from === 0 ? 0 : (rounds[from]?.start ?? this.cells.length);
+            const end = rounds[to - 1]?.end ?? start;
+            return this.sliceCells(start, end);
+        }
+        rounds() {
+            const out = [];
+            let response = null;
+            let toolCalls = [];
+            let start = 0;
+            const flush = (end) => {
+                if (response == null)
+                    return;
+                out.push({
+                    start,
+                    end,
+                    prompt: response.userPrompt,
+                    response,
+                    toolCalls,
+                });
+                response = null;
+                toolCalls = [];
+            };
+            for (const [i, cell_] of this.cells.entries()) {
+                const cell = cell_;
+                if (cell instanceof CompletionExpectation) {
+                    flush(i);
+                    response = cell;
+                    start = i;
+                }
+                else if ((cell instanceof ToolCallJob || cell instanceof ProgrammaticJob) && response != null) {
+                    toolCalls.push(cell);
+                }
+            }
+            flush(this.cells.length);
+            return out;
+        }
+        /** Occupancy — see preamble. */
+        tokensUsed() {
+            let lastGauge = -1;
+            let lastIndex = -1;
+            for (let i = 0; i < this.cells.length; i++) {
+                const cell = this.cells[i];
+                if (cell instanceof CompletionExpectation && cell.totalTokens != null && cell.totalTokens > 0) {
+                    lastGauge = cell.totalTokens;
+                    lastIndex = i;
+                }
+            }
+            if (lastIndex === -1)
+                return contentTokensOf(this.cells);
+            const gauged = Math.max(0, lastGauge - this.baseGauge);
+            return gauged + contentTokensOf(this.cells.slice(lastIndex + 1));
+        }
+        /**
+         * The frontier is the OLDEST round of this transcript. During the classify
+         * walk `preserve-transcript` runs frontier → newest (chronological), so the
+         * round being decided is the first one.
+         */
+        frontierRound() {
+            const rounds = this.rounds();
+            if (rounds.length === 0)
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            return this.sliceRounds(0, 1);
+        }
+        /** `transcript/newer`: preserve without the frontier — drop the oldest round. */
+        withoutFrontier() {
+            const rounds = this.rounds();
+            if (rounds.length <= 1)
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            return this.sliceRounds(1, rounds.length);
+        }
+        /** `transcript/older`: compact without the frontier — drop the newest round. */
+        withoutNewest() {
+            const rounds = this.rounds();
+            if (rounds.length <= 1)
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            return this.sliceRounds(0, rounds.length - 1);
+        }
+        completeRounds() {
+            const rounds = this.rounds();
+            if (rounds.length === 0)
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            const last = rounds.at(-1);
+            if (last && isRoundComplete(last))
+                return this.sliceRounds(0, rounds.length);
+            if (rounds.length === 1)
+                return new Transcript([], this.cap, this.checkIns, this.baseGauge);
+            return this.sliceRounds(0, rounds.length - 1);
+        }
+        partialRound() {
+            const rounds = this.rounds();
+            if (rounds.length === 0)
+                return null;
+            const last = rounds.at(-1);
+            if (last && isRoundComplete(last))
+                return null;
+            return this.sliceRounds(rounds.length - 1, rounds.length);
+        }
+        concat(other) {
+            const checkIns = new Set(this.checkIns);
+            for (const cell of other.checkIns)
+                checkIns.add(cell);
+            for (const cell of other.cells) {
+                if (other.isCheckIn(cell))
+                    checkIns.add(cell);
+            }
+            return new Transcript([...this.cells, ...other.cells], this.cap || other.cap, checkIns, this.baseGauge);
+        }
+    };
+    return Transcript = _classThis;
+})();
+export { Transcript };
+/**
+ * Content-token stand-in: `ceil(chars / 4)`. Replace this one function when
+ * per-cell prompt/response tokens exist on the model.
+ */
+export function estimateTokens(text) {
+    if (text.length === 0)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+/** Content meter — see preamble. */
+export function contentTokensOf(cells) {
+    let used = 0;
+    for (const cell of cells)
+        used += estimateTokens(textOfCell(cell));
+    return used;
+}
+export function charsOf(cells) {
+    let n = 0;
+    for (const cell of cells)
+        n += textOfCell(cell).length;
+    return n;
+}
+export function inferCap(cells, fallback = 0) {
+    for (let i = cells.length - 1; i >= 0; i--) {
+        const cell = cells[i];
+        if (cell instanceof CompletionExpectation && (cell.contextLimit ?? 0) > 0) {
+            return cell.contextLimit ?? 0;
+        }
+    }
+    return fallback;
+}
+export function payloadSuffix(transcript, n) {
+    const cells = transcript.cells.filter((cell) => !transcript.isCheckIn(cell));
+    if (n <= 0 || cells.length === 0)
+        return [];
+    const start = Math.max(0, cells.length - Math.floor(n));
+    let owner = start;
+    while (owner > 0 &&
+        (cells[owner] instanceof ToolCallJob ||
+            cells[owner] instanceof ProgrammaticJob ||
+            cells[owner] instanceof TurnNotificationChunk ||
+            cells[owner] instanceof TurnApprovalNoteChunk ||
+            cells[owner] instanceof TurnSteerChunk)) {
+        owner--;
+    }
+    if (!(cells[owner] instanceof CompletionExpectation))
+        owner = start;
+    return cells.slice(owner);
+}
+function isRoundComplete(round) {
+    const requested = round.response.responseCalls.length;
+    const hasResponse = round.response.responseText !== "" || (round.response.totalTokens ?? 0) > 0;
+    if (requested === 0)
+        return hasResponse;
+    if (round.toolCalls.length < requested)
+        return false;
+    return round.toolCalls.every((tool) => {
+        const json = tool instanceof ToolCallJob ? tool.sealedOutcomeJson() : tool.receiptJson;
+        return json != null && json !== "";
+    });
+}
+/** Floors are non-zero by default; a single-round eat legitimately keeps all. */
+export function sliceCompactEat(eat, floors) {
+    const rounds = eat.rounds();
+    const emptyKeep = eat.sliceCells(eat.cells.length);
+    if (rounds.length === 0)
+        return { prefix: eat, keep: emptyKeep };
+    let keepRounds = floors.rounds;
+    const userTurns = floors.userTurns;
+    if (keepRounds > 0 || userTurns > 0)
+        keepRounds = Math.max(keepRounds, 1);
+    let keepFrom = rounds.length;
+    if (keepRounds > 0)
+        keepFrom = Math.min(keepFrom, Math.max(0, rounds.length - keepRounds));
+    if (userTurns > 0) {
+        let counted = 0;
+        let idx = rounds.length;
+        for (let i = rounds.length - 1; i >= 0; i -= 1) {
+            if (rounds[i].prompt !== "")
+                counted += 1;
+            idx = i;
+            if (counted >= userTurns)
+                break;
+        }
+        if (counted > 0)
+            keepFrom = Math.min(keepFrom, idx);
+    }
+    // Preserve floors are a preference, not a right to keep everything. Clamp so
+    // >= 2 rounds always leaves one round in the prefix. One round still keeps all.
+    if (rounds.length >= 2 && keepFrom < 1)
+        keepFrom = 1;
+    if (keepFrom >= rounds.length)
+        return { prefix: eat, keep: emptyKeep };
+    if (keepFrom <= 0)
+        return { prefix: eat.sliceRounds(0, 0), keep: eat };
+    return {
+        prefix: eat.sliceRounds(0, keepFrom),
+        keep: eat.sliceRounds(keepFrom, rounds.length),
+    };
+}
+/**
+ * Keep is {@link sliceCompactEat}'s suffix. Squeeze is up to `floors.rounds`
+ * rounds immediately before that keep, taken from the prefix. If the squeeze
+ * would empty the prefix and at least two rounds exist, shrink the squeeze
+ * (to zero when the prefix is a single round) so one round stays in it.
+ */
+export function sliceCompactZones(eat, floors) {
+    const sliced = sliceCompactEat(eat, floors);
+    const empty = eat.sliceRounds(0, 0);
+    const prefixRounds = sliced.prefix.rounds();
+    let squeezeCount = Math.min(Math.max(0, floors.rounds), prefixRounds.length);
+    if (eat.rounds().length >= 2 && prefixRounds.length - squeezeCount < 1) {
+        squeezeCount = Math.max(0, prefixRounds.length - 1);
+    }
+    if (squeezeCount <= 0)
+        return { prefix: sliced.prefix, squeeze: empty, keep: sliced.keep };
+    const prefixEnd = prefixRounds.length - squeezeCount;
+    return {
+        prefix: sliced.prefix.sliceRounds(0, prefixEnd),
+        squeeze: sliced.prefix.sliceRounds(prefixEnd, prefixRounds.length),
+        keep: sliced.keep,
+    };
+}
+/** Squeeze band as role rows, then keep cells verbatim. The card is separate. */
+export function projectCompactRows(eat, floors) {
+    const zones = sliceCompactZones(eat, floors);
+    const rows = [];
+    for (const round of zones.squeeze.rounds()) {
+        const promptText = round.prompt.trim();
+        const response = round.response.responseText.trim();
+        if (promptText !== "")
+            rows.push({ kind: "user", text: promptText });
+        if (response !== "")
+            rows.push({ kind: "assistant", text: response });
+        for (const tool of round.toolCalls) {
+            if (tool instanceof ToolCallJob && !jobTriggersReactLoop(tool))
+                continue;
+            const line = compactToolLine(tool).trim();
+            if (line === "")
+                continue;
+            const name = (tool instanceof ToolCallJob ? tool.name : tool.toolName).trim();
+            rows.push({
+                kind: "user",
+                text: `[${name === "" ? "tool" : name}] ${line}`,
+            });
+        }
+    }
+    for (const cell of zones.keep.cells) {
+        if (cell instanceof MessageChunk)
+            continue;
+        if (isCompletionMessage(cell))
+            rows.push({ kind: "keep", cell });
+    }
+    return { zones, rows };
+}
+/**
+ * The card is the `CompactJob` itself, a typed cell (F10): `Transcript` then
+ * knows it is a prior card, and `transcript/compaction-results` is no longer
+ * always empty. Its text is `standIn`.
+ */
+export function projectionMessages(card, rows) {
+    const out = [];
+    if (card.standIn.trim() !== "")
+        out.push(card);
+    for (const row of rows) {
+        if (row.kind === "keep")
+            out.push(row.cell);
+        else if (row.text !== "")
+            out.push(row.text);
+    }
+    return out;
+}
+function floorsFor(job, chunks, read) {
+    const index = chunks.indexOf(job);
+    const before = index === -1 ? chunks : chunks.slice(0, index);
+    const need = contextNeedFromChunks(before, read.tailNeed);
+    return keepFloorsOfJob(job, need, read);
+}
+/** Card, squeeze lines, and verbatim keep cells for the wire and the next eat. */
+export function compactLeadRows(turn, job, read) {
+    const ctx = historyRead(turn, read);
+    const eat = eatBeforeCompact(turn, job, read);
+    const { rows } = projectCompactRows(Transcript.fromCells(eat), floorsFor(job, turnSpine(turn), ctx));
+    const card = job.standIn.trim();
+    return card === "" ? rows : [{ kind: "user", text: card }, ...rows];
+}
+function projectCompactMessages(eat, job, chunks, read) {
+    const { rows } = projectCompactRows(Transcript.fromCells(eat), floorsFor(job, chunks, read));
+    return projectionMessages(job, rows);
+}
+function isCompletionMessage(cell) {
+    return !(cell instanceof MessageChunk);
+}
+export function textOfCell(cell) {
+    if (typeof cell === "string")
+        return cell;
+    if (cell instanceof CompactJob)
+        return cell.standIn.trim();
+    if (cell instanceof MessageChunk)
+        return cell.text;
+    if (cell instanceof TurnNotificationChunk)
+        return cell.notificationText();
+    if (cell instanceof TurnApprovalNoteChunk)
+        return cell.approvalNoteText();
+    if (cell instanceof TurnSteerChunk)
+        return cell.completionMessage;
+    if (cell instanceof ToolCallJob) {
+        const scheme = cell.children.find((child) => child instanceof ProgrammaticJob);
+        if (scheme !== undefined) {
+            return `scheme ${scheme.expr} ${scheme.resultText()}`.trim();
+        }
+        const painted = toolCallRepresentation(cell);
+        return `${painted.name} ${painted.args} ${painted.result}`.trim();
+    }
+    if (cell instanceof ProgrammaticJob) {
+        return `scheme ${cell.expr} ${cell.resultText()}`.trim();
+    }
+    const pew = tapeCompletion(cell) ?? (cell instanceof CompletionExpectation ? cell : null);
+    if (pew != null) {
+        return `${pew.userPrompt}\n${pew.responseText}`.trim();
+    }
+    return "";
+}
+//# sourceMappingURL=transcript.js.map