@plurnk/plurnk-service 1.17.0 → 1.19.0

package/dist/core/packet-wire.js

@@ -3,13 +3,16 @@ import { relative, sep } from "node:path";
 import { Problems, Validator } from "@plurnk/plurnk-contracts";
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
 import { renderTarget } from "./plurnk-uri.js";
+import GitState from "./git-state.js";
 import LogBody from "./LogBody.js";
 import LogEntryProjection from "./LogEntryProjection.js";
 import LogVisibility from "./LogVisibility.js";
 import BodyPreview from "../content/body-preview.js";
+import ScopeFormat from "../content/scope-format.js";
 import { assertEditReceipt, assertResourceEffects, LineAnchors, } from "../content/index.js";
 // {§packet-attachment-parts} — the attachment kinds and their readout weights live in one table.
-import { imageWeight, pdfWeight } from "./attachments.js";
+import { audioWeight, 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
@@ -145,6 +148,9 @@ export default class PacketWire {
         if (lines.length !== ordinals.length) {
             throw new TypeError("A sparse log-body projection requires one source ordinal per rendered line.");
         }
+        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
@@ -201,7 +207,7 @@ export default class PacketWire {
     static #canonicalJson(obj) {
         const keys = Object.keys(obj).sort();
         const sorted = {};
-        for (const key of ["target", "aside"]) {
+        for (const key of ["path", "from", "to", "aside"]) {
             if (Object.hasOwn(obj, key))
                 sorted[key] = obj[key];
         }
@@ -223,7 +229,7 @@ export default class PacketWire {
             return {
                 ...head,
                 change: `-${receipt.effect.removed} +${receipt.effect.inserted}`,
-                range: `${receipt.effect.requested} ${receipt.effect.source}->${receipt.effect.result}`,
+                effect: `${receipt.effect.source} -> ${receipt.effect.result}`,
                 // {§edit-receipt-removed-text} — what a deletion took, so it can be put back from the receipt.
                 ...(receipt.effect.removedText === undefined ? {} : { removed: receipt.effect.removedText }),
             };
@@ -236,7 +242,7 @@ export default class PacketWire {
                 ? {}
                 : {
                     change: `-${receipt.replacement.removed} +${receipt.replacement.inserted}`,
-                    replacement: `${receipt.replacement.requested} ${receipt.replacement.source}->${receipt.replacement.result}`,
+                    replacement: `${receipt.replacement.source} -> ${receipt.replacement.result}`,
                 }),
         };
     }
@@ -252,21 +258,7 @@ export default class PacketWire {
         }
         return endsWithLineBreak ? body.replace(/(?:\r\n|\r|\n)$/, "") : body;
     }
-    // Render one Log entry → a single bullet line carrying the meta JSON.
-    // No body, no fence — every meaningful field is in the JSON. Naming
-    // follows the uniform principle: `path` is identity (this log row's
-    // own URI), `target` is the URI in the statement's target slot. COPY/MOVE
-    // retain their source and destination selections separately from ordered
-    // applied `effects`.
-    //
-    // On error, status >= 400 signals the failure; Problem Details live on
-    // this durable row and the next packet's Errors section points here.
-    //
-    // Per-entry render: one meta JSON line plus the row's canonical body.
-    // LogBody owns tx/rx storage interpretation; packet projection owns only
-    // visibility, previewing, mimetype rendering, and metadata.
-    // The log:/// handle the model sees for an entry.
-    // ({§log-kill-scope}).
+    // {§log-address-metadata} — row identity belongs to the H3, not its operand metadata.
     static #entryPath(coordinate, leaf) {
         if (coordinate === null)
             throw new TypeError("A packet log row requires an addressable coordinate.");
@@ -287,30 +279,26 @@ export default class PacketWire {
             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) {
+            const selected = ScopeFormat.lines(1, finalCompleteLine + 1);
+            if (finalCompleteLine + 1 === lines.length) {
                 throw new Error("a bounded body chunk must differ from its complete line extent");
             }
-            return `showing ${selected} of ${complete}`;
+            return `${selected} of ${ScopeFormat.count("line", lines.length)}`;
         }
         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);
+        const selected = ScopeFormat.region(selectedRegion);
+        const complete = ScopeFormat.region(completeRegion);
         if (selected === complete) {
             throw new Error("a bounded body chunk must differ from its complete text extent");
         }
-        return `showing ${selected} of ${complete}`;
+        return `${selected} of ${complete}`;
     }
     static #sparseChunk(completeContent, visibleContent, visibleOrdinals, projectedContent) {
         const end = projectedContent.length;
@@ -329,8 +317,8 @@ export default class PacketWire {
                     previous[1] = ordinal;
                 }
             }
-            const selected = runs.map(([start, finish]) => `<${start},${finish}>`).join(",");
-            return `showing ${selected} of <1,${TextCoordinates.logicalLines(completeContent).length}>`;
+            const selected = runs.map(([start, finish]) => ScopeFormat.lines(start, finish)).join(",");
+            return `${selected} of ${ScopeFormat.count("line", TextCoordinates.logicalLines(completeContent).length)}`;
         }
         const local = coordinates.regionFromOffsets(0, end);
         const complete = new TextCoordinates(completeContent)
@@ -343,11 +331,11 @@ export default class PacketWire {
         if (startLine === undefined || endLine === undefined) {
             throw new Error("a sparse character-bound chunk must map to canonical body lines");
         }
-        return `showing ${PacketWire.#formatRegion({
+        return `${ScopeFormat.region({
             ...local,
             startLine,
             endLine,
-        })} of ${PacketWire.#formatRegion(complete)}`;
+        })} of ${ScopeFormat.region(complete)}`;
     }
     static #promptProjection(body, budget, weighContent, render = (content) => PacketWire.#renderContentBody(content, body.startLine, null)) {
         const weightAt = (end) => weighContent(render(body.content.slice(0, end)));
@@ -421,10 +409,24 @@ export default class PacketWire {
             readableContent: select(readableOrdinals),
             readableOrdinals,
             folded: clipped,
+            trimmed: LogVisibility.clipped(trimmed, totalLines),
             totalLines,
             fullyFolded: LogVisibility.fullyFolded(clipped, totalLines),
         };
     }
+    // {§message-arrival} — an inbound SEND row: harness-published, the sender's statement as its
+    // sent side. {§message-causal-source}: a `source` names the actor; absence is the owner.
+    static isArrival(e) {
+        if (e.op !== "SEND" || e.origin !== "_plurnk")
+            return false;
+        const attrs = typeof e.attrs === "string" ? JSON.parse(e.attrs) : e.attrs;
+        return attrs !== null && typeof attrs === "object" && attrs.kind === "message";
+    }
+    // {§message-projection} — a peer worker's message takes the ordinary bounds; every other
+    // arrival, the loop's own assignment included, shares the allowance.
+    static isExteriorArrival(e) {
+        return PacketWire.isArrival(e) && !(typeof e.source === "string" && e.source.startsWith("worker://"));
+    }
     static #promptProjectionWeights(entries, bodies, visibility, weighContent, budget) {
         if (budget === undefined)
             return new Map();
@@ -432,7 +434,9 @@ export default class PacketWire {
             throw new RangeError(`promptProjectionWeight must be a non-negative safe integer, got ${JSON.stringify(budget)}`);
         }
         const costs = entries.flatMap((entry, index) => {
-            if (entry.op !== "prompt" || bodies[index].content.length === 0)
+            // {§message-projection} — an arrival from outside the workspace shares the allowance;
+            // a peer worker's message takes the ordinary bounds.
+            if (!PacketWire.isExteriorArrival(entry) || bodies[index].content.length === 0)
                 return [];
             const body = bodies[index];
             const visible = visibility[index];
@@ -481,316 +485,351 @@ 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;
-            }
-            // 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 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;
-            }
-            // {§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;
-            }
-            // 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, bodies[index]);
+            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). An arrival is an inbound
+        // SEND row the harness published ({§message-causal-source}): its origin says nothing, so
+        // the row carries only the causal `source` when another actor supplied one (#706).
+        if (typeof e.origin === "string" && e.origin !== "model" && !PacketWire.isArrival(e))
+            meta.origin = e.origin;
+        // {§env-delta-attribution}: render the causal worker address or
+        // subsystem token when present; absence means the owning worker.
+        // {§message-short-identity} an arrival whose source is the transport's own name for it adds
+        // nothing to its address; a peer's or an agent's source still shows.
+        const arrivalAttrs = typeof e.attrs === "string" ? PacketWire.#safeParse(e.attrs) : e.attrs;
+        const selfAddressed = arrivalAttrs !== null && typeof arrivalAttrs === "object" && arrivalAttrs.selfAddressed === true;
+        if (typeof e.source === "string" && e.source.length > 0 && !selfAddressed)
+            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.");
             }
-            // {§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,
-                });
+            meta.git = git;
+        }
+        // SEND, lifecycle verbs, 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);
+        // {§log-address-metadata}: operands are independent of record identity and attribution.
+        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.from = source;
+            if (destination !== null)
+                meta.to = 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.`);
             }
-            // 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;
+        }
+        else if (target !== null) {
+            meta.path = 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 };
+    }
+    // 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, fullBody) {
+        const { meta, op, tx } = identity;
+        if (op === "SEND" && rx !== null && typeof rx === "object" && Array.isArray(rx.attachments) && rx.attachments.length > 0) {
+            meta.attachments = rx.attachments.map(({ name, mediaType, target }) => ({ name, mediaType, path: target }));
+        }
+        // {§operation-resource-receipt}: preserve the returned address, not a second authored target.
+        if (rx !== null && typeof rx === "object" && typeof rx.resource === "string"
+            && rx.resource.length > 0 && rx.resource !== meta.path && rx.resource !== meta.stream) {
+            meta.resource = rx.resource;
+        }
+        // {§exec-stream}: explicit and automatic READs preserve the same
+        // durable liveness facts, including an empty active channel.
+        if (op === "READ" && rx !== null && typeof rx === "object" && Object.hasOwn(rx, "terminal")) {
+            if (typeof rx.terminal !== "boolean") {
+                throw new TypeError("A stream READ result carries a malformed terminal flag.");
             }
-            // {§retrieval-packet-metadata}: one extent/coordinate owner plus
-            // only FIND aggregates that add information beyond that extent.
-            let findItems = null;
-            // {§matcher-option} — a pattern rides the heading; the row shows it as `matcher`.
-            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;
+            meta.terminal = rx.terminal;
+            if (Object.hasOwn(rx, "exitCode")) {
+                if (typeof rx.exitCode !== "number" || !Number.isSafeInteger(rx.exitCode)) {
+                    throw new TypeError("A stream READ result carries a malformed exitCode.");
+                }
+                meta.exitCode = rx.exitCode;
             }
-            // {§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;
+        }
+        // {§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, target: identity.target },
+            });
+        }
+        // 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;
+        let range = 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.answers)) {
+            meta.answers = rx.answers;
+        }
+        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;
             }
-            // {§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;
+            range = rx !== null && typeof rx === "object" && rx.range !== undefined
+                ? Validator.assertRangeExtent(rx.range)
+                : null;
+            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" || 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;
-                }
-                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 (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;
-                }
+            if (range !== null && !problemOwnsRange) {
+                const sparse = fullBody.lineOrdinals !== undefined
+                    && range.returned !== undefined
+                    && fullBody.lineOrdinals.length !== range.returned[1] - range.returned[0] + 1;
+                meta.range = typeof e.status === "number" && e.status >= 400
+                    ? range
+                    : ScopeFormat.range(range, sparse);
+            }
+            else if (range === null && !problemOwnsRange && op === "READ" && rx !== null && typeof rx === "object" && rx.region !== undefined) {
+                meta.range = ScopeFormat.region(Validator.assertTextRegion(rx.region));
             }
-            // {§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;
+            // 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, 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.
-            const fullBody = bodies[index];
-            const bodyVisibility = visibility[index];
-            const projectedBody = {
-                ...fullBody,
-                content: bodyVisibility.fullyFolded ? bodyVisibility.readableContent : bodyVisibility.content,
-            };
-            const emptyFind = op === "FIND" && e.status === 200 && findItems === 0;
-            const previewExempt = op === "READ"
-                || op === "FIND"
-                || op === "TASK"
-                || (op === null && renderedLeaf === "ops")
-                || 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);
+                && typeof rx.returnedItemsWeightTotal === "number"
+                && rx.returnedItemsWeightTotal > 0
+                && rx.returnedItemsWeightTotal !== rx.itemsWeightTotal) {
+                meta.returnedItemsTokenTotal = rx.returnedItemsWeightTotal;
             }
-            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 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, 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;
-            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; logTokensTotal exceeds logTokensMax`;
+            if (op === "FIND"
+                && patterned
+                && range?.unit === "resource"
+                && rx !== null
+                && typeof rx === "object"
+                && typeof rx.matchLocationCount === "number"
+                && rx.matchLocationCount > 0) {
+                meta.matchLocationCount = rx.matchLocationCount;
             }
-            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. {§packet-token-accounting}
-            // {§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,
-                    };
-                }
-                meta.logTokens = logTokens;
+        }
+        // {§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) => ({
+                path: effect.target,
+                action: effect.action,
+                ...(effect.receipt === undefined
+                    ? {}
+                    : PacketWire.#receiptMeta(effect.receipt)),
+            }));
+            structuredMutationReceipt = effects.some((effect) => effect.receipt !== undefined);
+        }
+        return { findItems, range, 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, NOTE, lifecycle bodies and admitted programs remain
+    // complete, and exterior arrivals 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 === "NOTE" || typeof op === "string" && TurnDisposition.isOp(op)
+            || (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" ? facts.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.trimmed.length > 0 && !bodyVisibility.fullyFolded) {
+            meta.trimmed = LogVisibility.format(bodyVisibility.trimmed);
+        }
+        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.preview = projectedChunk;
+            delete meta.lines;
+        }
+        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;
@@ -818,6 +857,15 @@ export default class PacketWire {
                 weight: pdfWeight(pages, document.bytes),
             };
         }
+        const audio = view?.audio;
+        if (audio !== undefined && typeof audio.mimetype === "string" && Number.isSafeInteger(audio.bytes)) {
+            const duration = typeof audio.duration === "number" && Number.isFinite(audio.duration) && audio.duration >= 0 ? audio.duration : null;
+            return {
+                contentHash, coordinate, path, scheme, pathname, mimetype: audio.mimetype, kind: "audio",
+                ...(duration === null ? {} : { duration }),
+                weight: audioWeight(duration, audio.bytes),
+            };
+        }
         return null;
     }
     // {§packet-attachment-parts} — the wire form with native parts: user text first, then each accepted
@@ -871,10 +919,10 @@ export default class PacketWire {
     }
     // {§packet-git-status}: the count line, then one bounded line per non-empty class. Untracked paths are
     // named because they are NOT members ({§membership-baseline}) — a human `git add`s or picks them.
-    static #GIT_PATHS_PER_CLASS = 8;
     static #renderGitState(git) {
         const sync = git.ahead > 0 || git.behind > 0 ? ` (↑${git.ahead} ↓${git.behind})` : "";
-        const head = `branch \`${git.branch}\`${sync} — ${git.staged} staged, ${git.unstaged} unstaged, ${git.untracked} untracked`;
+        const position = git.branch === null ? "detached HEAD" : `branch \`${git.branch}\`${git.unborn ? " (no commits)" : ""}`;
+        const head = `${position}${sync} — ${git.staged} staged, ${git.unstaged} unstaged, ${git.untracked} untracked`;
         const files = git.files ?? [];
         const path = (p) => `\`${p}\``;
         const untracked = files.filter((f) => f.status === "??");
@@ -888,8 +936,9 @@ export default class PacketWire {
         const lines = classes
             .filter(([, items]) => items.length > 0)
             .map(([label, items]) => {
-            const shown = items.slice(0, PacketWire.#GIT_PATHS_PER_CLASS).join(" · ");
-            const more = items.length > PacketWire.#GIT_PATHS_PER_CLASS ? ` (+${items.length - PacketWire.#GIT_PATHS_PER_CLASS} more)` : "";
+            const paths = GitState.renderedPaths();
+            const shown = items.slice(0, paths).join(" · ");
+            const more = items.length > paths ? ` (+${items.length - paths} more)` : "";
             return `${label}: ${shown}${more}`;
         });
         return [head, ...lines].join("\n");