@nanobpm/nano-workforce 0.185.1 → 0.186.1

package/pages/cockpit/generated/transcript-display.js

@@ -0,0 +1,316 @@
+// @generated from node_modules/@nanobpm/agentic/dist/transcript/display.js by scripts/build-cockpit-browser.ts — DO NOT EDIT.
+//
+// Browser ESM derived (type-strip only) from the typed transcript core so pages/cockpit/mount.js
+// renders the agentic transcript from ONE source of truth (#660). Regenerate with:
+//   node --experimental-strip-types scripts/build-cockpit-browser.ts
+
+const NOOP = Object.freeze({ appended: false });
+/** Recursively freeze a value already owned exclusively by the caller (a fresh clone), so no consumer
+ *  can mutate it at any depth. Idempotent, and a no-op for primitives and already-frozen objects. A
+ *  `seen` set guards against cyclic references so an arbitrarily-shaped `args` payload with a cycle
+ *  freezes without recursing forever. */
+function deepFreeze(value, seen = new WeakSet()) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value) || seen.has(value))
+        return;
+    seen.add(value);
+    Object.freeze(value);
+    for (const nested of Object.values(value))
+        deepFreeze(nested, seen);
+}
+/** Decouple a producer-owned, arbitrarily-shaped `args` value from projection state: deep clone it (so
+ *  the returned snapshot shares no mutable reference) then deep-freeze the clone. When `structuredClone`
+ *  is unavailable or `args` is non-cloneable (e.g. it contains functions), fall back to deep-freezing
+ *  `args` *in place* rather than returning it unfrozen: a shared-by-reference fallback would let a
+ *  consumer mutate `tool.args` back into the projection's internals, so freezing the shared object is
+ *  what preserves the "cannot reach back" guarantee even when cloning fails. */
+function freezeArgs(args) {
+    if (args === null || typeof args !== "object")
+        return args;
+    let cloned;
+    try {
+        cloned = structuredClone(args);
+    }
+    catch {
+        deepFreeze(args);
+        return args;
+    }
+    deepFreeze(cloned);
+    return cloned;
+}
+/** Deep-freeze a {@link DerivedTool} into a snapshot decoupled from the projection's mutable internals:
+ *  a shallow clone whose nested `result` is itself cloned + frozen and whose producer-owned `args` is
+ *  deep cloned + frozen ({@link freezeArgs}), so a consumer that mutates the returned `tool` (or
+ *  `tool.result` / `tool.args`) cannot reach back into projection state. */
+function freezeTool(tool) {
+    return Object.freeze({
+        ...tool,
+        ...(tool.args !== undefined ? { args: freezeArgs(tool.args) } : {}),
+        ...(tool.result !== undefined ? { result: Object.freeze({ ...tool.result }) } : {}),
+    });
+}
+/** Deep-freeze a {@link DerivedPermission} into a snapshot decoupled from the projection's mutable
+ *  internals: a shallow clone whose nested `options` (and each option) and `resolved` are cloned +
+ *  frozen, so a consumer cannot mutate projection state through the returned `permission`. */
+function freezePermission(permission) {
+    return Object.freeze({
+        ...permission,
+        options: Object.freeze(permission.options.map((option) => Object.freeze({ ...option }))),
+        ...(permission.resolved !== undefined ? { resolved: Object.freeze({ ...permission.resolved }) } : {}),
+    });
+}
+function freezeBlock(block) {
+    switch (block.kind) {
+        case "text":
+            return Object.freeze({
+                kind: "text",
+                id: `text:${block.startOffset}`,
+                role: block.role,
+                ...(block.messageId !== undefined ? { messageId: block.messageId } : {}),
+                text: block.text,
+                startOffset: block.startOffset,
+                endOffset: block.endOffset,
+                complete: block.complete,
+            });
+        case "tool":
+            return Object.freeze({
+                kind: "tool",
+                id: `tool:${block.startOffset}`,
+                tool: freezeTool(block.tool),
+                startOffset: block.startOffset,
+                endOffset: block.endOffset,
+            });
+        case "permission":
+            return Object.freeze({
+                kind: "permission",
+                id: `permission:${block.startOffset}`,
+                permission: freezePermission(block.permission),
+                startOffset: block.startOffset,
+                endOffset: block.endOffset,
+            });
+        case "gap":
+            return Object.freeze({
+                kind: "gap",
+                id: `gap:${block.ordinal}`,
+                ...(block.beforeOffset !== undefined ? { beforeOffset: block.beforeOffset } : {}),
+            });
+    }
+}
+function toolFromCall(event) {
+    return {
+        name: event.name,
+        offset: event.offset,
+        ...(event.callId !== undefined ? { callId: event.callId } : {}),
+        ...(event.args !== undefined ? { args: event.args } : {}),
+    };
+}
+function toolWithResult(tool, result) {
+    return {
+        ...tool,
+        result: {
+            ok: result.ok,
+            offset: result.offset,
+            ...(result.content !== undefined ? { content: result.content } : {}),
+        },
+    };
+}
+function permissionFromRequest(event) {
+    return {
+        callId: event.callId,
+        policy: event.policy,
+        options: event.options,
+        offset: event.offset,
+        ...(event.toolName !== undefined ? { toolName: event.toolName } : {}),
+        ...(event.title !== undefined ? { title: event.title } : {}),
+        ...(event.reason !== undefined ? { reason: event.reason } : {}),
+    };
+}
+function permissionWithResolution(permission, resolution) {
+    return {
+        ...permission,
+        resolved: {
+            allowed: resolution.allowed,
+            optionId: resolution.optionId,
+            offset: resolution.offset,
+            ...(resolution.by !== undefined ? { by: resolution.by } : {}),
+        },
+    };
+}
+export function createDisplayProjection() {
+    const blocks = [];
+    const openTools = new Map();
+    let anonymousTool;
+    const openPermissions = new Map();
+    // The append-order idempotency key: the highest offset ever folded. Any event at or below it was
+    // already applied (a replayed/duplicated chunk), so it is a no-op — this is what keeps replay,
+    // reconnect and pagination overlap from doubling text. Starts at -1 so offset 0 applies.
+    let lastOffset = -1;
+    // A pending gap awaiting the offset of the next block, so a consumer can anchor the break.
+    let pendingGapBlock;
+    let gapOrdinal = 0;
+    /** The active text block a delta may extend: the LAST block, iff it is an open text block. Any other
+     *  trailing block (a tool card, a permission, a gap) means there is no open text run to coalesce into. */
+    const activeText = () => {
+        const tail = blocks[blocks.length - 1];
+        return tail !== undefined && tail.kind === "text" && !tail.complete ? tail : undefined;
+    };
+    const closeActiveText = () => {
+        const active = activeText();
+        if (active !== undefined)
+            active.complete = true;
+    };
+    /** Anchor a not-yet-anchored gap to the first block that opens after it, returning the now-anchored gap
+     *  (frozen) so the triggering {@link apply} can surface it as {@link DisplayApplyResult.anchored} — else
+     *  `undefined` when there is no pending gap. */
+    const anchorGap = (offset) => {
+        if (pendingGapBlock === undefined)
+            return undefined;
+        pendingGapBlock.beforeOffset = offset;
+        const anchored = freezeBlock(pendingGapBlock);
+        pendingGapBlock = undefined;
+        return anchored;
+    };
+    const applyMessage = (event) => {
+        const active = activeText();
+        // A delta may extend the active block only when it is the SAME speaker AND the SAME logical message
+        // AND the producer did not force a new block with `start`. Message identity: if both sides carry a
+        // `messageId` they must match; a changed id (or one side having an id the other lacks) is a distinct
+        // message. With no ids on either side, the fallback is purely structural — adjacent + same speaker.
+        const idsMatch = event.messageId !== undefined || active?.messageId !== undefined
+            ? event.messageId === active?.messageId
+            : true;
+        const canExtend = active !== undefined && event.start !== true && active.role === event.role && idsMatch;
+        if (canExtend && active !== undefined) {
+            // Snapshot REPLACES the accumulated text; a delta APPENDS exactly (no separator).
+            active.text = event.mode === "snapshot" ? event.text : active.text + event.text;
+            active.endOffset = event.offset;
+            if (event.final === true)
+                active.complete = true;
+            return { changed: freezeBlock(active), appended: false };
+        }
+        // Open a fresh block. (A `start`/id-change/role-change also closes any still-open predecessor so the
+        // next unrelated delta cannot re-open it.)
+        closeActiveText();
+        const anchored = anchorGap(event.offset);
+        const block = {
+            kind: "text",
+            role: event.role,
+            text: event.text,
+            startOffset: event.offset,
+            endOffset: event.offset,
+            complete: event.final === true,
+            ...(event.messageId !== undefined ? { messageId: event.messageId } : {}),
+        };
+        blocks.push(block);
+        return { changed: freezeBlock(block), appended: true, ...(anchored !== undefined ? { anchored } : {}) };
+    };
+    const applyToolCall = (event) => {
+        // A tool call interrupts any running text: it becomes the trailing block, so a later delta opens a
+        // new text block rather than coalescing across the tool.
+        closeActiveText();
+        const anchored = anchorGap(event.offset);
+        const block = {
+            kind: "tool",
+            tool: toolFromCall(event),
+            startOffset: event.offset,
+            endOffset: event.offset,
+        };
+        blocks.push(block);
+        const pending = { block };
+        if (event.callId !== undefined)
+            openTools.set(event.callId, pending);
+        else
+            anonymousTool = pending;
+        return { changed: freezeBlock(block), appended: true, ...(anchored !== undefined ? { anchored } : {}) };
+    };
+    const applyToolResult = (event) => {
+        const pending = event.callId !== undefined ? openTools.get(event.callId) : anonymousTool;
+        if (pending === undefined)
+            return NOOP; // A result with no open call — nothing to pair (never invents a card).
+        pending.block.tool = toolWithResult(pending.block.tool, event);
+        pending.block.endOffset = event.offset;
+        if (event.callId !== undefined)
+            openTools.delete(event.callId);
+        else
+            anonymousTool = undefined;
+        return { changed: freezeBlock(pending.block), appended: false };
+    };
+    const applyPermissionRequest = (event) => {
+        closeActiveText();
+        const anchored = anchorGap(event.offset);
+        const block = {
+            kind: "permission",
+            permission: permissionFromRequest(event),
+            startOffset: event.offset,
+            endOffset: event.offset,
+        };
+        blocks.push(block);
+        openPermissions.set(event.callId, { block });
+        return { changed: freezeBlock(block), appended: true, ...(anchored !== undefined ? { anchored } : {}) };
+    };
+    const applyPermissionResolution = (event) => {
+        const pending = openPermissions.get(event.callId);
+        if (pending === undefined)
+            return NOOP;
+        pending.block.permission = permissionWithResolution(pending.block.permission, event);
+        pending.block.endOffset = event.offset;
+        openPermissions.delete(event.callId);
+        return { changed: freezeBlock(pending.block), appended: false };
+    };
+    const apply = (event) => {
+        // Idempotency gate: this projection requires events in strictly increasing `offset` order, so any
+        // offset at or below the high-water mark is treated as already folded (replay / reconnect /
+        // pagination overlap / a duplicated chunk) and re-applying it must not change anything. A genuinely
+        // out-of-order event (offset <= lastOffset arriving late) is likewise dropped here, not merged — a
+        // caller seeing a "missing" block must re-feed the stream in order rather than read it as deduped.
+        if (event.offset <= lastOffset)
+            return NOOP;
+        lastOffset = event.offset;
+        switch (event.kind) {
+            case "message":
+                return applyMessage(event);
+            case "tool-call":
+                return applyToolCall(event);
+            case "tool-result":
+                return applyToolResult(event);
+            case "permission":
+                return event.phase === "request" ? applyPermissionRequest(event) : applyPermissionResolution(event);
+            case "turn":
+                // An explicit turn boundary closes the running message so the next turn's text starts fresh.
+                closeActiveText();
+                return NOOP;
+            // A `step`, a `lifecycle` transition, and a raw `stream-chunk` do not themselves produce a display
+            // block and do not break text coalescing (raw bytes render on the separate byte-terminal plane).
+            case "step":
+            case "lifecycle":
+            case "stream-chunk":
+                return NOOP;
+        }
+    };
+    return {
+        apply,
+        applyAll(events) {
+            for (const event of events)
+                apply(event);
+        },
+        noteGap() {
+            closeActiveText();
+            const block = { kind: "gap", ordinal: gapOrdinal++ };
+            blocks.push(block);
+            pendingGapBlock = block;
+            return { changed: freezeBlock(block), appended: true };
+        },
+        blocks() {
+            return blocks.map(freezeBlock);
+        },
+    };
+}
+/**
+ * The pure batch convenience: fold a whole run of offset-ordered events into the ordered display blocks
+ * in one call, over a fresh {@link createDisplayProjection}. Duplicate offsets in the input are deduped
+ * by the same idempotency gate, so a replayed slice folds to the same result as a gap-free one.
+ */
+export function deriveDisplay(events) {
+    const projection = createDisplayProjection();
+    projection.applyAll(events);
+    return projection.blocks();
+}

package/pages/cockpit/generated/transcript-events.js

@@ -75,6 +75,12 @@ function num(body, key) {
     const v = body[key];
     return typeof v === "number" && Number.isFinite(v) ? v : undefined;
 }
+/** Read a strictly-boolean field, or `undefined` when absent. A present-but-non-boolean value returns
+ *  `undefined` too, so the caller can reject a malformed envelope rather than silently coercing it. */
+function bool(body, key) {
+    const v = body[key];
+    return typeof v === "boolean" ? v : undefined;
+}
 const ROLES = ["assistant", "user", "system", "tool"];
 /** Narrow an arbitrary string to a known {@link TranscriptRole}, defaulting to `assistant`. */
 function toRole(value) {
@@ -123,7 +129,35 @@ export const CORE_TRANSCRIPT_VOCAB = Object.freeze(Object.assign(Object.create(n
         if (text === undefined)
             return undefined;
         const roleRaw = str(body, "role");
-        return { kind: "message", offset, role: toRole(roleRaw), text };
+        // The additive display metadata (all optional). Mirror the permission decoder's discipline: a
+        // present-but-malformed optional field REJECTS the whole envelope (→ raw stream-chunk) rather than
+        // being silently dropped, so a decoded event never diverges from the on-wire JSON.
+        const messageId = str(body, "messageId");
+        if (body.messageId !== undefined && messageId === undefined)
+            return undefined;
+        let mode;
+        if (body.mode !== undefined) {
+            const modeRaw = str(body, "mode");
+            if (modeRaw !== "delta" && modeRaw !== "snapshot")
+                return undefined;
+            mode = modeRaw;
+        }
+        const start = bool(body, "start");
+        if (body.start !== undefined && start === undefined)
+            return undefined;
+        const final = bool(body, "final");
+        if (body.final !== undefined && final === undefined)
+            return undefined;
+        return {
+            kind: "message",
+            offset,
+            role: toRole(roleRaw),
+            text,
+            ...(messageId !== undefined ? { messageId } : {}),
+            ...(mode !== undefined ? { mode } : {}),
+            ...(start !== undefined ? { start } : {}),
+            ...(final !== undefined ? { final } : {}),
+        };
     },
     "tool-call": (body, offset) => {
         const name = str(body, "name");

package/pages/cockpit/mount.js

@@ -25,7 +25,7 @@
 // (`app/agentic/cockpit/transcript-derive.ts` + `app/agentic/transcript-events.ts`) that a drift-guard
 // test keeps byte-identical to its source.
 import { RelayChannelClient, TerminalSession } from "@nanobpm/agentic/cockpit";
-import { renderDerivedTranscript } from "./generated/transcript-derive.js";
+import { createIncrementalTranscript } from "./generated/transcript-derive.js";
 
 const DEFAULT_REFRESH_MS = 2000;
 const DEFAULT_STALE_AFTER_MS = 15_000;
@@ -390,42 +390,96 @@ function renderTranscripts(host, doc, view, onReplay, activeStream, title = "Pas
   host.appendChild(root);
 }
 
-// ── transcript rendering (#660) ────────────────────────────────────────────────────────────────
+// ── transcript rendering (#660, #757) ───────────────────────────────────────────────────────────
 //
-// A rendered-transcript sink over `host`: it accumulates the relay stream's `{offset, chunk}` entries
-// and (re-)draws them through the shared `renderDerivedTranscript` — the SAME parse→derive→render path
-// the typed core uses — so the operator sees readable message turns + tool/diff/permission cards, never
-// the raw `nwfTranscriptEvent` envelopes. Chunks are keyed by offset, so a resume-from-offset reconnect
-// that re-delivers a chunk coalesces instead of doubling it (mirrors TerminalSession's own dedup). The
-// derive/render logic is NOT re-copied here — that hand-copy was the #660 drift; this only collects
-// offsets and hands the whole page to the imported renderer, which parses + folds it exactly once.
+// An INCREMENTAL rendered-transcript sink over `host`: it feeds each relay `{offset, chunk}` into the
+// shared {@link createIncrementalTranscript} projection — the SAME ordered-display fold the typed core
+// uses (#757) — so the operator sees ONE growing text block per logical message with tool/diff/permission
+// activity interleaved in chronological order, never one bordered card per streamed delta and never the
+// raw `nwfTranscriptEvent` envelopes. The renderer patches only the ONE touched block's DOM node per
+// chunk (append a new block, or grow/settle an existing one) instead of rebuilding the whole tree, so the
+// operator's text selection and expansion survive live streaming.
+//
+// Redraws are BATCHED to an animation frame when the host provides one (bounded scheduling: many deltas
+// arriving in one frame apply together, once), falling back to a synchronous flush where no rAF exists
+// (Node/tests). Scroll is AUTO-FOLLOWED only when the operator is already at the tail — captured before
+// each flush mutates the DOM — so reading back through history is not yanked to the bottom by new output.
+// The derive/render logic is NOT re-copied here (that hand-copy was the #660 drift); this only schedules
+// and collects chunks and hands them to the imported projection.
 function transcriptSink(host, stream, opts = {}) {
-  const byOffset = new Map();
-  let gap = false;
-  let nextOffset = 0;
-  const draw = () => {
-    const entries = [...byOffset.entries()].sort((a, b) => a[0] - b[0]).map(([offset, chunk]) => ({ offset, chunk }));
-    renderDerivedTranscript(host, host.ownerDocument, { stream, from: 0, gap, nextOffset, entries }, opts);
-  };
+  const doc = host.ownerDocument;
+  const win = doc?.defaultView ?? (typeof window !== "undefined" ? window : undefined);
+  const raf = win && typeof win.requestAnimationFrame === "function" ? win.requestAnimationFrame.bind(win) : undefined;
+  const caf = win && typeof win.cancelAnimationFrame === "function" ? win.cancelAnimationFrame.bind(win) : undefined;
+
+  let renderer = createIncrementalTranscript(host, doc, stream, opts);
+  const pending = []; // buffered {offset, chunk} awaiting the next flush
+  let gapPending = false; // a retention gap to open before the next flush's chunks
+  let frame = 0; // scheduled animation-frame handle (0 = none)
+  let disposed = false;
+
+  // Is the operator following the tail (so new output should auto-scroll)? Only meaningful with real
+  // layout; a host without numeric scroll metrics (the Node fake DOM) is treated as following.
+  function atTail() {
+    const sh = host.scrollHeight;
+    const st = host.scrollTop;
+    const ch = host.clientHeight;
+    if (typeof sh !== "number" || typeof st !== "number" || typeof ch !== "number") return true;
+    return st + ch >= sh - 4;
+  }
+  function followTail() {
+    if (typeof host.scrollHeight === "number") host.scrollTop = host.scrollHeight;
+  }
+
+  function flush() {
+    frame = 0;
+    if (disposed) return;
+    // Capture follow-state BEFORE mutating so only an operator already at the tail is auto-scrolled.
+    const follow = atTail();
+    if (gapPending) {
+      renderer.noteGap();
+      gapPending = false;
+    }
+    const batch = pending.splice(0, pending.length).sort((a, b) => a.offset - b.offset);
+    for (const entry of batch) renderer.applyChunk(entry);
+    if (follow) followTail();
+  }
+
+  function schedule() {
+    if (disposed || frame !== 0) return;
+    if (raf) frame = raf(flush);
+    else flush(); // no animation-frame scheduler (Node/tests) — flush synchronously so the DOM is current
+  }
+
   return {
-    /** Fold in the resume ack (offset/gap metadata) and redraw. */
+    /** Fold in the resume ack: a gap flag opens a visible retention break before the following chunks. */
     ack: (message) => {
-      if (typeof message?.nextOffset === "number") nextOffset = message.nextOffset;
-      if (typeof message?.gap === "boolean") gap = message.gap;
-      draw();
+      if (message != null && message.gap === true) gapPending = true;
+      schedule();
     },
-    /** Fold in one relay data chunk (deduped by offset) and redraw. */
+    /** Buffer one relay data chunk (deduped by offset inside the idempotent projection) and schedule a flush. */
     add: (offset, chunk) => {
-      byOffset.set(offset, chunk);
-      draw();
+      pending.push({ offset, chunk });
+      schedule();
     },
-    /** Render a whole fetched transcript page in one pass (static replay). */
+    /** Render a whole fetched transcript page in one pass (static replay) — rebuild from a fresh projection. */
     replace: (data) => {
-      byOffset.clear();
-      gap = Boolean(data.gap);
-      nextOffset = data.nextOffset ?? 0;
-      for (const entry of data.entries ?? []) byOffset.set(entry.offset, entry.chunk);
-      draw();
+      if (frame !== 0 && caf) caf(frame);
+      frame = 0;
+      pending.length = 0;
+      gapPending = false;
+      renderer = createIncrementalTranscript(host, doc, data.stream ?? stream, opts);
+      if (data.gap) renderer.noteGap();
+      const entries = [...(data.entries ?? [])].sort((a, b) => a.offset - b.offset);
+      for (const entry of entries) renderer.applyChunk(entry);
+      followTail();
+    },
+    /** Tear down the scheduler when the terminal region is claimed by another session (or disposed). */
+    dispose: () => {
+      disposed = true;
+      if (frame !== 0 && caf) caf(frame);
+      frame = 0;
+      pending.length = 0;
     },
   };
 }

package/resources/forms/delivery-human-generic.form

@@ -5,43 +5,14 @@
   "components": [
     {
       "type": "text",
-      "text": "### Delivery graph — node `{{nodeId}}`",
-      "conditional": {
-        "hide": "=(nodeId = null) or (nodeId = \"\")"
-      }
-    },
-    {
-      "type": "textarea",
-      "key": "prompt",
       "label": "Now do this",
-      "description": "The scheduled human step this delivery graph is waiting on.",
-      "readonly": true
-    },
-    {
-      "type": "text",
-      "text": "**Emits:** {{emitLabel}} — enter its typed value below (validated against the node's declared fact).",
-      "conditional": {
-        "hide": "=emitMode != \"typed\""
-      }
+      "text": "This task's instruction is shown in the Decision context above."
     },
     {
       "type": "textfield",
       "key": "value",
-      "label": "Emitted value",
-      "description": "The typed value this step hands forward to its downstream dependents. Validated against the node's declared emitted fact.",
-      "conditional": {
-        "hide": "=emitMode != \"typed\""
-      },
-      "validate": {
-        "required": true
-      }
-    },
-    {
-      "type": "text",
-      "text": "_This step emits no typed fact (N/A) — just complete it to unblock its dependents._",
-      "conditional": {
-        "hide": "=emitMode = \"typed\""
-      }
+      "label": "Emitted value (only if this step emits a fact)",
+      "description": "The typed value this step hands forward to its downstream dependents. Leave blank for a click-done step that emits nothing."
     },
     {
       "type": "textarea",

package/scripts/build-cockpit-browser.ts

@@ -40,12 +40,22 @@ interface BundleModule {
 // self-contained ESM (`dist/transcript/events.js` has no runtime imports), the SAME source of truth the
 // Node core re-exports via the `transcript-events.ts` barrel. This keeps "one grammar, no drift surface"
 // true across BOTH hosts: the cockpit renders from agentic's grammar, never a hand-rolled second copy.
+// The ordered DISPLAY projection (agentic #566) is a THIRD browser-safe agentic module
+// (`dist/transcript/display.js`, self-contained — its only import is `import type` from events.ts,
+// erased on transpile). The cockpit's derive+render now folds through it (one growing block per message,
+// chronological interleave), so it joins the bundle beside the events grammar. `transcript-derive.ts`
+// imports the display fold from the `../transcript-display.ts` barrel, rewritten here to the generated
+// display sibling — the SAME source of truth the Node core re-exports.
 const MODULES: readonly BundleModule[] = [
   { src: "node_modules/@nanobpm/agentic/dist/transcript/events.js", out: "pages/cockpit/generated/transcript-events.js" },
+  { src: "node_modules/@nanobpm/agentic/dist/transcript/display.js", out: "pages/cockpit/generated/transcript-display.js" },
   {
     src: "app/agentic/cockpit/transcript-derive.ts",
     out: "pages/cockpit/generated/transcript-derive.js",
-    rewrites: [["../transcript-events.ts", "./transcript-events.js"]],
+    rewrites: [
+      ["../transcript-events.ts", "./transcript-events.js"],
+      ["../transcript-display.ts", "./transcript-display.js"],
+    ],
   },
 ];