@plurnk/plurnk-service 1.16.5 → 1.18.0

package/dist/core/packet-wire.js

@@ -1,11 +1,4 @@
-// Packet → wire markdown projection. Single source of truth for how the
-// Packet's ordered list of sections renders to ChatMessage.content
-// strings the LLM receives. Engine imports this for the wire payload; the
-// digest tool imports it to write byte-identical packetNNN.{system,user}.md
-// files. No second implementation, no drift.
-//
-// Format and omission rules are owned by {§packet-markdown}. Section producers
-// supply names and typed content; this projection preserves their ordered evidence.
+import { TurnDisposition } from "@plurnk/plurnk-contracts";
 import { relative, sep } from "node:path";
 import { Problems, Validator } from "@plurnk/plurnk-contracts";
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
@@ -13,35 +6,16 @@ import { renderTarget } from "./plurnk-uri.js";
 import LogBody from "./LogBody.js";
 import LogEntryProjection from "./LogEntryProjection.js";
 import LogVisibility from "./LogVisibility.js";
+import BodyPreview from "../content/body-preview.js";
 import { assertEditReceipt, assertResourceEffects, LineAnchors, } from "../content/index.js";
-const editReceiptRevisionChars = () => {
-    const raw = process.env.PLURNK_SERVICE_EDIT_RECEIPT_REVISION_CHARS;
-    const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < 1 || value > 64) {
-        throw new Error(`PLURNK_SERVICE_EDIT_RECEIPT_REVISION_CHARS must be a safe integer from 1 through 64, got ${JSON.stringify(raw)}`);
-    }
-    return value;
-};
-const previewBounds = () => {
-    const rawLines = process.env.PLURNK_SERVICE_PREVIEW_LINES;
-    const rawChars = process.env.PLURNK_SERVICE_PREVIEW_CHARS;
-    const lines = Number(rawLines);
-    const chars = Number(rawChars);
-    if (!Number.isSafeInteger(lines) || lines < 1) {
-        throw new Error(`PLURNK_SERVICE_PREVIEW_LINES must be a positive safe integer, got ${JSON.stringify(rawLines)}`);
-    }
-    if (!Number.isSafeInteger(chars) || chars < 1) {
-        throw new Error(`PLURNK_SERVICE_PREVIEW_CHARS must be a positive safe integer, got ${JSON.stringify(rawChars)}`);
-    }
-    return { lines, chars };
-};
 // {§packet-attachment-parts} — the attachment kinds and their readout weights live in one table.
 import { imageWeight, pdfWeight } from "./attachments.js";
+import { isExecutionOp } from "@plurnk/plurnk-contracts";
 export { imageWeight, pdfWeight };
 export default class PacketWire {
     // {§packet-markdown} Render the sections in `slot` to one ChatMessage.content
     // string. Sections render in list order; empties are omitted (no empty headers on the wire);
-    // each is `## {header}\n\n{content}` (or bare content when header is null),
+    // JSON follows its H2 directly; other content has one blank line (null header is bare),
     // trailing newlines stripped, joined with a blank line.
     static renderSlot(sections, slot) {
         return sections
@@ -50,15 +24,15 @@ export default class PacketWire {
             .filter((p) => p.length > 0)
             .join("\n\n");
     }
-    // One section → its markdown block (`## {header}\n{content}`, or bare
-    // content when header is null/empty), trailing newlines stripped. Empty
+    // One section → its markdown block, trailing newlines stripped. Empty
     // content renders to "" so renderSlot drops it. This is the unit the
     // per-section `weight` is measured over.
     static renderSection(s) {
         if (typeof s.content !== "string" || s.content.length === 0)
             return "";
         const header = typeof s.header === "string" && s.header.length > 0 ? s.header : null;
-        return (header ? `## ${header}\n${s.content}` : s.content).replace(/\n+$/, "");
+        const separator = s.content.startsWith("{") || s.content.startsWith("[") ? "\n" : "\n\n";
+        return (header ? `## ${header}${separator}${s.content}` : s.content).replace(/\n+$/, "");
     }
     // Durable operation failures render as `{status, path}` JSON pointers to the log rows that
     // own their exact RFC 9457 results.
@@ -88,23 +62,27 @@ export default class PacketWire {
             return `* ${kind}${message.length > 0 ? `: ${message}` : ""}${position}`;
         }).join("\n");
     }
-    // The Child Streams / Active Child Workers sections ({§child-orientation}) — the OPPOSITE of advice: terse
-    // `{status, path}` JSON pointers (same shape as the errors section) to the live things the worker holds,
-    // so the model SEES its active streams + unconcluded workers each turn and reasons for itself (READ /
-    // KILL via the path). Orienting state, never an instruction. "" when none → section omitted.
-    static renderChildPointers(rows) {
+    // The Delegation section ({§child-orientation}) — the OPPOSITE of advice: terse `{status, path}`
+    // JSON pointers (same shape as the errors section) to the live things the worker holds, under the
+    // word the teaching uses for handing work out: its unconcluded workers and its open streams. The
+    // model SEES them each turn and reasons for itself (READ / SEND / KILL via the path). Orienting
+    // state, never an instruction; both lists render every turn, `[]` when empty ({§packet-empty-sections}).
+    static renderDelegation(workers, streams) {
+        return `{"workers":${PacketWire.#pointers(workers)},\n"streams":${PacketWire.#pointers(streams)}}`;
+    }
+    static #pointers(rows) {
         const items = Array.isArray(rows) ? rows : [];
         const pointers = items.map((r) => JSON.stringify({
             status: r.status,
             path: r.path,
             ...(typeof r.detail === "string" && r.detail.length > 0 ? { detail: r.detail } : {}),
         }));
-        return pointers.length === 0 ? "" : `[${pointers.join(",\n")}]`;
+        return pointers.length === 0 ? "[]" : `[${pointers.join(",\n")}]`;
     }
     // The git section content: the working-tree summary. "" when absent.
     static renderGit(git) {
         const status = git === null || git === undefined ? "" : PacketWire.#renderGitState(git);
-        return status;
+        return status.length === 0 ? "" : `> [!NOTE]\n${status.split("\n").map((line) => `> ${line}`).join("\n")}`;
     }
     // The log section's content: the model's curated rows as Markdown-framed records ({§log-wire-format}).
     // Data only — no prose leads the records (the log carries rules for no one). Empty log → ""
@@ -117,12 +95,16 @@ export default class PacketWire {
     static renderLogWithAccounting(entries, weighContent, options = {}) {
         const log = Array.isArray(entries) ? entries : [];
         if (log.length === 0)
-            return { content: "", reclaimableBodies: [], attachments: [] };
+            return { content: "", records: [], curationTargets: [], attachments: [], unadmittedOutput: [], newOverflow: false };
         const rows = PacketWire.#renderLogEntries(log, weighContent, options);
+        const records = rows.map(({ content }) => content);
         return {
-            content: rows.map(({ content }) => content).join("\n\n"),
-            reclaimableBodies: rows.flatMap(({ reclaimableBody }) => reclaimableBody === null ? [] : [reclaimableBody]),
+            content: records.join("\n\n"),
+            records,
+            curationTargets: rows.flatMap(({ curationTarget }) => curationTarget === null ? [] : [curationTarget]),
             attachments: rows.flatMap(({ attachment }) => attachment === null ? [] : [attachment]),
+            unadmittedOutput: rows.flatMap(({ unadmittedOutput }) => unadmittedOutput === null ? [] : [unadmittedOutput]),
+            newOverflow: rows.some(({ newOverflow }) => newOverflow),
         };
     }
     // Read one section's content by name off a packet (Engine's or re-parsed).
@@ -144,7 +126,7 @@ export default class PacketWire {
     }
     // Number a non-READ body line as `<N>:<line>` — `N:` followed by NO separator whitespace
     // ({§render-rule-line-navigable-prefix}): the leading digit prevents column-zero fence collisions and gives
-    // the model line refs for free (`### READ0 (...) <42-46>`), while the absence of any separator means a
+    // the model line refs for free (`READ (...) <42-46>`), while the absence of any separator means a
     // reproduced line has nothing between `N:` and the content to copy — the hard-tab separator used
     // to leak into edit bodies and corrupt indentation. The content's OWN leading whitespace is
     // content, preserved verbatim. `N` is left-padded to the body's line-range width so every body
@@ -159,12 +141,15 @@ export default class PacketWire {
         const prefix = () => `${String(line++).padStart(width, " ")}:`;
         return `${prefix()}${body.replace(/(\r\n|\r(?!\n)|\n)(?=[\s\S])/g, (separator) => `${separator}${prefix()}`)}`;
     }
-    static #numberSelectedLines(body, ordinals, startLine, lineAnchors, lineNumberWidth, numericLineNumberWidth) {
+    static #numberSelectedLines(body, ordinals, startLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, sourceLineNumbers) {
         const lines = TextCoordinates.logicalLines(body);
         if (lines.length !== ordinals.length) {
             throw new TypeError("A sparse log-body projection requires one source ordinal per rendered line.");
         }
-        const displayed = ordinals.map((ordinal) => startLine + ordinal - 1);
+        if (sourceLineNumbers !== null && ordinals.some((ordinal) => ordinal < 1 || ordinal > sourceLineNumbers.length)) {
+            throw new TypeError("A sparse log-body projection's ordinals must address its source line numbers.");
+        }
+        const displayed = ordinals.map((ordinal) => sourceLineNumbers === null ? startLine + ordinal - 1 : sourceLineNumbers[ordinal - 1]);
         const width = lineAnchors === null
             ? numericLineNumberWidth > 0
                 ? numericLineNumberWidth
@@ -192,14 +177,14 @@ export default class PacketWire {
     // Exact READ content receives source-width-aligned `@hash N:`; other textual bodies receive `N:`.
     // Matchers consume canonical content before this presentation projection.
     // Empty content produces no body.
-    static #renderContentBody(content, startLine = 1, lineAnchors = null, lineNumberWidth = null, numericLineNumberWidth = 0, lineOrdinals = null) {
+    static #renderContentBody(content, startLine = 1, lineAnchors = null, lineNumberWidth = null, numericLineNumberWidth = 0, lineOrdinals = null, sourceLineNumbers = null) {
         if (content.length === 0)
             return "";
         // `startLine === null` means the producer already supplied numbered
         // content; re-numbering would duplicate its coordinates.
         const rendered = startLine !== null
             ? lineOrdinals !== null
-                ? PacketWire.#numberSelectedLines(content, lineOrdinals, startLine, lineAnchors, lineNumberWidth, numericLineNumberWidth)
+                ? PacketWire.#numberSelectedLines(content, lineOrdinals, startLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, sourceLineNumbers)
                 : lineAnchors === null
                     ? PacketWire.#numberLines(content, startLine, numericLineNumberWidth)
                     : LineAnchors.render(content, startLine, lineAnchors, lineNumberWidth ?? 0)
@@ -216,19 +201,23 @@ export default class PacketWire {
             return null;
         }
     }
-    // Stable JSON metadata: keys are sorted so the same facts produce the same
-    // line across turns — prefix-cache friendly. The preceding H3 owns identity.
+    // {§log-wire-format} Orientation precedes telemetry on every receipt.
     static #canonicalJson(obj) {
         const keys = Object.keys(obj).sort();
         const sorted = {};
+        for (const key of ["target", "aside"]) {
+            if (Object.hasOwn(obj, key))
+                sorted[key] = obj[key];
+        }
         for (const k of keys)
             sorted[k] = obj[k];
         return JSON.stringify(sorted);
     }
     static #receiptMeta(value) {
         const receipt = assertEditReceipt(value);
+        // The durable receipt keeps the full revision for forensics; the model gets no token it
+        // cannot use (operator, 2026-09-13: "ditch rev").
         const head = {
-            rev: receipt.revision.slice(0, editReceiptRevisionChars()),
             extent: `${receipt.unit} ${receipt.before}->${receipt.after}`,
             ...(receipt.parseIssues === undefined
                 ? {}
@@ -287,41 +276,14 @@ export default class PacketWire {
             throw new TypeError("A packet log row requires an addressable coordinate.");
         return `log:///${coordinate}/${leaf}`;
     }
-    static #offsetAfterCharacters(text, count) {
-        let offset = 0;
-        let consumed = 0;
-        while (offset < text.length && consumed < count) {
-            if (text.startsWith("\r\n", offset)) {
-                offset += 2;
-            }
-            else {
-                const codePoint = text.codePointAt(offset);
-                if (codePoint === undefined)
-                    break;
-                offset += String.fromCodePoint(codePoint).length;
-            }
-            consumed++;
-        }
-        return offset;
-    }
     // One preview function for every bounded model-facing projection. Lines
     // protect ordinary documents and Unicode characters protect a single-line
     // bomb. Once a physical line is complete, a character cut retreats to that
     // line boundary rather than exposing a partial coordinate prefix.
     static #preview(text) {
-        const { lines: maxLines, chars: maxChars } = previewBounds();
         const coordinates = new TextCoordinates(text);
         const physicalLines = coordinates.logicalLines();
-        const lineEnd = physicalLines.length > maxLines
-            ? physicalLines[maxLines - 1].end
-            : text.length;
-        const characterEnd = PacketWire.#offsetAfterCharacters(text, maxChars);
-        let end = Math.min(lineEnd, characterEnd);
-        if (characterEnd < text.length && characterEnd <= lineEnd) {
-            const completeLine = physicalLines.findLast((line) => line.separator.length > 0 && line.end <= characterEnd);
-            if (completeLine !== undefined)
-                end = completeLine.end;
-        }
+        const { end } = BodyPreview.select(text);
         const cut = end < text.length;
         return {
             text: text.slice(0, end),
@@ -446,17 +408,22 @@ export default class PacketWire {
         };
     }
     static #visibleBody(entry, body) {
-        const folded = LogVisibility.parse(entry.folded ?? LogVisibility.OPEN);
+        const trimmed = LogVisibility.parse(entry.folded ?? LogVisibility.OPEN);
+        const folded = LogVisibility.combine(LogVisibility.parse(entry.initial_folded ?? LogVisibility.OPEN), trimmed);
         const lines = TextCoordinates.logicalLines(body.content);
         const totalLines = lines.length;
         const clipped = LogVisibility.clipped(folded, totalLines);
         const ordinals = LogVisibility.visibleLineOrdinals(clipped, totalLines);
+        const readableOrdinals = LogVisibility.visibleLineOrdinals(trimmed, totalLines);
+        const select = (selected) => selected.map((ordinal) => {
+            const line = lines[ordinal - 1];
+            return body.content.slice(line.start, line.end);
+        }).join("");
         return {
-            content: ordinals.map((ordinal) => {
-                const line = lines[ordinal - 1];
-                return body.content.slice(line.start, line.end);
-            }).join(""),
+            content: select(ordinals),
             ordinals,
+            readableContent: select(readableOrdinals),
+            readableOrdinals,
             folded: clipped,
             totalLines,
             fullyFolded: LogVisibility.fullyFolded(clipped, totalLines),
@@ -518,315 +485,343 @@ export default class PacketWire {
         }));
         const promptProjectionWeights = PacketWire.#promptProjectionWeights(entries, visibleBodies, visibility, weighContent, options.promptProjectionWeight);
         return entries.map((e, index) => {
-            const meta = {};
-            const coordinate = typeof e.coordinate === "string" ? e.coordinate : null;
-            const op = typeof e.op === "string" && e.op.length > 0 ? e.op : null;
-            const renderedLeaf = LogEntryProjection.leaf(e);
-            const path = PacketWire.#entryPath(coordinate, renderedLeaf);
-            // Absence = "model" — the worker's own authorship is the default,
-            // exactly as `source` absence means the owning worker (#338).
-            if (typeof e.origin === "string" && e.origin !== "model")
-                meta.origin = e.origin;
-            // {§env-delta-attribution}: render the causal worker address or
-            // subsystem token when present; absence means the owning worker.
-            if (typeof e.source === "string" && e.source.length > 0)
-                meta.source = e.source;
-            if (e.source === "file" && e.attrs !== null && typeof e.attrs === "object" && "git" in e.attrs) {
-                const git = e.attrs.git;
-                if (typeof git !== "string" || git.length !== 2) {
-                    throw new TypeError("A source=file log row carries malformed Git XY metadata.");
-                }
-                meta.git = git;
-            }
-            // Absence = 200 on an ordinary row — the clients' quiet grammar
-            // (plurnk#21) applied to the packet. SEND keeps its disposition,
-            // KILL keeps decisive destructive completion, a dissolving log-KILL
-            // receipt exists only to show its status ({§curation-receipt-dissolves}),
-            // and every non-200 stays explicit (#338).
-            if (typeof e.status === "number" && (op === "SEND" || op === "KILL" || e.status !== 200))
-                meta.status = e.status;
-            const tx = (typeof e.tx === "string" ? PacketWire.#safeParse(e.tx) : e.tx);
-            if (typeof tx?.annotation === "string")
-                meta.annotation = tx.annotation;
-            const target = PacketWire.#renderActionTarget(e.target);
-            // {§exec-stream}: a terminal stream observation's address is the stream it observed,
-            // rendered under `stream` like the invocation's own link — never a `target`, which
-            // the model would otherwise author into an EXEC slot (#425 F4).
-            const terminalStream = op === "READ"
-                && e.attrs !== null
-                && typeof e.attrs === "object"
-                && e.attrs.terminal === true;
-            if (op === "COPY" || op === "MOVE") {
-                const source = PacketWire.#renderSelection(tx?.source?.target, tx?.source?.lineMarker);
-                const destination = PacketWire.#renderSelection(tx?.destination?.target, tx?.destination?.lineMarker);
-                if (source !== null)
-                    meta.source = source;
-                if (destination !== null)
-                    meta.destination = destination;
-                if (typeof e.status === "number"
-                    && e.status < 400
-                    && (source === null || destination === null)) {
-                    throw new Error(`A successful ${op} log row must retain both operand selections.`);
-                }
-            }
-            else if (target !== null) {
-                meta[terminalStream ? "stream" : "target"] = target;
-            }
-            // EXEC's output is a separate stream entry ({§exec-stream}); its address rides in a
-            // `stream` link, distinct from the runtime-owned invocation target.
-            // {§exec-target-routing} {§fs-namespace} — the receipt names the working directory only
-            // when it is not the project root, and then in the model's own project-relative form;
-            // the root is the default and a host-absolute path never reaches the packet.
-            if (op === "EXEC" && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.cwd === "string") {
-                const cwd = PacketWire.#projectRelativeCwd(e.attrs.cwd, options.projectRoot ?? null);
-                if (cwd !== null)
-                    meta.cwd = cwd;
-            }
-            if (op === "EXEC" && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.stream === "string") {
-                meta.stream = e.attrs.stream;
-            }
+            const identity = PacketWire.#rowIdentity(e, options);
             // Parse rx once — reused for the matcher/items enrichment and the body.
             const rx = (typeof e.rx === "string" ? PacketWire.#safeParse(e.rx) : e.rx);
-            // {§exec-stream}: a terminal stream observation is self-sufficient
-            // even when its selected channel is empty. Preserve exact producer
-            // facts; do not manufacture a prose completion summary.
-            if (terminalStream) {
-                meta.terminal = true;
-                if (rx !== null && typeof rx === "object" && Object.hasOwn(rx, "exitCode")) {
-                    if (typeof rx.exitCode !== "number" || !Number.isSafeInteger(rx.exitCode)) {
-                        throw new TypeError("A terminal stream result carries a malformed exitCode.");
-                    }
-                    meta.exitCode = rx.exitCode;
+            const facts = PacketWire.#rowResultFacts(identity, e, rx);
+            const projected = PacketWire.#rowBody(identity, e, bodies[index], visibility[index], facts, promptProjectionWeights.get(index), weighContent);
+            return PacketWire.#rowAccounting(identity, e, bodies[index], visibility[index], projected, weighContent, options);
+        });
+    }
+    // The row's identity and authored facts: who wrote it, what it addressed, and the statuses
+    // that stay explicit. `meta` is the metadata line under construction; each later stage adds
+    // to it, and {§log-wire-format}'s canonical JSON sorts the keys, so the order of stages never
+    // reaches the wire.
+    static #rowIdentity(e, options) {
+        const meta = {};
+        const coordinate = typeof e.coordinate === "string" ? e.coordinate : null;
+        const op = typeof e.op === "string" && e.op.length > 0 ? e.op : null;
+        const renderedLeaf = LogEntryProjection.leaf(e);
+        const path = PacketWire.#entryPath(coordinate, renderedLeaf);
+        // Absence = "model" — the worker's own authorship is the default,
+        // exactly as `source` absence means the owning worker (#338).
+        if (typeof e.origin === "string" && e.origin !== "model")
+            meta.origin = e.origin;
+        // {§env-delta-attribution}: render the causal worker address or
+        // subsystem token when present; absence means the owning worker.
+        if (typeof e.source === "string" && e.source.length > 0)
+            meta.source = e.source;
+        if (e.source === "file" && e.attrs !== null && typeof e.attrs === "object" && "git" in e.attrs) {
+            const git = e.attrs.git;
+            if (typeof git !== "string" || git.length !== 2) {
+                throw new TypeError("A source=file log row carries malformed Git XY metadata.");
+            }
+            meta.git = git;
+        }
+        // SEND, TASK, destructive KILL, and non-200 statuses stay explicit.
+        // Successful log-KILL rows never reach this projection
+        // ({§log-kill-meta-operation}).
+        if (typeof e.status === "number" && (op === "SEND" || op === "KILL" || typeof op === "string" && TurnDisposition.isOp(op) || e.status !== 200))
+            meta.status = e.status;
+        const tx = (typeof e.tx === "string" ? PacketWire.#safeParse(e.tx) : e.tx);
+        if (typeof tx?.aside === "string")
+            meta.aside = tx.aside;
+        const target = PacketWire.#renderActionTarget(e.target);
+        // {§exec-stream}: a terminal stream observation's address is the stream it observed,
+        // rendered under `stream` like the invocation's own link — never a `target`, which
+        // the model would otherwise author into an execution slot (#425 F4).
+        const terminalStream = op === "READ"
+            && e.attrs !== null
+            && typeof e.attrs === "object"
+            && e.attrs.terminal === true;
+        if (op === "COPY" || op === "MOVE") {
+            const source = PacketWire.#renderSelection(tx?.source?.target, tx?.source?.lineMarker);
+            const destination = PacketWire.#renderSelection(tx?.destination?.target, tx?.destination?.lineMarker);
+            if (source !== null)
+                meta.source = source;
+            if (destination !== null)
+                meta.destination = destination;
+            if (typeof e.status === "number"
+                && e.status < 400
+                && (source === null || destination === null)) {
+                throw new Error(`A successful ${op} log row must retain both operand selections.`);
+            }
+        }
+        else if (target !== null) {
+            meta[terminalStream ? "stream" : "target"] = target;
+        }
+        // {§worker-auto-name} The created identity is an outcome, not an authored target.
+        if ((op === "WORK" || op === "FORK") && e.attrs !== null && typeof e.attrs === "object"
+            && typeof e.attrs.worker === "string") {
+            meta.worker = e.attrs.worker;
+        }
+        // An execution's output is a separate stream entry ({§exec-stream}); its address rides in a
+        // `stream` link, distinct from the runtime-owned invocation target.
+        // {§exec-target-routing} {§fs-namespace} — the receipt names the working directory only
+        // when it is not the project root, and then in the model's own project-relative form;
+        // the root is the default and a host-absolute path never reaches the packet.
+        if (isExecutionOp(op) && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.cwd === "string") {
+            const cwd = PacketWire.#projectRelativeCwd(e.attrs.cwd, options.projectRoot ?? null);
+            if (cwd !== null)
+                meta.cwd = cwd;
+        }
+        if (isExecutionOp(op) && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.stream === "string") {
+            meta.stream = e.attrs.stream;
+        }
+        return { meta, op, tx, coordinate, path, renderedLeaf, target, terminalStream };
+    }
+    // The row's result facts from its rx: the terminal stream's exit, the Problem or detail, the
+    // matcher, the retrieval extents, and the structured mutation receipts. Returns what the body
+    // projection needs to know about the result.
+    static #rowResultFacts(identity, e, rx) {
+        const { meta, op, tx, terminalStream } = identity;
+        // {§exec-stream}: a terminal stream observation is self-sufficient
+        // even when its selected channel is empty. Preserve exact producer
+        // facts; do not manufacture a prose completion summary.
+        if (terminalStream) {
+            meta.terminal = true;
+            if (rx !== null && typeof rx === "object" && Object.hasOwn(rx, "exitCode")) {
+                if (typeof rx.exitCode !== "number" || !Number.isSafeInteger(rx.exitCode)) {
+                    throw new TypeError("A terminal stream result carries a malformed exitCode.");
                 }
+                meta.exitCode = rx.exitCode;
+            }
+        }
+        // {§problem-projection} — the exact durable Problem remains the
+        // failure authority; the packet carries only facts not already
+        // owned by its enclosing row. Errors remains only an index.
+        if (typeof e.status === "number" && e.status >= 400 && rx !== null && typeof rx === "object") {
+            const problem = rx.problem;
+            Validator.assertProblemDetails(problem);
+            meta.problem = Problems.project(problem, {
+                status: e.status,
+                row: meta,
+            });
+        }
+        // The success-side sibling (#342): a sub-problem receipt may carry one
+        // terse `detail` (e.g. the EDIT 304) so situational teaching is paid
+        // only when the situation occurs, never in the hot path.
+        if (!Object.hasOwn(meta, "problem") && rx !== null && typeof rx === "object"
+            && typeof rx.detail === "string"
+            && rx.detail.length > 0) {
+            meta.detail = rx.detail;
+        }
+        // {§retrieval-packet-metadata}: one extent/coordinate owner plus
+        // only FIND aggregates that add information beyond that extent.
+        let findItems = null;
+        const patterned = tx !== null && tx !== undefined && typeof tx === "object" && tx.matcher !== null && typeof tx.matcher === "object" && typeof tx.matcher.raw === "string";
+        if (patterned) {
+            meta.matcher = tx.matcher.raw;
+            if (op !== "FIND" && rx !== null && typeof rx === "object" && typeof rx.matched === "number")
+                meta.matched = rx.matched;
+        }
+        // {§channel-selection-visibility} — a READ names the resource's other channels with their
+        // tokens, so the row itself shows the choice a FIND listing would.
+        if (op === "READ" && rx !== null && typeof rx === "object" && rx.channels !== null && typeof rx.channels === "object") {
+            meta.channels = rx.channels;
+        }
+        // {§send-response-receipt} — a reply's row names the prompts it answered.
+        if (op === "SEND" && rx !== null && typeof rx === "object" && Array.isArray(rx.recipients)) {
+            meta.recipients = rx.recipients;
+        }
+        if (op === "READ" || op === "FIND") {
+            if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.content === "string") {
+                const parsed = PacketWire.#safeParse(rx.content);
+                if (Array.isArray(parsed))
+                    findItems = parsed.length;
             }
-            // {§problem-projection} — the exact durable Problem remains the
-            // failure authority; the packet carries only facts not already
-            // owned by its enclosing row. Errors remains only an index.
-            if (typeof e.status === "number" && e.status >= 400 && rx !== null && typeof rx === "object") {
-                const problem = rx.problem;
-                Validator.assertProblemDetails(problem);
-                meta.problem = Problems.project(problem, {
-                    status: e.status,
-                    row: meta,
-                });
+            const range = rx !== null && typeof rx === "object" && rx.range !== undefined
+                ? rx.range
+                : undefined;
+            const problemOwnsRange = typeof e.status === "number"
+                && e.status >= 400
+                && meta.problem !== null
+                && typeof meta.problem === "object"
+                && Object.hasOwn(meta.problem, "range");
+            if (problemOwnsRange) {
+                Validator.assertRangeExtent(meta.problem.range);
             }
-            // The success-side sibling (#342): a sub-problem receipt may carry one
-            // terse `detail` (e.g. the EDIT 304) so situational teaching is paid
-            // only when the situation occurs, never in the hot path.
-            if (!Object.hasOwn(meta, "problem") && rx !== null && typeof rx === "object"
-                && typeof rx.detail === "string"
-                && rx.detail.length > 0) {
-                meta.detail = rx.detail;
+            if (range !== undefined && !problemOwnsRange) {
+                meta.range = Validator.assertRangeExtent(range);
             }
-            // {§retrieval-packet-metadata}: one extent/coordinate owner plus
-            // only FIND aggregates that add information beyond that extent.
-            let findItems = null;
-            if (op === "READ" || op === "FIND") {
-                const findMatcher = op === "FIND"
-                    && tx !== null
-                    && tx !== undefined
-                    && typeof tx === "object"
-                    && tx.body !== null
-                    && typeof tx.body === "object";
-                if (findMatcher) {
-                    const body = tx?.body;
-                    if (body !== null && typeof body === "object" && typeof body.raw === "string") {
-                        meta.matcher = body.raw;
-                    }
-                }
-                if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.content === "string") {
-                    const parsed = PacketWire.#safeParse(rx.content);
-                    if (Array.isArray(parsed))
-                        findItems = parsed.length;
-                }
-                const range = rx !== null && typeof rx === "object" && rx.range !== undefined
-                    ? rx.range
-                    : undefined;
-                const problemOwnsRange = typeof e.status === "number"
-                    && e.status >= 400
-                    && meta.problem !== null
-                    && typeof meta.problem === "object"
-                    && Object.hasOwn(meta.problem, "range");
-                if (problemOwnsRange) {
-                    Validator.assertRangeExtent(meta.problem.range);
-                }
-                if (range !== undefined && !problemOwnsRange) {
-                    meta.range = Validator.assertRangeExtent(range);
-                }
-                else if (op === "READ" && rx !== null && typeof rx === "object" && rx.region !== undefined) {
-                    meta.region = Validator.assertTextRegion(rx.region);
-                }
-                // These are underlying selected-content weights, distinct from
-                // the emitted body's generic `tokens` measurement.
-                if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.itemsWeightTotal === "number" && rx.itemsWeightTotal > 0) {
-                    meta.itemsTokenTotal = rx.itemsWeightTotal;
-                }
-                if (op === "FIND"
-                    && rx !== null
-                    && typeof rx === "object"
-                    && typeof rx.returnedItemsWeightTotal === "number"
-                    && rx.returnedItemsWeightTotal > 0
-                    && rx.returnedItemsWeightTotal !== rx.itemsWeightTotal) {
-                    meta.returnedItemsTokenTotal = rx.returnedItemsWeightTotal;
-                }
-                if (findMatcher
-                    && range !== null
-                    && typeof range === "object"
-                    && range.unit === "resource"
-                    && rx !== null
-                    && typeof rx === "object"
-                    && typeof rx.matchLocationCount === "number"
-                    && rx.matchLocationCount > 0) {
-                    meta.matchLocationCount = rx.matchLocationCount;
-                }
+            else if (op === "READ" && rx !== null && typeof rx === "object" && rx.region !== undefined) {
+                meta.region = Validator.assertTextRegion(rx.region);
             }
-            // {§edit-result-receipt-projection} {§edit-result-copy-move-effects}
-            // Mutations expose compact, validated outcome metadata. EDIT owns
-            // one receipt; COPY/MOVE own ordered resource effects whose
-            // optional receipts describe scoped textual materializations.
-            let structuredMutationReceipt = false;
-            if (op === "EDIT" && rx !== null && typeof rx === "object" && Object.hasOwn(rx, "receipt")) {
-                Object.assign(meta, PacketWire.#receiptMeta(rx.receipt));
-                structuredMutationReceipt = true;
+            // These are underlying selected-content weights, distinct from
+            // the emitted body's generic `tokens` measurement.
+            if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.itemsWeightTotal === "number" && rx.itemsWeightTotal > 0) {
+                meta.itemsTokenTotal = rx.itemsWeightTotal;
             }
-            if ((op === "COPY" || op === "MOVE")
+            if (op === "FIND"
                 && rx !== null
                 && typeof rx === "object"
-                && Object.hasOwn(rx, "effects")) {
-                const effects = assertResourceEffects(rx.effects);
-                meta.effects = effects.map((effect) => ({
-                    target: effect.target,
-                    action: effect.action,
-                    ...(effect.receipt === undefined
-                        ? {}
-                        : PacketWire.#receiptMeta(effect.receipt)),
-                }));
-                structuredMutationReceipt = effects.some((effect) => effect.receipt !== undefined);
-            }
-            // The canonical full body is shared with log READ, log FIND,
-            // and search derivation. READ/FIND own selection bounds, PLAN is
-            // persistent working memory, and prompt rows share their packet
-            // allowance. Structured mutation receipts own their join bound;
-            // every remaining body uses the ordinary fixed preview.
-            const fullBody = bodies[index];
-            const bodyVisibility = visibility[index];
-            const projectedBody = bodyVisibility.fullyFolded
-                ? fullBody
-                : { ...fullBody, content: bodyVisibility.content };
-            const emptyFind = op === "FIND" && e.status === 200 && findItems === 0;
-            const previewExempt = op === "READ"
-                || op === "FIND"
-                || op === "PLAN"
-                || structuredMutationReceipt;
-            const lineAnchors = op === "READ" ? e.lineAnchors ?? null : null;
-            const lineNumberWidth = op === "READ" ? e.lineNumberWidth ?? null : null;
-            if (lineAnchors !== null) {
-                LineAnchors.assertProjection(fullBody.content, lineAnchors);
-            }
-            const findRange = op === "FIND" && meta.range !== null && typeof meta.range === "object"
-                ? meta.range
-                : null;
-            const bodyStartLine = findRange?.returned?.[0] ?? fullBody.startLine;
-            const numericLineNumberWidth = findRange === null
-                ? bodyStartLine === null || bodyVisibility.totalLines === 0
-                    ? 0
-                    : String(bodyStartLine + bodyVisibility.totalLines - 1).length
-                : String(findRange.total).length;
-            const allOrdinals = Array.from({ length: bodyVisibility.totalLines }, (_, ordinal) => ordinal + 1);
-            const sourceOrdinals = bodyVisibility.fullyFolded
-                ? allOrdinals
-                : bodyVisibility.ordinals;
-            const promptProjectionWeight = promptProjectionWeights.get(index);
-            const projection = promptProjectionWeight !== undefined
-                ? PacketWire.#promptProjection(projectedBody, promptProjectionWeight, weighContent, (content) => PacketWire.#renderContentBody(content, bodyStartLine, null, null, numericLineNumberWidth, bodyStartLine === null
-                    ? null
-                    : sourceOrdinals.slice(0, TextCoordinates.logicalLines(content).length)))
-                : previewExempt
-                    ? { text: projectedBody.content, cut: false, chunk: null }
-                    : PacketWire.#preview(projectedBody.content);
-            const projectedLineCount = TextCoordinates.logicalLines(projection.text).length;
-            const projectedOrdinals = sourceOrdinals.slice(0, projectedLineCount);
-            const body = emptyFind || projection.text.length === 0
-                ? ""
-                : PacketWire.#renderContentBody(projection.text, bodyStartLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, bodyStartLine === null ? null : projectedOrdinals);
-            // {§packet-token-accounting} — tokensBody reports the projected body's weight even
-            // when that body is withheld. Active accounting happens only after every field and
-            // the final row framing are known below.
-            const renderedBodyWeight = body.length > 0 ? weighContent(body) : 0;
-            // Never tokensBody:0 — a zero-weight visible body is field absence, and
-            // tokensBody presence is what marks the folded state (#338).
-            if (fullBody.content.length > 0 && renderedBodyWeight > 0)
-                meta.tokensBody = renderedBodyWeight;
-            // lines beside tokens on a non-retrieval row with a navigable body — the count of
-            // `N:`-numbered lines (fences and unnumbered prose don't count), so the model can plan
-            // a <start,end> slice before paying for a READ. READ/FIND own typed extents instead.
-            if (fullBody.content.length > 0 && op !== "READ" && op !== "FIND") {
-                meta.lines = bodyVisibility.totalLines;
+                && typeof rx.returnedItemsWeightTotal === "number"
+                && rx.returnedItemsWeightTotal > 0
+                && rx.returnedItemsWeightTotal !== rx.itemsWeightTotal) {
+                meta.returnedItemsTokenTotal = rx.returnedItemsWeightTotal;
             }
-            if (bodyVisibility.folded.length > 0 && !bodyVisibility.fullyFolded) {
-                meta.folded = LogVisibility.format(bodyVisibility.folded);
+            if (op === "FIND"
+                && patterned
+                && range !== null
+                && typeof range === "object"
+                && range.unit === "resource"
+                && rx !== null
+                && typeof rx === "object"
+                && typeof rx.matchLocationCount === "number"
+                && rx.matchLocationCount > 0) {
+                meta.matchLocationCount = rx.matchLocationCount;
             }
-            // {§log-wire-format} — the three body states stay self-describing:
-            // coordinate lines ⇒ visible, `tokensBody` without lines ⇒ suppressed,
-            // neither ⇒ no canonical body.
-            const display = fullBody.content.length === 0
-                ? "none"
-                : bodyVisibility.fullyFolded
-                    ? "folded"
-                    : body.length === 0
-                        ? "none"
-                        : "open";
-            const projectedChunk = projection.chunk !== null
-                && bodyVisibility.folded.length > 0
-                && !bodyVisibility.fullyFolded
-                ? PacketWire.#sparseChunk(fullBody.content, projectedBody.content, sourceOrdinals, projection.text)
-                : projection.chunk;
-            if (display === "open" && projectedChunk !== null)
-                meta.chunk = projectedChunk;
-            const renderRow = () => {
-                const metadata = PacketWire.#canonicalJson(meta);
-                return display === "open"
-                    ? `### ${path}\n${metadata}\n${body}`
-                    : `### ${path}\n${metadata}`;
-            };
-            // The accounting field participates in the row it measures. Iterate
-            // until its decimal width and therefore the rendered row's curation
-            // weight are stable. The metadata share is derivable (tokensActive −
-            // tokensBody when open; tokensActive otherwise) and feeds no
-            // curation decision, so it is not serialized (#338).
-            // {§packet-attachment-parts} — only an undelivered READ supported by this request's
-            // route contributes native content and its weight.
-            const candidate = display === "open"
-                && op === "READ"
-                && (e.native_delivered_at === null || e.native_delivered_at === undefined)
-                ? PacketWire.#attachmentOf(e.rx, e.target, coordinate, target)
-                : null;
-            const attachment = candidate !== null
-                && (options.acceptedAttachmentKinds?.has(candidate.kind) ?? true)
-                ? candidate
-                : null;
-            if (attachment !== null)
-                meta.tokensAttachment = attachment.weight;
-            meta.tokensActive = 0;
-            for (let pass = 0; pass < 8; pass += 1) {
-                const tokensActive = weighContent(renderRow()) + (attachment?.weight ?? 0);
-                if (meta.tokensActive === tokensActive) {
-                    const tokensBody = typeof meta.tokensBody === "number" ? meta.tokensBody : 0;
-                    return {
-                        content: renderRow(),
-                        reclaimableBody: display === "open" && tokensBody > 0
-                            ? { path, tokensBody, tokensActive }
-                            : null,
-                        attachment,
-                    };
-                }
-                meta.tokensActive = tokensActive;
+        }
+        // {§edit-result-receipt-projection} {§edit-result-copy-move-effects}
+        // EDIT/scoped entry KILL own one receipt; COPY/MOVE own resource effects whose
+        // optional receipts describe scoped textual materializations.
+        let structuredMutationReceipt = false;
+        if ((op === "EDIT" || op === "KILL") && rx !== null && typeof rx === "object" && Object.hasOwn(rx, "receipt")) {
+            Object.assign(meta, PacketWire.#receiptMeta(rx.receipt));
+            structuredMutationReceipt = true;
+        }
+        if ((op === "COPY" || op === "MOVE")
+            && rx !== null
+            && typeof rx === "object"
+            && Object.hasOwn(rx, "effects")) {
+            const effects = assertResourceEffects(rx.effects);
+            meta.effects = effects.map((effect) => ({
+                target: effect.target,
+                action: effect.action,
+                ...(effect.receipt === undefined
+                    ? {}
+                    : PacketWire.#receiptMeta(effect.receipt)),
+            }));
+            structuredMutationReceipt = effects.some((effect) => effect.receipt !== undefined);
+        }
+        return { findItems, structuredMutationReceipt };
+    }
+    // The body the row shows: the canonical full body is shared with log READ, log FIND, and
+    // search derivation. READ/FIND own selection bounds, TASK and admitted programs remain
+    // complete, and prompt rows share their packet allowance. Structured mutation receipts own
+    // their join bound; every remaining body uses the ordinary fixed preview.
+    static #rowBody(identity, e, fullBody, bodyVisibility, facts, promptProjectionWeight, weighContent) {
+        const { meta, op, renderedLeaf } = identity;
+        const projectedBody = {
+            ...fullBody,
+            content: bodyVisibility.fullyFolded ? bodyVisibility.readableContent : bodyVisibility.content,
+        };
+        const emptyFind = op === "FIND" && e.status === 200 && facts.findItems === 0;
+        const previewExempt = op === "READ"
+            || op === "FIND"
+            || op === "TASK"
+            || (op === null && renderedLeaf === "ops")
+            || facts.structuredMutationReceipt;
+        const lineAnchors = op === "READ" ? e.lineAnchors ?? null : null;
+        const lineNumberWidth = op === "READ" ? e.lineNumberWidth ?? null : null;
+        if (lineAnchors !== null) {
+            LineAnchors.assertProjection(fullBody.content, lineAnchors);
+        }
+        const findRange = op === "FIND" && meta.range !== null && typeof meta.range === "object"
+            ? meta.range
+            : null;
+        const bodyStartLine = findRange?.returned?.[0] ?? fullBody.startLine;
+        const numericLineNumberWidth = findRange === null
+            ? bodyStartLine === null || bodyVisibility.totalLines === 0
+                ? 0
+                : String(fullBody.lineOrdinals?.at(-1) ?? bodyStartLine + bodyVisibility.totalLines - 1).length
+            : String(findRange.total).length;
+        const sourceOrdinals = bodyVisibility.fullyFolded
+            ? bodyVisibility.readableOrdinals
+            : bodyVisibility.ordinals;
+        const projection = promptProjectionWeight !== undefined
+            ? PacketWire.#promptProjection(projectedBody, promptProjectionWeight, weighContent, (content) => PacketWire.#renderContentBody(content, bodyStartLine, null, null, numericLineNumberWidth, bodyStartLine === null
+                ? null
+                : sourceOrdinals.slice(0, TextCoordinates.logicalLines(content).length)))
+            : previewExempt
+                ? { text: projectedBody.content, cut: false, chunk: null }
+                : PacketWire.#preview(projectedBody.content);
+        const projectedLineCount = TextCoordinates.logicalLines(projection.text).length;
+        const projectedOrdinals = sourceOrdinals.slice(0, projectedLineCount);
+        const body = emptyFind || projection.text.length === 0
+            ? ""
+            : PacketWire.#renderContentBody(projection.text, bodyStartLine, lineAnchors, lineNumberWidth, numericLineNumberWidth, bodyStartLine === null ? null : projectedOrdinals, fullBody.lineOrdinals ?? null);
+        // lines beside tokens on a non-retrieval row with a navigable body — the count of
+        // `N:`-numbered lines (fences and unnumbered prose don't count), so the model can plan
+        // a <start,end> slice before paying for a READ. READ/FIND own typed extents instead.
+        if (fullBody.content.length > 0 && op !== "READ" && op !== "FIND") {
+            meta.lines = bodyVisibility.totalLines;
+        }
+        if (bodyVisibility.folded.length > 0 && !bodyVisibility.fullyFolded) {
+            meta.folded = LogVisibility.format(bodyVisibility.folded);
+        }
+        const display = bodyVisibility.readableContent.length === 0
+            ? "none"
+            : bodyVisibility.fullyFolded || e.output_withheld === true
+                ? "folded"
+                : body.length === 0
+                    ? "none"
+                    : "open";
+        const projectedChunk = projection.chunk !== null
+            && bodyVisibility.folded.length > 0
+            && !bodyVisibility.fullyFolded
+            ? PacketWire.#sparseChunk(fullBody.content, projectedBody.content, sourceOrdinals, projection.text)
+            : projection.chunk;
+        if (display === "open" && projectedChunk !== null)
+            meta.chunk = projectedChunk;
+        return { body, projectedLineCount, display };
+    }
+    // The row's native attachment, its withholding receipt, and the accounting field that
+    // participates in the row it measures: iterate until its decimal width and therefore the
+    // rendered row's curation weight are stable. {§packet-token-accounting}
+    static #rowAccounting(identity, e, fullBody, bodyVisibility, projected, weighContent, options) {
+        const { meta, op, coordinate, path, target } = identity;
+        const { body, projectedLineCount, display } = projected;
+        const nativeCandidate = op === "READ" && typeof e.status === "number" && e.status >= 200 && e.status < 300
+            ? PacketWire.#attachmentOf(e.rx, e.target, coordinate, target) : null;
+        const native = nativeCandidate !== null && (options.acceptedAttachmentKinds?.has(nativeCandidate.kind) ?? true)
+            ? nativeCandidate : null;
+        const outputWithheld = e.output_withheld === true
+            && ((!bodyVisibility.fullyFolded && body.length > 0) || native !== null);
+        if (outputWithheld) {
+            const omitted = body.length > 0
+                ? `${projectedLineCount} output lines${native === null ? "" : " and native content"}`
+                : "native content";
+            meta.overflow = `${omitted} not shown; the log exceeded logTokensMax when this row was withheld`;
+        }
+        const renderRow = () => {
+            const metadata = PacketWire.#canonicalJson(meta);
+            return display === "open"
+                ? `### ${path}\n${metadata}\n${body}`
+                : `### ${path}\n${metadata}`;
+        };
+        // {§packet-attachment-parts}: retained native content shares the row's curation lifetime.
+        const attachment = e.output_withheld !== true
+            && !(bodyVisibility.totalLines > 0 && bodyVisibility.fullyFolded)
+            ? native
+            : null;
+        if (attachment !== null)
+            meta.tokensAttachment = attachment.weight;
+        meta.logTokens = 0;
+        for (let pass = 0; pass < 8; pass += 1) {
+            const logTokens = weighContent(renderRow()) + (attachment?.weight ?? 0);
+            if (meta.logTokens === logTokens) {
+                return {
+                    content: renderRow(),
+                    curationTarget: { path, logTokens },
+                    attachment,
+                    unadmittedOutput: (display === "open" || attachment !== null)
+                        && fullBody.provenance === "returned"
+                        && e.output_admission_turn_id == null
+                        && typeof e.id === "number"
+                        ? e.id : null,
+                    newOverflow: outputWithheld && e.newOverflow === true,
+                };
             }
-            throw new Error("packet log row accounting did not converge");
-        });
+            meta.logTokens = logTokens;
+        }
+        throw new Error("packet log row accounting did not converge");
     }
     static #attachmentOf(rx, target, coordinate, path) {
         const view = rx;
+        const contentHash = rx?.nativeContentHash;
+        if (typeof contentHash !== "string")
+            return null;
         const pathname = typeof target?.pathname === "string" && target.pathname.length > 0
             ? target.pathname
             : typeof target?.raw === "string" ? target.raw : null;
@@ -837,17 +832,21 @@ export default class PacketWire {
         if (image !== undefined && typeof image.mimetype === "string" && Number.isSafeInteger(image.width) && Number.isSafeInteger(image.height)) {
             const width = image.width;
             const height = image.height;
-            return { coordinate, path, scheme, pathname, mimetype: image.mimetype, kind: "image", width, height, weight: imageWeight(width, height) };
+            return { contentHash, coordinate, path, scheme, pathname, mimetype: image.mimetype, kind: "image", width, height, weight: imageWeight(width, height) };
         }
         const document = view?.document;
-        if (document !== undefined && typeof document.mimetype === "string" && Number.isSafeInteger(document.pages)) {
-            const pages = document.pages;
-            return { coordinate, path, scheme, pathname, mimetype: document.mimetype, kind: "pdf", pages, weight: pdfWeight(pages) };
+        if (document !== undefined && typeof document.mimetype === "string" && Number.isSafeInteger(document.bytes)) {
+            const pages = Number.isSafeInteger(document.pages) ? document.pages : null;
+            return {
+                contentHash, coordinate, path, scheme, pathname, mimetype: document.mimetype, kind: "pdf",
+                ...(pages === null ? {} : { pages }),
+                weight: pdfWeight(pages, document.bytes),
+            };
         }
         return null;
     }
     // {§packet-attachment-parts} — the wire form with native parts: user text first, then each accepted
-    // file immediately followed by its reactive ejection sentence.
+    // retained native part in observation order.
     static async wireMessages(packet, bytesOf, accepts = () => true) {
         const [system, user] = PacketWire.packetToWireMessages(packet);
         const parts = [{ type: "text", text: user.content }];
@@ -855,13 +854,7 @@ export default class PacketWire {
             if (!accepts(attachment.kind))
                 continue;
             const bytes = await bytesOf(attachment);
-            if (bytes === null)
-                continue;
             parts.push({ type: "file", data: bytes, mediaType: attachment.mimetype });
-            parts.push({
-                type: "text",
-                text: `${attachment.path} has been ejected from context. It must be READ again to retain it in context.`,
-            });
         }
         return parts.length === 1 ? [system, user] : [system, { role: "user", content: parts }];
     }