@plurnk/plurnk-service 1.4.0 → 1.6.0

package/dist/core/packet-wire.js

@@ -7,10 +7,11 @@
 // Format and omission rules are owned by {§packet-markdown}. Section producers
 // supply names and typed content; this projection preserves their ordered evidence.
 import { Validator } from "@plurnk/plurnk-contracts";
-import { Results as SchemeResults } from "@plurnk/plurnk-schemes";
+import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
 import { renderTarget } from "./plurnk-uri.js";
 import LogBody from "./LogBody.js";
-import { assertEditReceipt, assertResourceEffects, } from "../content/index.js";
+import LogEntryProjection from "./LogEntryProjection.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);
@@ -91,23 +92,24 @@ export default class PacketWire {
         return items.map((r) => `* ${String(r.status)} ${String(r.path)}`).join("\n");
     }
     // The git section content: the working-tree summary. "" when absent.
-    static renderGit(git) {
-        return git === null || git === undefined ? "" : PacketWire.#renderGitState(git);
+    static renderGit(git, assignedBranch = null) {
+        const status = git === null || git === undefined ? "" : PacketWire.#renderGitState(git);
+        const assignment = assignedBranch === null
+            ? ""
+            : `assigned branch \`${assignedBranch}\` — commit any project changes and leave the checkout clean before concluding`;
+        return [status, assignment].filter((line) => line.length > 0).join("\n");
     }
     // The log section's content: the model's curated rows as a fenced `jsonplurnk` array ({§jsonplurnk}).
     // Data only — no prose leads the fence (the log carries rules for no one). Empty log → ""
     // (the section is omitted).
-    static renderLog(entries, countTokens) {
+    static renderLog(entries, countTokens, options = {}) {
         const log = Array.isArray(entries) ? entries : [];
         if (log.length === 0)
             return "";
-        const items = PacketWire.#renderLogEntries(log, countTokens);
-        // The opening fence is DYNAMIC — one backtick longer than the longest run in the rendered
-        // entries — so a code sample inside a body can never close the block early (CommonMark closes
-        // a fence only on a line of ≥ its own length). {§jsonplurnk-dynamic-fence}
-        const longestTicks = Math.max(0, ...[...items.matchAll(/`+/g)].map((m) => m[0].length));
-        const fence = "`".repeat(Math.max(3, longestTicks + 1));
-        return `${fence}jsonplurnk\n[\n${items}\n]\n${fence}`;
+        const items = PacketWire.#renderLogEntries(log, countTokens, options);
+        // Every source line is coordinate-prefixed, so source backticks never occupy the
+        // CommonMark closing-fence position. The fixed opener keeps the packet prefix cache-stable.
+        return `\`\`\`jsonplurnk\n[\n${items}\n]\n\`\`\``;
     }
     // Read one section's content by name off a packet (Engine's or re-parsed).
     // The legible accessor — consumers name the section they want instead of
@@ -126,31 +128,33 @@ export default class PacketWire {
             { role: "user", content: PacketWire.renderSlot(sections, "user") },
         ];
     }
-    // Number each line of body as `<N>:<line>` — a bare `N:` prefix, NO separator whitespace
+    // Number a non-READ body line as `<N>:<line>` — a bare `N:` prefix, NO separator whitespace
     // ({§render-rule-line-navigable-prefix}): the leading digit prevents column-zero fence collisions and gives
-    // the model line refs for free (`READ<42-46>`), while the absence of any separator means a
+    // the model line refs for free (`## READ0 (...) <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.
     // Used for READ@200 content; index-preview numbering is the framework's
-    // job now (baked into the preview string — see renderHeredoc).
+    // job now (baked into the preview string).
     static #numberLines(body, start = 1) {
         let line = start;
-        return body.replace(/(^|\r\n|\r|\n)(?=[\s\S])/g, (separator) => `${separator}${line++}:`);
+        return `${line++}:${body.replace(/(\r\n|\r(?!\n)|\n)(?=[\s\S])/g, (separator) => `${separator}${line++}:`)}`;
     }
-    // The single content-body renderer EVERY output-emitting op routes through, so the line-number
-    // convention the model orients on can't drift. Every textual body receives
-    // the `N:` prefix from `startLine`; matchers consume canonical content before
-    // this presentation projection. Empty content produces no body.
-    static #renderContentBody(fence, content, startLine = 1) {
+    // The single content-body renderer EVERY output-emitting op routes through.
+    // 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) {
         if (content.length === 0)
             return "";
         // `startLine === null` means the producer already supplied numbered
         // content; re-numbering would duplicate its coordinates.
         const rendered = startLine !== null
-            ? PacketWire.#numberLines(content, startLine)
+            ? lineAnchors === null
+                ? PacketWire.#numberLines(content, startLine)
+                : LineAnchors.render(content, startLine, lineAnchors, lineNumberWidth ?? 0)
             : content;
-        return PacketWire.#wrapHeredocBody(fence, rendered);
+        return PacketWire.#quoteBody(rendered);
     }
     // Tolerant JSON parser for log entries' persisted rx/tx strings. The engine
     // pre-parses application/json mimetypes; malformed stored text is not JSON.
@@ -176,6 +180,7 @@ export default class PacketWire {
         const head = {
             rev: receipt.revision.slice(0, editReceiptRevisionChars()),
             extent: `${receipt.unit} ${receipt.before}->${receipt.after}`,
+            ...(receipt.parseIssues === undefined ? {} : { parseIssues: receipt.parseIssues }),
         };
         if ("effect" in receipt) {
             return {
@@ -196,18 +201,19 @@ export default class PacketWire {
                 }),
         };
     }
-    // Wrap a body in heredoc fences. The fence is FIXED (`<<BODY`/`BODY`), never the
-    // target: every body line is `N:`-prefixed, so a bare fence line can never occur
-    // inside a body, and a fixed fence gives the model nothing address-shaped to
-    // mimic back as op syntax — identity lives in the adjacent meta JSON. Leading
-    // `\n` always (separates the opening fence from the first body character).
-    // Trailing `\n` only when the body doesn't already end with one — otherwise you
-    // get a doubled newline that renders as a blank line before the closing fence,
-    // which reads as "the content has a trailing blank line" when actually it
-    // doesn't. The body's own whitespace decides the shape.
-    static #wrapHeredocBody(fence, body) {
-        const sep = body.endsWith("\n") ? "" : "\n";
-        return `<<BODY\n${body}${sep}BODY`;
+    // {§jsonplurnk} One deliberately raw multiline JSON string. The physical
+    // newline after the opening quote and every positive numeric or anchored coordinate prefix
+    // make the closing quote at column zero unambiguous without an invented
+    // delimiter for source text to imitate. Already-numbered producer output is
+    // checked here too: malformed bodies fail at the one projection boundary.
+    static #quoteBody(body) {
+        const endsWithLineBreak = /(?:\r\n|\r|\n)$/.test(body);
+        const lines = body.split(/\r\n|\r|\n/);
+        const contentLines = endsWithLineBreak ? lines.slice(0, -1) : lines;
+        if (contentLines.length === 0 || contentLines.some((line) => !/^[1-9]\d*:/.test(line) && !LineAnchors.isAnchoredLine(line))) {
+            throw new TypeError("A raw jsonplurnk body requires a positive coordinate prefix on every physical line.");
+        }
+        return `"\n${body}${endsWithLineBreak ? "" : "\n"}"`;
     }
     // Render one Log entry → a single bullet line carrying the meta JSON.
     // No body, no fence — every meaningful field is in the JSON. Naming
@@ -229,38 +235,180 @@ export default class PacketWire {
             return null;
         return op !== null ? `log:///${coordinate}/${op}` : `log:///${coordinate}`;
     }
+    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 chars protect a single-line bomb.
+    // 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();
-        let lineEnd = text.length;
-        let newline = -1;
-        for (let line = 0; line < maxLines; line++) {
-            newline = text.indexOf("\n", newline + 1);
-            if (newline === -1)
+        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 cut = end < text.length;
+        return {
+            text: text.slice(0, end),
+            cut,
+            chunk: cut ? PacketWire.#chunk(coordinates, physicalLines, end, text.length) : null,
+        };
+    }
+    static #formatRegion(region) {
+        return `<${region.startLine},${region.startColumn},${region.endLine},${region.endColumn}>`;
+    }
+    static #chunk(coordinates, lines, end, completeEnd) {
+        const finalCompleteLine = lines.findIndex((line) => line.separator.length > 0 && line.end === end);
+        if (finalCompleteLine !== -1) {
+            const selected = `<1,${finalCompleteLine + 1}>`;
+            const complete = `<1,${lines.length}>`;
+            if (selected === complete) {
+                throw new Error("a bounded body chunk must differ from its complete line extent");
+            }
+            return `showing ${selected} of ${complete}`;
+        }
+        const selectedRegion = coordinates.regionFromOffsets(0, end);
+        const completeRegion = coordinates.regionFromOffsets(0, completeEnd);
+        if (selectedRegion === null || completeRegion === null) {
+            throw new Error("a character-bound body chunk must resolve to exact text coordinates");
+        }
+        const selected = PacketWire.#formatRegion(selectedRegion);
+        const complete = PacketWire.#formatRegion(completeRegion);
+        if (selected === complete) {
+            throw new Error("a bounded body chunk must differ from its complete text extent");
+        }
+        return `showing ${selected} of ${complete}`;
+    }
+    static #promptProjection(body, budget, countTokens) {
+        const weightAt = (end) => countTokens(PacketWire.#renderContentBody(body.content.slice(0, end), body.startLine, null));
+        if (weightAt(body.content.length) <= budget) {
+            return { text: body.content, cut: false, chunk: null };
+        }
+        if (budget <= 0)
+            return { text: "", cut: true, chunk: null };
+        const coordinates = new TextCoordinates(body.content);
+        const lines = coordinates.logicalLines();
+        const completeLineEnds = lines
+            .filter((line) => line.separator.length > 0 && line.end < body.content.length)
+            .map((line) => line.end);
+        let low = 0;
+        let high = completeLineEnds.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            if (weightAt(completeLineEnds[middle]) <= budget)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        const completeLineEnd = low === 0 ? 0 : completeLineEnds[low - 1];
+        if (completeLineEnd > 0) {
+            return {
+                text: body.content.slice(0, completeLineEnd),
+                cut: true,
+                chunk: PacketWire.#chunk(coordinates, lines, completeLineEnd, body.content.length),
+            };
+        }
+        const firstLineEnd = lines[0]?.contentEnd ?? body.content.length;
+        const offsets = [0];
+        let offset = 0;
+        for (const codePoint of body.content.slice(0, firstLineEnd)) {
+            offset += codePoint.length;
+            offsets.push(offset);
+        }
+        low = 0;
+        high = offsets.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            if (weightAt(offsets[middle]) <= budget)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        const characterEnd = low === 0 ? 0 : offsets[low - 1];
+        if (characterEnd === 0)
+            return { text: "", cut: true, chunk: null };
+        return {
+            text: body.content.slice(0, characterEnd),
+            cut: true,
+            chunk: PacketWire.#chunk(coordinates, lines, characterEnd, body.content.length),
+        };
+    }
+    static #promptBudgets(entries, bodies, countTokens, budget) {
+        if (budget === undefined)
+            return new Map();
+        if (!Number.isSafeInteger(budget) || budget < 0) {
+            throw new RangeError(`promptProjectionBudget must be a non-negative safe integer, got ${JSON.stringify(budget)}`);
+        }
+        const costs = entries.flatMap((entry, index) => {
+            if (entry.op !== "prompt" || entry.folded === true || bodies[index].content.length === 0)
+                return [];
+            const rendered = PacketWire.#renderContentBody(bodies[index].content, bodies[index].startLine, null);
+            return [{ index, cost: countTokens(rendered) }];
+        });
+        const allocations = new Map();
+        let remaining = budget;
+        let active = costs;
+        while (active.length > 0) {
+            const share = Math.floor(remaining / active.length);
+            const complete = active.filter(({ cost }) => cost <= share);
+            if (complete.length === 0) {
+                const extra = remaining % active.length;
+                active.forEach(({ index }, position) => allocations.set(index, share + (position < extra ? 1 : 0)));
                 break;
-            if (line === maxLines - 1)
-                lineEnd = newline + 1;
+            }
+            for (const { index, cost } of complete) {
+                allocations.set(index, cost);
+                remaining -= cost;
+            }
+            const completed = new Set(complete.map(({ index }) => index));
+            active = active.filter(({ index }) => !completed.has(index));
         }
-        const end = Math.min(text.length, lineEnd, maxChars);
-        return { text: text.slice(0, end), cut: end < text.length };
+        return allocations;
     }
-    static #renderLogEntries(entries, countTokens) {
-        return entries.map((e) => {
+    static #renderLogEntries(entries, countTokens, options) {
+        const bodies = entries.map((e) => {
+            const op = typeof e.op === "string" && e.op.length > 0 ? e.op : null;
+            return LogBody.resolve({
+                op,
+                attrs: e.attrs,
+                tx: e.tx,
+                rx: e.rx,
+                mimetypeTx: typeof e.mimetype_tx === "string" ? e.mimetype_tx : undefined,
+                mimetypeRx: typeof e.mimetype_rx === "string" ? e.mimetype_rx : undefined,
+            });
+        });
+        const promptBudgets = PacketWire.#promptBudgets(entries, bodies, countTokens, options.promptProjectionBudget);
+        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;
-            // An executor entry sink is durably journaled as the system EDIT that
-            // created the entry. That storage fact is not the model-facing action:
-            // the resulting resource is ordinary readable state pushed into its
-            // environment. Project it as a folded system READ so the log advertises
-            // the available operation instead of implying that the model or another
-            // agent authored a mutation. The coordinate still resolves the same
-            // underlying row; the typed attrs preserve exact replay/client semantics.
-            const materializedEntry = e.origin === "plurnk" && op === "EDIT"
-                && e.attrs !== null && typeof e.attrs === "object"
-                && e.attrs.kind === "entry_materialized";
-            const renderedOp = materializedEntry ? "READ" : op;
+            const renderedOp = LogEntryProjection.op(e);
+            const actionlessKind = op === null
+                ? LogBody.actionlessKind({ op, attrs: e.attrs })
+                : null;
             const path = PacketWire.#entryPath(coordinate, renderedOp);
             if (path !== null)
                 meta.path = path;
@@ -270,10 +418,29 @@ export default class PacketWire {
             // subsystem token when present; absence means the owning worker.
             if (typeof e.source === "string" && e.source.length > 0)
                 meta.source = e.source;
-            if (renderedOp !== null)
-                meta.op = renderedOp;
+            if (actionlessKind !== null)
+                meta.kind = actionlessKind;
+            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;
+            }
             if (typeof e.status === "number")
                 meta.status = e.status;
+            if (e.tags !== undefined) {
+                const storedTags = e.tags;
+                if (!Array.isArray(storedTags) || !storedTags.every((tag) => typeof tag === "string" && tag.length > 0)) {
+                    throw new TypeError("A log row carries malformed folksonomic tags.");
+                }
+                const tags = [...new Set(storedTags)].toSorted();
+                if (tags.length !== storedTags.length || tags.some((tag, index) => tag !== storedTags[index])) {
+                    throw new TypeError("A log row's folksonomic tags must be unique and sorted.");
+                }
+                if (tags.length > 0)
+                    meta.tags = tags;
+            }
             const tx = (typeof e.tx === "string" ? PacketWire.#safeParse(e.tx) : e.tx);
             const target = PacketWire.#renderActionTarget(e.target);
             if (op === "COPY" || op === "MOVE") {
@@ -297,7 +464,7 @@ export default class PacketWire {
                     meta.target = target;
             }
             // EXEC's output is a separate stream entry ({§exec-stream}); its address rides in a
-            // `stream` link, distinct from `target` (the cwd / executable path it ran in).
+            // `stream` link, distinct from the runtime-owned invocation target.
             if (op === "EXEC" && e.attrs !== null && typeof e.attrs === "object" && typeof e.attrs.stream === "string") {
                 meta.stream = e.attrs.stream;
             }
@@ -310,107 +477,144 @@ export default class PacketWire {
                 Validator.assertProblemDetails(problem);
                 meta.problem = problem;
             }
-            // READ + FIND enrichment: the matcher body, READ match coordinates,
-            // and FIND resource count. Match coordinates let the model choose a
-            // surgical follow-up READ without silently narrowing this result.
-            let items = null;
+            // {§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") {
-                if (tx !== null && tx !== undefined && typeof tx === "object" && tx.body !== null && typeof tx.body === "object") {
-                    if (typeof tx.body.raw === "string")
-                        meta.matcher = tx.body.raw;
+                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.omittedItems === "number") {
-                    items = rx.omittedItems; // {§find-count-not-contents} - selected-resource count, though rows were not enumerated
-                }
-                else if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.content === "string") {
+                if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.content === "string") {
                     const parsed = PacketWire.#safeParse(rx.content);
                     if (Array.isArray(parsed))
-                        items = parsed.length;
+                        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 (op === "READ" && rx !== null && typeof rx === "object" && rx.matches !== undefined) {
-                    meta.matches = SchemeResults.assertMatchEvidenceList(rx.matches);
+                if (range !== undefined && !problemOwnsRange) {
+                    meta.range = Validator.assertRangeExtent(range);
                 }
-                if (op === "READ" && rx !== null && typeof rx === "object" && rx.region !== undefined) {
+                else if (op === "READ" && rx !== null && typeof rx === "object" && rx.region !== undefined) {
                     meta.region = Validator.assertTextRegion(rx.region);
                 }
-                // The matched set's content weight (sum of the entries' live channel tokens) — the
-                // FIND self-describes its hits' READ-weight; carries the per-scheme roll-up in the foist.
-                if (op === "FIND" && rx !== null && typeof rx === "object" && typeof rx.itemsTokenTotal === "number") {
+                // 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.itemsTokenTotal === "number" && rx.itemsTokenTotal > 0) {
                     meta.itemsTokenTotal = rx.itemsTokenTotal;
                 }
+                if (op === "FIND"
+                    && rx !== null
+                    && typeof rx === "object"
+                    && typeof rx.returnedItemsTokenTotal === "number"
+                    && rx.returnedItemsTokenTotal > 0
+                    && rx.returnedItemsTokenTotal !== rx.itemsTokenTotal) {
+                    meta.returnedItemsTokenTotal = rx.returnedItemsTokenTotal;
+                }
+                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;
+                }
             }
             // {§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;
             }
             if ((op === "COPY" || op === "MOVE")
                 && rx !== null
                 && typeof rx === "object"
                 && Object.hasOwn(rx, "effects")) {
-                meta.effects = assertResourceEffects(rx.effects).map((effect) => ({
+                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 READ(log://), FIND(log://),
-            // and search derivation. Only a worker-issued READ/FIND result renders
-            // complete; every pushed, authored, ambient, plugin, and engine body
-            // uses this one preview projection.
-            const fullBody = LogBody.resolve({
-                op: op ?? "",
-                tx: e.tx,
-                rx: e.rx,
-                mimetypeTx: typeof e.mimetype_tx === "string" ? e.mimetype_tx : undefined,
-                mimetypeRx: typeof e.mimetype_rx === "string" ? e.mimetype_rx : undefined,
-            });
-            const emptyFind = op === "FIND" && e.status === 200 && items === 0;
-            const previewExempt = e.origin === "model" && (op === "READ" || op === "FIND");
-            const projection = previewExempt
-                ? { text: fullBody.content, cut: false }
-                : PacketWire.#preview(fullBody.content);
-            const resourceBody = op === "READ" || op === "FIND" || op === "EDIT"
-                || op === "prompt";
-            const bodyFence = resourceBody ? (target ?? path) : path;
+            // 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 emptyFind = op === "FIND" && e.status === 200 && findItems === 0;
+            const previewExempt = op === "READ"
+                || op === "FIND"
+                || op === "PLAN"
+                || structuredMutationReceipt;
+            const promptBudget = promptBudgets.get(index);
+            const projection = promptBudget !== undefined
+                ? PacketWire.#promptProjection(fullBody, promptBudget, countTokens)
+                : previewExempt
+                    ? { text: fullBody.content, cut: false, chunk: null }
+                    : PacketWire.#preview(fullBody.content);
             if (projection.cut && path === null) {
                 throw new Error("a previewed log body requires an addressable log path");
             }
-            if (projection.cut) {
-                meta.overflow = `Body content truncated. Use READ ${path} to view the full body.`;
-            }
+            const lineAnchors = op === "READ" ? e.lineAnchors ?? null : null;
+            const lineNumberWidth = op === "READ" ? e.lineNumberWidth ?? null : null;
             const body = emptyFind || projection.text.length === 0
                 ? ""
-                : PacketWire.#renderContentBody(bodyFence ?? `log:///${coordinate}`, projection.text, fullBody.startLine);
+                : PacketWire.#renderContentBody(projection.text, fullBody.startLine, lineAnchors, lineNumberWidth);
             // tokens on EVERY row (0 when there's genuinely no body) so the model can always weigh
-            // it; for a folded row this is the room an OPEN would add. items present even at 0.
-            if (items !== null)
-                meta.items = items;
+            // it; for a folded row this is the room an OPEN would add.
             // 0 for a genuinely empty body — never call countTokens("") (some providers return
             // undefined for it, which JSON.stringify would drop, leaving the row with no tokens).
             meta.tokens = body.length > 0 ? countTokens(body) : 0;
-            // lines beside tokens on any 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 an OPEN. Omitted when the body isn't line-addressable.
-            if (body.length > 0) {
+            // 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 an OPEN. READ/FIND own typed extents instead.
+            if (body.length > 0 && op !== "READ" && op !== "FIND") {
                 const navigable = body.split("\n").filter((l) => /^\d+:/.test(l)).length;
                 if (navigable > 0)
                     meta.lines = navigable;
             }
             // {§jsonplurnk} — `display` describes the three body states: `none` carries an explicit
             // empty JSON string, `folded` withholds an existing body, and `open` appends that body as
-            // the format's one non-JSON value (a raw, tagged heredoc). The explicit empty body keeps
+            // the format's one raw multiline string. The explicit empty body keeps
             // every state self-describing; OPEN/FOLD remain friendly no-ops on `none`.
             const display = body.length === 0 ? "none" : e.folded === true ? "folded" : "open";
             meta.display = display;
             if (display === "none")
                 meta.body = "";
             const obj = PacketWire.#canonicalJson(meta);
-            return display === "open" ? obj.replace(/\}$/, `,"body":\n${body}\n}`) : obj;
+            if (display !== "open")
+                return obj;
+            const chunk = projection.chunk !== null
+                ? `,"chunk":${JSON.stringify(projection.chunk)}`
+                : "";
+            return obj.replace(/\}$/, `,"body":${body}${chunk}}`);
         }).join(",\n");
     }
     static #renderActionTarget(target) {
@@ -437,9 +641,9 @@ export default class PacketWire {
             return null;
         if (marker === null || marker === undefined)
             return address;
-        const validation = Validator.validateLineMarker(marker);
+        const validation = Validator.validateTextLineMarker(marker);
         if (!validation.valid) {
-            throw new TypeError("A COPY/MOVE operand contains an invalid line marker.");
+            throw new TypeError("A COPY/MOVE operand contains an invalid text line marker.");
         }
         return `${address}<${marker.marks.join(",")}>`;
     }