@plurnk/plurnk-digest 2.0.0 → 3.1.0

package/dist/DigestRender.js

@@ -1,7 +1,7 @@
 // Digest renderers ({§digest-programmatic-surface}): the markdown, JSON, reasoning, and packet
 // artifacts of one DigestModel, reading heavy evidence on demand through DigestEvidence.
 import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, posix } from "node:path";
 import { aggregateProviderAccounting, } from "@plurnk/plurnk-providers";
 import { Validator } from "@plurnk/plurnk-contracts";
 import { EDIT_FORMS } from "./digest-rows.js";
@@ -11,6 +11,26 @@ function* projectRows(rows, project) {
         yield project(row);
 }
 export default class DigestRender {
+    static #literal(body, language = "text") {
+        let length = 3;
+        for (const match of body.matchAll(/`+/gu))
+            length = Math.max(length, match[0].length + 1);
+        const fence = "`".repeat(length);
+        return `${fence}${language}\n${body}\n${fence}`;
+    }
+    static #link(from, target, label) {
+        return `[${label}](${posix.relative(posix.dirname(from), target)})`;
+    }
+    static #turnLinks(m, turn, from) {
+        const stem = DigestRender.packetStems(m).get(turn.id);
+        if (stem === undefined)
+            return [];
+        return [
+            ...(turn.has_packet === 1 ? [DigestRender.#link(from, `${stem}.request.md`, "Input")] : []),
+            ...(turn.program !== null ? [DigestRender.#link(from, `${stem}.assistant.md`, "Output")] : []),
+            ...(turn.has_reasoning === 1 ? [DigestRender.#link(from, `${stem}.reasoning.md`, "Reasoning")] : []),
+        ];
+    }
     static #summarize(text, n = 80) {
         if (text === null || text === undefined)
             return "";
@@ -217,18 +237,13 @@ export default class DigestRender {
         const { packet } = m.evidence.packet(turn);
         if (packet === null)
             return null;
-        return packet.messages(DigestRender.#emissionsOf(turn, m))
+        const messages = packet.messages();
+        if (messages.length === 0)
+            return null;
+        return messages
             .map(({ role, content }) => `${role}\n${content}`)
             .join("\n");
     }
-    // {§emission-row} — the emissions the turn's worker announced; a stored request places those its log
-    // section carried.
-    static #emissionsOf(turn, m) {
-        const loop = m.loopsById.get(turn.loop_id);
-        if (loop === undefined)
-            throw new Error(`digest: turn ${turn.id} names loop ${turn.loop_id}, which the digest did not read`);
-        return m.emissionsByWorker.get(loop.worker_id) ?? new Map();
-    }
     static #commonPrefixLength(left, right) {
         const bound = Math.min(left.length, right.length);
         let n = 0;
@@ -479,8 +494,11 @@ export default class DigestRender {
             : null;
         // {§provider-wire-emission} — an empty emission is read from what the wire carried, never guessed at.
         const wireLine = content.length === 0 && packet?.assistant != null ? DigestRender.wireLine(packet.assistantRaw) : null;
+        const roles = packet?.messages().map(({ role }) => role).join(" → ");
+        const requestLine = packet === null ? null
+            : `  ↳ request: ${roles || "input sections not retained"} (${stem}.request.md)`;
         const opLines = DigestRender.#renderOpLines(m.logEntriesByTurn.get(turn.id) ?? [], m);
-        return [head, ...(summary ? [summary] : []), ...(reasoningLine ? [reasoningLine] : []), ...(wireLine ? [wireLine] : []), ...opLines].join("\n");
+        return [head, ...(requestLine ? [requestLine] : []), ...(summary ? [summary] : []), ...(reasoningLine ? [reasoningLine] : []), ...(wireLine ? [wireLine] : []), ...opLines].join("\n");
     }
     // {§provider-wire-emission} — public so the line can be witnessed on its own.
     static wireLine(assistantRaw) {
@@ -541,12 +559,55 @@ export default class DigestRender {
             `Tokens:     ${usageStr}`,
             `Cost:       ${costStr}${kindStr}${usagelessStr}`,
             `Wire:       ${wireStr}`,
+            `Room:       ${DigestRender.#renderRoom(worker, m)}`,
             `Op mix:     ${opMix.length > 0 ? opMix : "(no ops)"}`,
             `EDITs:      ${DigestRender.#renderEditCensus(DigestRender.#editCensus(m).byWorker.get(worker.id))}`,
             `Emissions:  ${DigestRender.#renderEmissions(worker, m)}`,
             `Reasonings: ${DigestRender.#renderReasonings(worker, m)}`,
         ].join("\n");
     }
+    // {§digest-room-line} — the room in provider tokens: the largest budget the model was shown, at its
+    // request's own ratio, against the capacity; the wall's estimate against the provider's count; and the
+    // requests the estimate put under the wall while the count was over it.
+    static #renderRoom(worker, m) {
+        const measured = DigestRender.#roomMeasures(worker, m);
+        if (measured.length === 0)
+            return "(no measured requests)";
+        const room = Math.max(...measured.map(({ weight, budget, count, capacity }) => budget * count / weight / capacity));
+        const errors = measured.map(({ estimate, count }) => (estimate - count) / count);
+        const missed = measured.filter(({ estimate, count, wall }) => estimate <= wall && count > wall).length;
+        const percent = (ratio) => `${ratio < 0 ? "-" : "+"}${Math.abs(100 * ratio).toFixed(1)}%`;
+        return `budget up to ${Math.round(100 * room)}% of capacity · wall estimate ${percent(Math.min(...errors))} to ${percent(Math.max(...errors))} of the count`
+            + (missed === 0 ? "" : `  ⚠ ${missed} over the wall the estimate admitted`);
+    }
+    // One measure per packet-bearing inference turn whose request records a known capacity and wall and a
+    // provider count: the exact preflight measurement, else the reported input.
+    static #roomMeasures(worker, m) {
+        const measures = [];
+        for (const loop of m.loopsByWorker.get(worker.id) ?? []) {
+            for (const turn of m.turnsByLoop.get(loop.id) ?? []) {
+                if (turn.kind !== "inference" || turn.has_packet !== 1)
+                    continue;
+                const packet = m.evidence.packet(turn).packet;
+                if (packet === null || packet.budget === null || packet.budget === 0 || packet.weight === 0)
+                    continue;
+                const call = m.modelCalls.findLast((row) => row.turn_id === turn.id && row.kind === "emission" && row.capacity !== null);
+                const capacity = DigestRender.parseJson(call?.capacity);
+                if (capacity?.inputCapacity == null || capacity.inputWall == null)
+                    continue;
+                const reported = (m.requestsByTurn.get(turn.id) ?? [])
+                    .findLast((row) => row.kind === "emission" && row.outcome === "response" && row.usage_input !== null)?.usage_input ?? null;
+                const count = capacity.prompt?.kind === "exact" ? capacity.prompt.tokens ?? null : reported;
+                if (count === null || count === 0)
+                    continue;
+                measures.push({
+                    weight: packet.weight, budget: packet.budget, capacity: capacity.inputCapacity, wall: capacity.inputWall, count,
+                    estimate: Math.ceil(packet.weight * capacity.inputCapacity / packet.budget),
+                });
+            }
+        }
+        return measures;
+    }
     // {§emission-row} — announced, retired by the model, and echoed back as headings in its own text.
     static #renderEmissions(worker, m) {
         const rows = m.emissionRows.filter((row) => row.worker_id === worker.id);
@@ -603,6 +664,7 @@ export default class DigestRender {
             for (const worker of workspaceWorkers) {
                 lines.push("");
                 lines.push(`### Worker #${worker.id} — ${worker.name}`);
+                lines.push(`Owner: ${worker.owner}`);
                 lines.push("");
                 lines.push("```");
                 lines.push(DigestRender.#renderWorkerShape(worker, m));
@@ -629,24 +691,15 @@ export default class DigestRender {
                     if (loop.status !== 200 && terminal?.problem?.detail !== undefined) {
                         lines.push(`Terminal${loop.terminated_by !== null ? ` (${loop.terminated_by})` : ""}: ${terminal.problem.detail.trim()}`);
                     }
-                    const policy = DigestRender.parseJson(loop.policy, {});
-                    const policySummary = Object.entries(policy)
-                        .map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`)
-                        .join(" ");
-                    if (policySummary.length > 0)
-                        lines.push(`Policy: ${policySummary}`);
+                    lines.push("");
+                    lines.push("| Turn | Packet artifacts | Physical requests |", "| --- | --- | --- |");
+                    for (const turn of m.turnsByLoop.get(loop.id) ?? []) {
+                        const requests = (m.requestsByTurn.get(turn.id) ?? []).map((request) => DigestRender.#link("digest.md", `requests/${request.id}.md`, `${request.id}: ${request.kind} ${request.outcome ?? request.state}`));
+                        lines.push(`| ${turn.sequence} (${turn.kind}) | ${DigestRender.#turnLinks(m, turn, "digest.md").join(" · ") || "—"} | ${requests.join(" · ") || "—"} |`);
+                    }
                     lines.push("");
                     const turnLines = (m.turnsByLoop.get(loop.id) ?? []).map((t) => DigestRender.#renderTurnLine(t, m));
-                    const findMaxTicks = (s) => {
-                        const matches = s.match(/`+/g);
-                        return matches ? Math.max(...matches.map((match) => match.length)) : 0;
-                    };
-                    const maxBackticks = turnLines.reduce((max, line) => Math.max(max, findMaxTicks(line)), 0);
-                    const fence = "`".repeat(Math.max(3, maxBackticks + 1));
-                    lines.push(fence);
-                    for (const line of turnLines)
-                        lines.push(line);
-                    lines.push(fence);
+                    lines.push(DigestRender.#literal(turnLines.join("\n"), ""));
                 }
             }
         }
@@ -667,7 +720,7 @@ export default class DigestRender {
                 lines.push("(operation turn; no provider inference)");
                 const reasoning = m.evidence.reasoning(t);
                 if (reasoning !== null)
-                    lines.push("", reasoning);
+                    lines.push("", DigestRender.#literal(reasoning));
                 continue;
             }
             const attempts = m.attemptsByTurn.get(t.id) ?? [];
@@ -680,13 +733,14 @@ export default class DigestRender {
                 if (packetFailure !== null)
                     lines.push("(stored provider packet is invalid; see its packet artifacts)");
                 else if (typeof reasoning === "string" && reasoning.length > 0)
-                    lines.push(reasoning);
+                    lines.push(DigestRender.#literal(reasoning));
                 else
                     lines.push("(no admitted provider reasoning)");
                 continue;
             }
             for (const attempt of attempts) {
-                const response = DigestRender.parseJson(m.evidence.response(attempt.model_call_id), {});
+                const retainedResponse = m.evidence.response(attempt.model_call_id);
+                const response = DigestRender.parseJson(retainedResponse, {});
                 const parseErrors = DigestRender.parseJson(attempt.parse_errors, []);
                 lines.push("");
                 const disposition = attempt.state === "error"
@@ -703,7 +757,7 @@ export default class DigestRender {
                     lines.push(`Failure: ${JSON.stringify(DigestRender.parseJson(attempt.failure, attempt.failure))}`);
                 }
                 for (const request of m.requestsByAttempt.get(attempt.id) ?? []) {
-                    lines.push(`Physical request ${request.sequence}: [${request.state === "settled" ? request.outcome : request.state} evidence](requests/${request.id}.json)`);
+                    lines.push(`Physical request ${request.sequence}: [${request.state === "settled" ? request.outcome : request.state} evidence](requests/${request.id}.md)`);
                 }
                 if (attempt.accepted !== 1) {
                     for (const error of parseErrors) {
@@ -714,7 +768,9 @@ export default class DigestRender {
                 }
                 const reasoning = response.assistant?.reasoning ?? null;
                 if (typeof reasoning === "string" && reasoning.length > 0)
-                    lines.push(reasoning);
+                    lines.push(DigestRender.#literal(reasoning));
+                else if (retainedResponse === null && attempt.state === "response")
+                    lines.push("(response evidence is not retained; readable reasoning availability is unknown)");
                 else {
                     const reasoningTokens = DigestRender.#accounting(m.requestsByAttempt.get(attempt.id) ?? [])?.usage?.outputTokenDetails?.reasoningTokens;
                     lines.push(reasoningTokens !== undefined && reasoningTokens > 0
@@ -726,6 +782,108 @@ export default class DigestRender {
         }
         return lines.join("\n");
     }
+    // {§share-packet-names}: render the owned envelope, never infer roles from filenames or body text.
+    static request(messages, preamble = []) {
+        const blocks = messages.map(({ role, content }, index) => {
+            return `### ${index + 1}. ${role}\n\n${DigestRender.#literal(content)}`;
+        });
+        return ["# Request", ...preamble, "## Input messages", messages.map(({ role }) => role).join(" → "),
+            messages.length === 0 ? "No input message sections are retained; the original input cannot be reconstructed."
+                : "Stored text-message envelope, not a transport capture. Native payloads and provider transformations are not shown.",
+            ...blocks, ""].join("\n\n");
+    }
+    // {§digest-navigation}: navigation surrounds evidence; channel files stay verbatim.
+    static #requestPreamble(m, turn) {
+        const stems = DigestRender.packetStems(m);
+        const stem = stems.get(turn.id);
+        const from = `${stem}.request.md`;
+        const loop = m.loopsById.get(turn.loop_id);
+        const siblings = m.turns.filter((row) => row.has_packet === 1
+            && m.loopsById.get(row.loop_id)?.worker_id === loop.worker_id).toSorted((a, b) => a.id - b.id);
+        const index = siblings.findIndex(({ id }) => id === turn.id);
+        const previous = siblings[index - 1];
+        const next = siblings[index + 1];
+        const navigation = [
+            DigestRender.#link(from, "digest.md", "Digest"),
+            ...(previous === undefined ? [] : [DigestRender.#link(from, `${stems.get(previous.id)}.request.md`, "Previous")]),
+            ...(next === undefined ? [] : [DigestRender.#link(from, `${stems.get(next.id)}.request.md`, "Next")]),
+            ...DigestRender.#turnLinks(m, turn, from).filter((link) => !link.startsWith("[Input]")),
+        ];
+        const lines = [posix.basename(stem), navigation.join(" · ")];
+        const requests = m.requestsByTurn.get(turn.id) ?? [];
+        if (requests.length > 0) {
+            const table = ["| Request | Call | Admission | Outcome |", "| --- | --- | --- | --- |"];
+            for (const request of requests) {
+                table.push(`| ${DigestRender.#link(from, `requests/${request.id}.md`, String(request.id))} | ${request.kind} ${request.inference_call_id} | ${DigestRender.#admission(m, request)} | ${request.outcome ?? request.state} |`);
+            }
+            lines.push("## Attempts", table.join("\n"));
+        }
+        for (const attempt of m.attemptsByTurn.get(turn.id) ?? []) {
+            if (attempt.accepted === 1)
+                continue;
+            const ordinal = String(attempt.sequence).padStart(3, "0");
+            const prefix = `${stem}.attempt${ordinal}`;
+            if (attempt.state !== "response") {
+                lines.push(`### Emission attempt ${attempt.sequence}: ${attempt.state}`, DigestRender.#link(from, `${prefix}.${attempt.state}.json`, "Call evidence"));
+                if (attempt.failure !== null)
+                    lines.push(DigestRender.#literal(attempt.failure, "json"));
+                continue;
+            }
+            const admission = attempt.accepted === 0 ? "rejected" : "unadmitted";
+            lines.push(`### Emission attempt ${attempt.sequence}: ${admission}`, m.evidence.response(attempt.model_call_id) === null ? "Response evidence is not retained."
+                : DigestRender.#link(from, `${prefix}.${admission}.assistant.md`, "Exact output"), DigestRender.#literal(JSON.stringify(DigestRender.parseJson(attempt.parse_errors, []), null, 2), "json"));
+        }
+        return lines;
+    }
+    static #admission(m, request) {
+        if (request.kind === "bare")
+            return "not an emission";
+        if (request.outcome !== "response")
+            return "not admitted";
+        const call = m.modelCalls.find(({ id }) => id === request.inference_call_id);
+        return call?.accepted === 1 ? "admitted" : call?.accepted === 0 ? "rejected" : "not admitted";
+    }
+    static #physicalRequest(m, request, evidence) {
+        const from = `requests/${request.id}.md`;
+        const turn = m.turns.find(({ id }) => id === request.turn_id);
+        const fields = typeof evidence === "object" && evidence !== null ? evidence : {};
+        const capture = fields.request;
+        const lines = [
+            `# Physical request ${request.id}`,
+            [DigestRender.#link(from, "digest.md", "Digest"),
+                DigestRender.#link(from, `requests/${request.id}.json`, "Complete evidence")].join(" · "),
+            ...(turn === undefined ? [] : [`Originating turn: ${DigestRender.#turnLinks(m, turn, from).join(" · ") || "no packet artifacts retained"}`]),
+            DigestRender.#literal(JSON.stringify({
+                provider: request.provider, model: request.model, kind: request.kind,
+                inferenceCallId: request.inference_call_id, sequence: request.sequence,
+                state: request.state, outcome: request.outcome, admission: DigestRender.#admission(m, request),
+                startedAt: request.started_at, completedAt: request.completed_at,
+            }, null, 2), "json"),
+            "## Accounting",
+            request.state === "pending" ? "Request is unsettled; accounting is not yet available."
+                : DigestRender.#literal(JSON.stringify(DigestRender.#requestAccounting(request), null, 2), "json"),
+            "## Dispatched request",
+            typeof capture?.body !== "string" ? "Dispatched request body was not retained."
+                : `${capture.method} ${capture.origin}\n\nExact serialized body; URL details and request headers are not captured.\n\n${DigestRender.#literal(capture.body, "json")}`,
+        ];
+        const call = m.modelCalls.find(({ id }) => id === request.inference_call_id);
+        if (request.outcome === "response" && call?.accepted === 0) {
+            lines.push("## Admission", "The provider returned a response, but Plurnk rejected its emission.", DigestRender.#literal(JSON.stringify(DigestRender.parseJson(call.parse_errors, []), null, 2), "json"));
+        }
+        if (fields.error !== undefined)
+            lines.push("## Failure", DigestRender.#literal(JSON.stringify(fields.error, null, 2), "json"));
+        if (evidence === null)
+            lines.push("## Response", "No settled response evidence is retained.");
+        else {
+            if (request.outcome === "error")
+                lines.push("Partial output; this physical request failed. It is not an admitted response.");
+            for (const [field, heading] of [["reasoning", "Reasoning"], ["content", "Content"]]) {
+                lines.push(`## ${heading}`, typeof fields[field] === "string"
+                    ? DigestRender.#literal(fields[field]) : `No readable ${field} is retained in this request record.`);
+            }
+        }
+        return `${lines.join("\n\n")}\n`;
+    }
     // Per-turn forensic files. turnOps is the source authority; PacketWire
     // reproduces provider request slots, and assistantRaw preserves provider bytes.
     // {§share-packet-names}: the stem each turn's packet files carry is its log coordinate, worker, loop and
@@ -793,21 +951,32 @@ export default class DigestRender {
             const padded = stems.get(turn.id);
             const files = [];
             const { packet, packetFailure } = m.evidence.packet(turn);
+            const preamble = turn.has_packet === 1 ? DigestRender.#requestPreamble(m, turn) : [];
             if (packetFailure !== null) {
-                files.push([`${padded}.packet.raw.txt`, packetFailure.raw], [`${padded}.packet.invalid.json`, JSON.stringify({
+                files.push([`${padded}.request.md`, ["# Request", ...preamble, "Stored packet is invalid; no input messages were reconstructed.",
+                        DigestRender.#literal(JSON.stringify(packetFailure.error, null, 2), "json"),
+                        DigestRender.#link(`${padded}.request.md`, `${padded}.packet.raw.txt`, "Stored packet")].join("\n\n")], [`${padded}.packet.raw.txt`, packetFailure.raw], [`${padded}.packet.invalid.json`, JSON.stringify({
                         turnId: turn.id,
                         error: packetFailure.error,
                     }, null, 2)]);
             }
             if (packet !== null) {
-                files.push([`${padded}.system.md`, packet.slot("system")], [`${padded}.user.md`, packet.slot("user")]);
                 // {§packet-wire-envelope} — the exact text messages the request carried; a stored packet
                 // whose log cannot be projected is evidence of its own, never a reason to stop the digest.
                 try {
-                    files.push([`${padded}.wire.json`, JSON.stringify(packet.messages(DigestRender.#emissionsOf(turn, m)), null, 2)]);
+                    const messages = packet.messages();
+                    if (messages.length > 0)
+                        files.push([`${padded}.system.md`, packet.slot("system")], [`${padded}.user.md`, packet.slot("user")], [`${padded}.wire.json`, JSON.stringify(messages, null, 2)]);
+                    files.push([`${padded}.request.md`, DigestRender.request(messages, [
+                            ...preamble,
+                            ...(packet.attachments.length === 0 ? [] : ["## Native attachments", "Stored descriptors; selection alone does not prove transport or provider acceptance.", DigestRender.#literal(JSON.stringify(packet.attachments, null, 2), "json")]),
+                        ])]);
                 }
                 catch (cause) {
                     files.push([`${padded}.wire.invalid.json`, JSON.stringify({ turnId: turn.id, error: cause instanceof Error ? cause.message : String(cause) }, null, 2)]);
+                    files.push([`${padded}.request.md`, ["# Request", ...preamble,
+                            "Stored input could not be projected; no message order was reconstructed.",
+                            DigestRender.#link(`${padded}.request.md`, `${padded}.wire.invalid.json`, "Projection failure")].join("\n\n")]);
                 }
             }
             if (source !== null) {
@@ -844,22 +1013,30 @@ export default class DigestRender {
                     }, null, 2));
                     continue;
                 }
-                const response = DigestRender.parseJson(m.evidence.response(attempt.model_call_id), {});
-                const prefix = `${padded}.attempt${attemptPadded}.rejected`;
+                const retainedResponse = m.evidence.response(attempt.model_call_id);
+                const admission = attempt.accepted === 0 ? "rejected" : "unadmitted";
+                const prefix = `${padded}.attempt${attemptPadded}.${admission}`;
+                write(`${prefix}.parse-errors.json`, JSON.stringify(DigestRender.parseJson(attempt.parse_errors, []), null, 2));
+                write(`${prefix}.attributions.json`, JSON.stringify(DigestRender.parseJson(attempt.attributions, []), null, 2));
+                if (retainedResponse === null) {
+                    write(`${prefix}.response.md`, `# Emission attempt ${attempt.sequence}: ${admission}\n\nResponse evidence is not retained.\n`);
+                    continue;
+                }
+                const response = DigestRender.parseJson(retainedResponse, {});
                 const attemptFiles = [
                     [
                         `${prefix}.assistant.md`,
                         typeof response.assistant?.content === "string" ? response.assistant.content : "",
                     ],
                     [`${prefix}.response.json`, JSON.stringify(response, null, 2)],
-                    [`${prefix}.parse-errors.json`, JSON.stringify(DigestRender.parseJson(attempt.parse_errors, []), null, 2)],
-                    [`${prefix}.attributions.json`, JSON.stringify(DigestRender.parseJson(attempt.attributions, []), null, 2)],
                 ];
                 for (const [file, body] of attemptFiles)
                     write(file, body);
             }
         });
         for (const request of m.providerRequests) {
+            const evidence = DigestRender.parseJson(m.evidence.request(request.id));
+            write(`requests/${request.id}.md`, DigestRender.#physicalRequest(m, request, evidence));
             write(`requests/${request.id}.json`, JSON.stringify({
                 id: request.id,
                 inferenceCallId: request.inference_call_id,
@@ -870,7 +1047,7 @@ export default class DigestRender {
                 startedAt: request.started_at,
                 completedAt: request.completed_at,
                 accounting: request.state === "settled" ? DigestRender.#requestAccounting(request) : null,
-                evidence: DigestRender.parseJson(m.evidence.request(request.id)),
+                evidence,
             }, null, 2));
         }
         return written;
@@ -889,12 +1066,13 @@ export default class DigestRender {
                 id: r.id,
                 workspace_id: r.workspace_id,
                 name: r.name,
+                owner: r.owner,
                 accounting: DigestRender.#accounting(m.requestsByWorker.get(r.id) ?? []),
                 edit_census: DigestRender.#editCensus(m).byWorker.get(r.id) ?? null,
             })),
             loops: m.loops.map((l) => ({
                 id: l.id, worker_id: l.worker_id, sequence: l.sequence, status: l.status,
-                prompt: l.prompt, policy: DigestRender.parseJson(l.policy, {}),
+                prompt: l.prompt,
                 terminated_by: l.terminated_by,
                 claimed_at: l.claimed_at,
                 terminated_at: l.terminated_at,
@@ -989,6 +1167,8 @@ export default class DigestRender {
                 id: le.id, worker_id: le.worker_id, loop_id: le.loop_id,
                 turn_id: le.turn_id, sequence: le.sequence, origin: le.origin,
                 source: le.source, model_call_id: le.model_call_id,
+                ...(le.inherited_history === undefined ? {} : { inherited_history: le.inherited_history === 1 }),
+                ...(le.ambient_event_id === undefined ? {} : { ambient_event_id: le.ambient_event_id }),
                 attrs: DigestRender.parseJson(le.attrs, {}),
                 op: le.op, target: DigestRender.#renderTarget(le),
                 status_rx: le.status_rx, state: le.state, outcome: le.outcome,