@plurnk/plurnk-service 1.20.0 → 1.21.1

package/.env.defaults

@@ -144,11 +144,13 @@ PLURNK_SERVICE_PREVIEW_LINES=100
 PLURNK_SERVICE_PREVIEW_CHARS=16000
 # Turn0 reasoning READ: -1 = complete; 0 = omit; N = first N lines. Later reads are model-chosen.
 # Alias override: PLURNK_REASONING_VIEW_LINES_<alias>. Source retention/streaming are unchanged.
-PLURNK_REASONING_VIEW_LINES=-1
+PLURNK_REASONING_VIEW_LINES=100
+# After a turn with no operation, its reasoning is read back: same scale, same alias override.
+PLURNK_REASONING_EMPTY_TURN_LINES=100
 # Cold-start input allowance reserved for automatic prompt bodies, percentage in (0,100).
 # Alias override: PLURNK_SERVICE_PROMPT_PROJECTION_<alias>. Full prompts remain addressable.
 PLURNK_SERVICE_PROMPT_PROJECTION=25%
-# Neighboring lines hashed on each side of an editable line anchor; 0 = addressed line only.
+# Minimum neighbors hashed on each side of an editable line anchor; repeated handles widen context.
 PLURNK_SERVICE_LINE_ANCHOR_CONTEXT_LINES=2
 # Surrounding and changed lines shown at each EDIT boundary; overlapping windows coalesce.
 PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES=4

package/INSTALL.md

@@ -62,8 +62,9 @@ the owning declaration specifies its meaning.
 | File creation and membership | Separate policies. Creating an out-of-root file, admitting a new file, and editing an existing member are distinct decisions. |
 | User-facing behavior | Operating policy; use configuration for runtime controls. |
 
-The [model chapter](skill://plurnk/references/models.md) covers alias tuning,
-reasoning and output budgets, local endpoints, caching, and connectivity.
+The `@plurnk/plurnk-providers` README covers alias tuning, reasoning and output
+budgets, local endpoints, caching, and connectivity; the
+[model chapter](skill://plurnk/references/models.md) is what a model is told.
 The defaults catalog groups the remaining settings by their owning subsystem:
 permissions, loop limits, residency, execution, context, indexing, MCP, A2A,
 hooks, HTTP, and content handling. Search the catalog for that subsystem instead

package/SPEC.md

@@ -496,7 +496,7 @@ Every admitted authority is a literal `workers.name`; self-addressing uses the c
 | `READ`    | existing literal name       | Collect the named worker's deliverable. |
 | `KILL`    | existing literal name  | Terminate the named worker or caller.   |
 
-- §worker-scheme-spawn **Spawn** — ```` ```WORK (worker://<name>)? ```` with a task body creates a new worker sister (empty log) and starts it with that task on its first loop. WORK/FORK are the worker-creation verbs: EDIT is file/entry only, so EDIT on the bare worker entity is a **400** steering to WORK/FORK — the entity is not an entry. Names remain unique within a workspace for the lifetime of retained Worker rows, including after termination. An existing name returns 409; concurrent claims cannot redirect a published address or expose a raw uniqueness failure.
+- §worker-scheme-spawn **Spawn** — ```` ```WORK (worker://<name>)? ```` with a task body creates a new child worker (empty log) and starts it with that task on its first loop. WORK/FORK are the worker-creation verbs: EDIT is file/entry only, so EDIT on the bare worker entity is a **400** steering to WORK/FORK — the entity is not an entry. Names remain unique within a workspace for the lifetime of retained Worker rows, including after termination. An existing name returns 409; concurrent claims cannot redirect a published address or expose a raw uniqueness failure.
 - §worker-spawn-prompt-resource **The spawn slot is overloaded by scheme.** A `worker://` path is
   the child's address and keeps the address rules ({§worker-control-addressing}). A path of any
   other scheme is the child's prompt resource: it is read whole (`<1,-1>`) under the caller's read capabilities, composed with
@@ -506,9 +506,9 @@ Every admitted authority is a literal `workers.name`; self-addressing uses the c
   resource with no body is `422 spawn-prompt-empty`. Naming the child and giving a resource in one
   statement is not expressible; the body can READ the resource instead. Taught in the deep
   reference only.
-- §worker-scheme-irc **irc** — ```` ```SEND (worker://<name>) ```` with a message body delivers it to an existing sister, the **voice door** ({§actor-boundary-two-doors}): an active sister folds it into its next turn, an idle one wakes ({§actor-boundary-passive-wake}). A fresh receiving loop retains that worker's durable model, spawn override, and reasoning policy; the sender and daemon default do not re-select it. The caller addresses itself by its literal name; a literal name with no worker in the workspace is 404.
+- §worker-scheme-irc **irc** — ```` ```SEND (worker://<name>) ```` with a message body or attachments delivers it to an existing worker, the **voice door** ({§actor-boundary-two-doors}): an active worker folds it into its next turn, an idle one wakes ({§actor-boundary-passive-wake}). No text beyond whitespace and no attachments is 422 `message-empty`, before message admission or recipient loop creation. Nonempty text is delivered verbatim; attachment-only delivery uses {§send-resource-attachments}. A fresh receiving loop retains that worker's durable model, spawn override, and reasoning policy; the sender and daemon default do not re-select it. The caller addresses itself by its literal name; a literal name with no worker in the workspace is 404.
 - §worker-scheme-fork **Fork** — ```` ```FORK (worker://<name>)? ```` with a task body branches the
-  current worker into a **named** sister: its log is deep-copied
+  current worker into a **named** child: its log is deep-copied
   ({§machine-processes-fork-copies-the-log}), which continues with `task`; the
   world is shared, never copied ({§machine-processes-fork-shares-the-world}).
   WORK and FORK are distinct verbs — WORK spawns a fresh worker, FORK branches
@@ -633,7 +633,7 @@ and never re-fetch a match.
   project file is exactly one of three things: **invisible**, **added**, or **tracked
   by git**. There is no fourth category. Membership — what the model can READ and
   FIND, what is materialized into the store, what a packet can ship to a provider — is
-  the allowlist `(tracked ∪ include) − exclude` and nothing else. No file is a member because
+  the allowlist `(tracked ∪ include ∪ created) − exclude` and nothing else. No file is a member because
   it exists on disk, because git does not ignore it, or because a model would find it
   convenient: ambient admission of untracked files is prohibited, so a workspace rooted
   in a home directory or a monorepo exposes exactly what was committed or added (the
@@ -1083,6 +1083,7 @@ These are the complete strike sources:
 |---------------------|------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------|
 | Hard result         | An admitted non-execution operation or bounded parse-error status is `>= 400`, except the soft set `404`, `409`, `416`, `425`, `501`. | The originating failure row.                                  |
 | Cycle               | The executed operations and their observed results repeat under {§engine-cycle-evidence}.                         | None; cycle detection itself is private engine accounting.    |
+| Empty turn          | An admitted turn with no authored response operation ({§empty-turn}).                                            | The turn's `422` error row, and its reasoning read back ({§reasoning-empty-turn-read}). |
 
 Execution results remain exact model-visible evidence but are always soft: an
 executor error is not a PLURNK contract violation. Cycle detection remains an
@@ -1521,7 +1522,7 @@ Registration precedes loop affinity:
 | Boundary | Contract |
 |---|---|
 | Prompt | A resource path, an inline body, or both ({§bare-statement}). The sole user message contains the complete addressed READ representation followed by the body, separated by two newlines when both are nonempty. Resource resolution occurs at the operation's execution point through {§universal-read-composition}, including source preparation, identity, channel selection, and retained log lines. No preview limit, presentation prefixes, or extra READ receipt. |
-| Admission | Ordinary {§capability-admission} checks BARE execution and, for a path, source observation before acquisition or inference. An unsuccessful source result becomes the BARE receipt unchanged; the inline tail is not a fallback. Empty combined text yields 422 `bare-prompt-empty`. Neither refusal creates a model call. |
+| Admission | Ordinary {§capability-admission} checks BARE execution and, for a path, source observation before acquisition or inference. An unsuccessful source result becomes the BARE receipt unchanged; the inline tail is not a fallback. Empty combined text yields 422 `bare-prompt-empty`, whose detail names where a prompt goes: the fence body, a resource path, or both, never the aside. Neither refusal creates a model call. |
 | Isolation | No inherited PLURNK packet, context, tools, GBNF, parser, or persistent child worker. Non-prompt call identity and accounting remain ordinary provider metadata. |
 | Provider | Exactly the loop's WORK/FORK child provider; durable inherit policy falls back to the parent. |
 | Execution | A contiguous group's prompt acquisition precedes model-call creation; interrupted acquisition leaves no unstarted inference records. Admitted calls acquire identities in authored order and launch concurrently under the loop cancellation signal. Core awaits the group and records results and notifications in authored order, regardless of completion order. An intervening operation is an execution boundary. |
@@ -1530,7 +1531,7 @@ Registration precedes loop affinity:
 
 - §op-synchronous **Decisive operations settle before the next operation.** The dispatcher awaits each operation and its proposal resolution. Work remains in flight only when the operation's contract deliberately creates concurrency: FORK, WORK, a stream-producing execution, and streaming READ after acquisition. Such a READ first establishes its durable subscription and returns `102`; a later operation may address that live owner. Dispatching an execution before KILL does not wait for the process to finish using a resource. KILL of a worker synchronously ends its live loops before disposition checks the pending set; physical scope cleanup remains asynchronous.
 - §edit-execution **One authored EDIT is one mutation.** Each EDIT resolves against current resource state when dispatch reaches it, owns its proposal when gated, and records its own resulting revision. No later EDIT is prepared or applied in advance. Numeric scopes address current coordinates; an earlier EDIT may change what those numbers select. Rejection applies only to that operation, not its successful siblings.
-- §edit-anchor-continuity **Own EDITs preserve untouched hash targets within one program.** Core carries an anchor through exact, successfully applied EDIT splices when its line survives unchanged, even if its ordinal or neighborhood changes. Scoped entry KILL uses the same deletion path. Target-line replacement or deletion invalidates that binding. Continuity is private to the admitted program and canonical resource/channel; it is not a new published anchor format. The complete normalized line content must match the expected result of the preceding recorded EDIT, otherwise retained bindings are discarded and ordinary current-state validation applies. Reviewer replacement and results without an applied EDIT receipt do not carry bindings forward. Normalization is the same line-content representation used by READ and line hashing; file-write revision checks remain independent. No approximate text matching is used. Lowered coordinates retain a current-anchor precondition at the mutation owner; ambiguous matches and concurrent changes remain collisions.
+- §edit-anchor-continuity **Own EDITs preserve untouched hash targets within one program.** Core carries an anchor through exact, successfully applied EDIT splices when its line survives unchanged, even if its ordinal or neighborhood changes. Scoped entry KILL uses the same deletion path. Target-line replacement or deletion invalidates that binding. Continuity is private to the admitted program and canonical resource/channel; it is not a new published anchor format. The complete normalized line content must match the expected result of the preceding recorded EDIT, otherwise retained bindings are discarded and ordinary current-state validation applies. Reviewer replacement and results without an applied EDIT receipt do not carry bindings forward. A retained binding resolves alone: a twin neighbourhood this program's own splice created elsewhere does not make the carried anchor ambiguous, and an anchor the program never bound resolves against current state. Normalization is the same line-content representation used by READ and line hashing; file-write revision checks remain independent. No approximate text matching is used. Lowered coordinates retain a current-anchor precondition at the mutation owner; ambiguous matches and concurrent changes remain collisions.
 - §anchor-offset **An anchor offset is tolerated, never taught (#749).** A line mark may carry an offset from its anchor (`@abcde+1`, `@abcde-2`), and a bare `+N` after an anchor counts from that anchor (`<@abcde,+1>`). The anchor resolves as usual and the offset is added; a result before line 1 is an invalid mark, and past the end is the ordinary range refusal. Continuity and current-anchor preconditions check the anchor's own line. No teaching text, scope table or receipt mentions offsets; `plurnk.md` keeps its two anchor forms. A bare `+N` with no anchor before it is refused as before.
 - §edit-batch **One compound operation may require atomic splices.** The scheme's `editBatch` primitive validates all supplied numeric edits against one snapshot and commits one revision or none. Core supplies one statement for an authored EDIT; same-resource MOVE can supply multiple splices as one operation. This primitive does not group separate authored operations. Its replacement, insertion, conflict, and receipt rules remain owned by the shared Slicer.
 - §edit-batch-receipt **A refusal describes its own unapplied work.** An anchor collision lists every distinct unresolved anchor in that EDIT, including both range endpoints, in `unresolvedAnchors` (`anchor`, `kind: missing | ambiguous`, and matching `lines` when ambiguous). Missing is not proof of earlier validity or subsequent change. It carries `editCount: 1`, `applied: 0`, and recovery directing a READ for current coordinates; it makes no claim about other operations. A refused compound splice batch lists all conflicting pairs in `conflicts`, non-conflicting regions in `cleanRegions`, its first pair in `conflictingRegions`, and its own `editCount` and `applied: 0`.
@@ -1855,18 +1856,42 @@ coordinates and derives its internal anchors from canonical content and identity
 not from whether a model-facing READ publishes them. Explicit log anchors remain
 available for curation without granting source EDIT.
 
-For canonical model-facing
-resource identity `R`, configured non-negative neighbor count `C`, ordered
-content array `W` containing that line and up to `C` complete lines on either
-side (all excluding separators), and the line's offset `O` within `W`
-(`min(L-1, C)` for one-based ordinal `L`), core hashes the JSON tuple
-`["plurnk-line-anchor-v2",R,C,O,W]` with SHA-256, interprets the digest as a
-big-endian integer modulo `62^5`, and encodes five fixed-width characters with
-alphabet `0-9A-Za-z`. The ordinal itself is not hashed (#428): a line keeps its
-anchor wherever it moves while its content and neighborhood are unchanged, so
-edits above a line — the model's own earlier edits included — never stale the
-anchors below them; identical neighborhoods share one anchor and resolve as
-ambiguous with the matching lines, never as a silent landing on a twin. The universal READ projector derives
+For canonical resource identity `R`, minimum neighbor count `C` from
+`PLURNK_SERVICE_LINE_ANCHOR_CONTEXT_LINES`, one-based line `L`, and ordered
+window `W` containing the line and up to `C` neighbors on either side (without
+separators), the initial fingerprint is SHA-256 of the JSON tuple
+`["plurnk-line-anchor-v2",R,C,min(L-1,C),W]`. Its big-endian integer modulo
+`62^5`, encoded with alphabet `0-9A-Za-z`, supplies the five-character handle.
+Absolute ordinals and occurrence numbers are not identity.
+
+§line-anchor-disambiguation Repeated handles expand their content context on
+the complete canonical resource, before any READ scope or preview:
+
+| Condition | Derivation / outcome |
+| --- | --- |
+| Handle is unique | Keep it; expansion elsewhere does not re-key it. |
+| Handle repeats | Double the context radius (`0` first becomes `1`), re-fingerprint the repeated lines, and recheck all resulting handles. |
+| Expanded context | Hash the ordered left block, addressed line, and right block with `R`, `C`, and the expanded radius. Compose doubled side blocks from their two previous SHA-256 fingerprints; missing blocks are `null`. No absolute position, mutable registry, or fuzzy relocation. |
+| Shift outside distinguishing context | Handle remains valid when that context and its uniqueness remain unchanged. |
+| Context or required disambiguation changes | The old handle may become stale; do not redirect it by ordinal or occurrence. |
+| Full-resource radius reached | Stop expansion. A residual short-hash collision remains ambiguous and is refused, never resolved by picking a match. |
+
+Side-block leaves cover up to `max(C,1)` neighboring lines and hash their
+ordered line arrays; expanded handles hash
+`["plurnk-line-anchor-context-v1",R,C,radius,left,line,right]`, where `line`
+hashes the addressed line's text. Side-block parents hash the ordered pair of
+child fingerprints. Context expansion takes logarithmically many rounds and
+linear auxiliary storage, not increasingly large substring copies per line.
+Larger distinguishing contexts deliberately carry larger stale-check regions.
+Anchors are content preconditions, not persistent physical-line identities: an
+exact copy of the distinguishing context cannot be told from a move after the
+original context disappears. Multiple current matches are never guessed.
+Within one program {§edit-anchor-continuity} retains proven bindings through
+its own splices, including changes to contextual disambiguation. This does not
+grant bindings to another program or bypass concurrent-write checks. Applied
+EDIT receipts publish current anchors under {§edit-receipt-anchored-context}.
+
+The universal READ projector derives
 anchors from the complete canonical selected channel before applying the
 authored text slice; its durable result retains the canonical derivation
 identity and anchors aligned with returned lines. Packet rendering right-aligns
@@ -2001,7 +2026,7 @@ READ is the one fan-out core performs ({§read-fan-out}).
   Each such row carries `attrs.fanout` (`target`, the authored glob; `matched`, the
   survey's matching path count; `index`; `count`), so a client presents the authored
   statement once and folds the paths beneath it without inferring the group.
-  Without a scope each path renders its ordinary `<1,16>` preview; with a pattern
+  Without a scope each path uses {§markerless-first-page}; with a pattern
   only the matching lines, `grep -n` style. The authored statement contributes
   `rowsWritten`, the receipt count, to its turn's sequence. No path is one 204
   receipt on the authored glob (`matched: 0` when a pattern selected nothing); a
@@ -2084,7 +2109,7 @@ same transitions the dispatcher's atomic curation event makes, without the row.
 |---|---|
 | Evidence | Original provider reasoning remains verbatim in immutable model-call responses and admitted packets. Resource and log operations never rewrite it. Only an admitted response, or the final exhausted emission attempt, produces a model reasoning source; missing provider reasoning creates no substitute. A non-model producer may record its own authored rationale under {§turn-source-resources}. |
 | Resource | `reasoning://<worker>/<loop>/<turn>` is immutable text/plain source belonging to the named workspace worker's turn under {§turn-source-resources}. Every workspace actor may READ, FIND, search and COPY from it; none may EDIT, KILL, COPY into or MOVE it. |
-| Delivery | Initialization READs its own authored rationale under {§reasoning-initial-read}. Further observations require deliberate READs. The selected model reasoning source is stored before its OPs execute, so an ordinary READ of the current turn resolves immediately and is visible in subsequent packets. Every READ retains its authored scope and ordinary range metadata, without edit anchors. |
+| Delivery | Initialization READs its own authored rationale under {§reasoning-initial-read}, and an empty turn's reasoning is read back under {§reasoning-empty-turn-read}. Further observations require deliberate READs. The selected model reasoning source is stored before its OPs execute, so an ordinary READ of the current turn resolves immediately and is visible in subsequent packets. Every READ retains its authored scope and ordinary range metadata, without edit anchors. |
 | Curation | Scoped log KILL suppresses receipt lines; whole log KILL retires the receipt. Neither affects the source. Explicit log READs retain ordinary curation anchors. A mutable working copy requires ordinary COPY into an editable resource. |
 | Lifecycle | Restart retains sources and observations. FORK snapshots sources under the child's name at the same loop/turn coordinates and receipts with independent curation. No curation or lifecycle event automatically READs model reasoning. A turn the provider left without reasoning reads empty; absent workers and turns return the ordinary missing result ({§turn-source-resources}). |
 | Client | Standard live reasoning events and replay retain original provider reasoning; working resources and READ receipts never substitute for or replay that stream. |
@@ -2098,10 +2123,21 @@ The program begins with its own NOTE and READs its reasoning and persisted ops,
 demonstrating both NOTE placements and their ordinary results. The initial message arrives separately as an
 inbound SEND ({§message-arrival}). Neither initialization nor later turns
 manufacture a task inventory.
-`PLURNK_REASONING_VIEW_LINES` (default `-1`, alias-scoped) selects this one READ's
+`PLURNK_REASONING_VIEW_LINES` (alias-scoped, default in `.env.defaults`) selects this one READ's
 scope: `0` omits it, `-1` reads the complete rationale, and a positive integer
 bounds it to the first N lines. Source retention, deliberate READs, and client
-streaming are independent. No later turn automatically requests reasoning.
+streaming are independent. The only other automatic reasoning READ follows an empty
+turn ({§reasoning-empty-turn-read}).
+
+§reasoning-empty-turn-read **An empty turn's reasoning is read back to the model.** After a
+turn admitted under {§empty-turn}, one runtime turn of the same loop
+(`{ producer="_plurnk", kind="operation" }`) dispatches
+`READ (reasoning://<worker>/<loop>/<turn>) <!-- turn N emitted no OP -->` over that turn's stored
+reasoning source; its receipt renders in the next packet like any other log row.
+`PLURNK_REASONING_EMPTY_TURN_LINES` (alias-scoped, default in `.env.defaults`) selects the scope on the same
+scale as `PLURNK_REASONING_VIEW_LINES`. No read follows a turn without reasoning, and none follows
+a turn whose emission or reasoning carries a foreign tool-call grammar ({§response-text-note});
+the strike and its error row are unchanged.
 
 ### §log-kill-scope KILL on the log: whole items and scoped bodies
 
@@ -2138,27 +2174,25 @@ type and projection facts under {§read-bytes}.
 The `## Log` section is a sequence of ordinary Markdown records separated by one blank line:
 
 ```text
-### log:///<loop>/<turn>/<item>/<leaf> · <logTokens>
-OP (operands) <marks> [metadata] <!-- aside -->
-{"oneLine":"strict JSON result facts"}
+### log:///<loop>/<turn>/<item>/<leaf> → path pattern · <logTokens>
+{"oneLine":"strict JSON facts"}
 <coordinate-prefixed body lines when visible>
 ```
 
 | Line | Content | Rule |
 |---|---|---|
-| H3 | The row's complete model-facing identity and canonical READ address, then ` · ` and its `logTokens` charge ({§packet-token-accounting}). | Always present; nothing else repeats the identity, the operation, or the charge. |
-| written | The request as the language writes it ({§heading-slot-order}): the operation or runtime, every operand in the packet's canonical spelling ({§log-address-metadata}), marks, metadata blocks, matcher, aside. No fence, no body. | Present for every operation and execution row; absent on `error` and `extension` rows. |
-| facts | One strict JSON object of result facts in stable alphabetical order. | Present only when a fact exists; it never re-encodes the written line. |
+| H3 | Only the row's complete READ address, addressed resource(s), selection pattern(s), and ` · ` followed by its `logTokens` charge ({§packet-token-accounting}). | Always present. Canonical operands follow arrows ({§log-address-metadata}); each pattern follows its operand. No invocation parentheses, scope, aside or metadata block. The operation appears only in the URI leaf. |
+| facts | One strict JSON object in stable alphabetical order. | Present only when a fact exists. Asides, scopes, opaque invocation metadata and result facts belong here, not on the H3. |
 | body | Coordinate-prefixed lines. | Present when the row is visible. |
 
-The written line is the model's own request, so a matcher such as `/\bhello\b/i` returns exactly as it was written, never JSON-quoted. Absent fields are not invented. Every physical body line retains its canonical numeric `N:` or anchored `@hash N:` coordinate, so source text cannot create a record boundary. The section contains records only, with no leading prose or enclosing fence.
+Patterns retain their literal spelling; a pattern containing a line break is JSON-quoted to keep the H3 on one physical line. Receipts are descriptive records, not reconstructed operation headings. Absent fields are not invented. Every physical body line retains its canonical numeric `N:` or anchored `@hash N:` coordinate, so source text cannot create a record boundary. The section contains records only, with no leading prose or enclosing fence.
 
 §log-address-metadata **Addresses name their relationship, not the row's producer.**
 
 | Spelling | Meaning | Where |
 |---|---|---|
-| `OP (path)` | The operation's addressed operand: read resource, mutation subject, message recipient, or executor operand. Explicit and automatic READs are written identically. Pathless operations are written bare. | Written line |
-| `COPY (from) <marks> (to) <marks>` | COPY/MOVE's two operand selections, each retaining its optional scope; neither replaces actor attribution. | Written line |
+| `→ path` | The operation's addressed operand: read resource, mutation subject, message recipient, or executor operand. Explicit and automatic READs share this spelling. Pathless operations have no operand. | H3 |
+| `→ from pattern → to` | COPY/MOVE's ordered operands and any operand pattern; neither replaces actor attribution. Scopes remain paired by `scope.from` and `scope.to` in JSON. | H3 |
 | `stream` | An executor invocation's separately created output address, never a READ's alternative spelling of its operand. | Facts |
 | `resource` | A distinct returned resource under {§operation-resource-receipt}. | Facts |
 
@@ -2175,6 +2209,7 @@ Coordinate-prefixed lines are the text currently in context; a metadata-only row
 
 | Field | Coordinate owner | Representation |
 |---|---|---|
+| `scope` | The submitted operation | `<marks>` when present; COPY/MOVE use `{from,to}` with only the authored scopes. Omitted when a READ/FIND's result or Problem already supplies its range. |
 | `range` | The resource addressed by a successful READ/FIND | `<first,last> of N lines/resources/match locations/bytes`; singleton scopes use `<first>`. A complete dense selection reduces to `N units`; an empty selection from a nonempty extent is `none of N units`. |
 | `range` for exact text | The addressed text resource | `<startLine,startColumn,endLine,endColumn>`; no invented available extent. |
 | `preview` | The retained receipt body | Only when displayed incompletely: selected scope(s) `of N lines`, or exact selected region `of` complete region for an in-line cut. Replaces the body's otherwise redundant `lines` count. |
@@ -2192,7 +2227,7 @@ numbers and its receipt's body-relative curation coordinates remain distinct
 ({§log-kill-scope}). Byte ranges describe the hex selection, not native-media
 cropping ({§packet-attachment-parts}).
 
-Successful retrieval metadata omits requested coordinates; durable results and
+Retrieval results omit redundant requested coordinates; durable results and
 submitted programs retain them. Failed selections keep requested coordinates
 and available extent in their owning Problem. Projection never parses its
 display strings to recover typed facts. A hidden body has no `preview`; a
@@ -2202,6 +2237,8 @@ curation, admission, or immutable evidence.
 
 Field absence carries defaults: `origin` is omitted for the owning model, `source` for the owning worker, and `status` for a routine 200. Dispositions always carry their lifecycle status, SEND its delivery status, KILL keeps an explicit 200, and every non-200 stays explicit. A present authored aside appears as `aside`. Every row's accounting follows {§packet-token-accounting}.
 
+Authored `metadata` retains its opaque ordered block strings under {§scheme-metadata-modifier}; COPY/MOVE pair them as `{from,to}`. Packet rendering does not interpret scheme options or discard malformed input from a failed operation.
+
 - §operation-resource-receipt A result's nonempty `resource` address remains visible in receipt metadata when distinct from its `path` and `stream`. It identifies returned material without replacing the addressed operand or injecting that material into context; ordinary READ acquires it.
 - §packet-attachment-parts A successful READ of an attachable resource carries projection facts with its
   result ({§mimetype-projection-facts}): an image ({§mimetype-image}) as
@@ -2227,7 +2264,7 @@ Field absence carries defaults: `origin` is omitted for the owning model, `sourc
   records the exact READ coordinates sent without controlling retention. Missing immutable bytes are an
   internal integrity failure, never silently dropped content. No ejection message or permanent teaching is
   added. These stable curation weights are not provider-token measurements ({§tokenomics-render-weight-budget}).
-- §packet-token-accounting Every row reports one `logTokens` charge on its H3 ({§log-wire-format}): its complete materialized H3, written request, facts, visible body, and selected native attachment. The completed record is measured to a fixed point, including the accounting field itself. No `tokensBody`, `tokensMetadata`, or `tokensActive` field is serialized. Hidden text is not charged; metadata-only rows still have a reclaimable charge. Source/FIND-item `tokens` measure source content, not the observation's context footprint. A FIND's nonzero `itemsTokenTotal` weighs the complete matched set; a nonzero `returnedItemsTokenTotal` appears only when the returned page differs. All use stable curation weights, not provider tokens or dollars. Native component accounting follows {§packet-attachment-parts}; ordinary addressability and truthful errors follow {§log-wire-format}.
+- §packet-token-accounting Every row reports one `logTokens` charge on its H3 ({§log-wire-format}): its complete materialized H3, facts, visible body, and selected native attachment. The completed record is measured to a fixed point, including the accounting field itself. No `tokensBody`, `tokensMetadata`, or `tokensActive` field is serialized. Hidden text is not charged; metadata-only rows still have a reclaimable charge. Source/FIND-item `tokens` measure source content, not the observation's context footprint. A FIND's nonzero `itemsTokenTotal` weighs the complete matched set; a nonzero `returnedItemsTokenTotal` appears only when the returned page differs. All use stable curation weights, not provider tokens or dollars. Native component accounting follows {§packet-attachment-parts}; ordinary addressability and truthful errors follow {§log-wire-format}.
 
 ### §retrieval-packet-metadata READ/FIND packet metadata
 
@@ -2241,10 +2278,10 @@ The packet projects one actionable owner for each retrieval fact:
 | catalog/path FIND | `range` in resources | none | none |
 | broad matcher FIND | `range` in resources | per-resource match-location counts; a resource with exactly one match also carries that match's `locator`/`region` | nonzero complete `matchLocationCount` |
 | exact matcher FIND | `range` in match locations | each row's locator/region; a regex or glob row also carries `matched`, the matched text | none |
-| pattern READ ({§read-pattern}) | `range` over the physical lines | the selected lines with their ordinals and anchors | `matcher` and `matched`, the selected line count |
+| pattern READ ({§read-pattern}) | `range` over the physical lines | the selected lines with their ordinals and anchors | the heading's pattern and `matched`, the selected line count |
 
-Any row whose statement carried a heading pattern ({§matcher-option}) names it as
-`matcher`, and a pattern mutation ({§edit-pattern}, {§kill-pattern},
+Any row whose statement carried a heading pattern ({§matcher-option}) retains it
+in its H3, and a pattern mutation ({§edit-pattern}, {§kill-pattern},
 {§copy-move-pattern}) carries its `matched` count beside its receipt, so a
 digest can show what a pattern selected and how much it touched.
 
@@ -2529,7 +2566,7 @@ Log history preserved — `log_entries` stores path tuple as text, not FK to `en
 - §find-glob-filter-on-content The heading's `pattern` option ({§matcher-option})
   matches the selected channel's content or derivation; path globs select
   resources through `(target)` ({§path-glob}).
-- §find-fulltext-selection Every matcher operates only over the candidate set selected by `(target)`; indexed matchers do not bypass that selection. `~query` passes the native FTS5 expression to SQLite and ranks matching candidates by ascending BM25, with resource identity breaking ties. Native BM25 uses the shared index's term statistics; candidate visibility, owner, channel and target filters determine which resources can be returned. The ordinary FIND pager selects resources for broad targets or match locations for exact targets: markerless search defaults to `<1,16>`, `<N>` selects position N and `<N,M>` selects an inclusive range. Fractions are invalid result coordinates, not similarity thresholds. Results expose addressable matched text regions; neither cosine scores nor percentage similarity is invented. Native query-syntax failures return 400 with SQLite's diagnostic; database and implementation failures propagate.
+- §find-fulltext-selection Every matcher operates only over the candidate set selected by `(target)`; indexed matchers do not bypass that selection. `~query` passes the native FTS5 expression to SQLite and ranks matching candidates by ascending BM25, with resource identity breaking ties. Native BM25 uses the shared index's term statistics; candidate visibility, owner, channel and target filters determine which resources can be returned. The ordinary FIND pager selects resources for broad targets or match locations for exact targets: markerless search uses {§markerless-first-page}, `<N>` selects position N and `<N,M>` selects an inclusive range. Fractions are invalid result coordinates, not similarity thresholds. Results expose addressable matched text regions; neither cosine scores nor percentage similarity is invented. Native query-syntax failures return 400 with SQLite's diagnostic; database and implementation failures propagate.
 - §find-scoped-isolation Workspace + scheme scoped — no cross-workspace/cross-scheme leakage.
 - §find-result-projection **The authored target shape determines the result unit; result cardinality never changes it** ({§find-result-unit}). Returns `FindResult { status, content, mimetype, results, range, matchingPathCount, matchLocationCount, itemsWeightTotal, returnedItemsWeightTotal }`:
 
@@ -2692,7 +2729,13 @@ accounting and model-visible failure evidence remain separately owned by
   Delivered as a SEND, the text read as an answer and confirmed that speaking outside operations
   works; reported as a count of invalid characters, it sent a model to repair its prose into
   live operations (`demo-show-dont-run-qdN9u2` executed the KILL it meant to show). A NOTE
-  neither delivers nor concludes (operator, 2026-09-22). This is the far end of the teaching
+  neither delivers nor concludes (operator, 2026-09-22). Storing interstitial text is a
+  privilege, not a right (operator, 2026-09-23): a span is retained only on a turn that
+  executed at least one operation, and only when it is narration. An empty turn retains no
+  NOTE, and on any turn a span that carries a known foreign tool-call grammar, a leaked
+  template token, or an operation attempt outside its fence retains none either. The exact
+  emission stays at `ops://`, and the packet never echoes the grammar that broke a turn for
+  the next turn to imitate. The registers are mechanism (`KnownToxins`). This is the far end of the teaching
   scale: text outside every operation breaks the first rule of `plurnk.md` — *"YOU MUST ONLY
   use valid Plurnk OPs"* — and takes the largest reinterpretation, while a
   departure as small as a missing closer is read as meant ({§closer-fallback}).
@@ -2708,9 +2751,11 @@ accounting and model-visible failure evidence remain separately owned by
   Count parsed response operations before outside-text and reasoning NOTEs join them;
   neither enters the count. When none exist and no boundary was lost, retain the turn and its raw
   sources and count one progress-contract strike, whether or not the turn carried text
-  ({§response-text-note}). The strike sends no notice of its own; the threshold terminal is
-  where it becomes visible, and it says why ({§engine-rails}). An empty turn uses its exact
-  text as the cycle fingerprint ({§engine-cycle-evidence});
+  ({§response-text-note}). The strike sends no notice of its own: the turn records one `_plurnk`
+  error row, `422` `The turn performed no operation.`, which rides the next packet's errors like
+  any failure ({§operation-result-uniform-error-channel}), and its reasoning is read back to the
+  model under {§reasoning-empty-turn-read}; the threshold terminal still says why ({§engine-rails}).
+  An empty turn uses its exact text as the cycle fingerprint ({§engine-cycle-evidence});
   different empty programs are not a repeated cycle merely because neither contained
   operations. Lost-boundary handling remains {§unparsed-tail-boundary}; no confirmation
   token or private retry is invented here.
@@ -2789,7 +2834,7 @@ control capabilities, not exceptions granting write access to stdout/resources.
 
 ### §exec Executions
 
-AST: `{ runtime (the fence name in its registered lowercase spelling; there is no operation keyword), target (optional runtime-specific target), body: string | null (runtime-specific input), lineMarker (timeout/poll) }`.
+AST: `{ runtime (the fence name in its registered lowercase spelling; there is no operation keyword), target (optional runtime-specific target), body: string | null (runtime-specific input), lineMarker }`. Execution refuses a non-null scope under {§exec-lifetime}.
 
 §exec-target-routing Engine routes unconditionally to the `exec` scheme,
 resolves the runtime first, selects its static {§executor-invocation} or exact
@@ -2864,7 +2909,7 @@ target at its run boundary.
 §exec-source-temporary **Resource execution preserves source identity.** After
 acceptance, Core reparses the complete authored address and resolves one exact `<1,-1>` READ through
 {§universal-read-composition}; internal source consumption never borrows the
-model-facing 16-line preview. For the default channel, a source owner supplying
+model-facing preview ({§body-projection}). For the default channel, a source owner supplying
 a native file through {§scheme-source-bytes} supplies the executor target:
 its filename, extension, sibling imports, and source-relative assets remain
 intact. This neither bypasses admission nor changes the executor's working
@@ -2920,11 +2965,6 @@ catalogue.
 
 Per-tool programs such as `go`, `cargo`, `make`, and `npm` do not earn executor tags merely because they are executables; they are complete shell commands in a `sh` executable fence. Registered tags exist only for tools that own a distinct body, target, or output contract. {§exec-registry-resolves}
 
-**Timeout and poll — `<T,P>` on the `<L>` slot (grammar 0.74.20).** An execution
-repurposes the line-marker slot as `<timeout, poll>` in **minutes** — agentic
-latencies make a sub-minute horizon a trap — converted at the parse boundary to the
-catalog's internal `stream.seconds`. WAIT takes no timing; future wakes belong to the schedule family.
-
 §exec-lifetime **How long a spawn may live is the fence's metadata, one field.**
 `[{"lifetime": …}]` takes a duration (`30s`, `30m`, `2h`), or one of three words;
 absent is `loop`. An execution takes no scope: a numeric coordinate on an
@@ -3472,6 +3512,10 @@ loading; their runtime dependency graphs contain no leaf consumers. A required
 default leaf missing from a service install is a broken install. A direct
 framework consumer may intentionally omit leaves and receives that framework's
 documented unavailable-capability behavior.
+Packed executor coverage distinguishes installation from enablement: verify
+the package floor, explicit opt-in, and composed allowlist/disable behavior
+through discovery and registration outside the development dependency graph
+({§executor-default-inventory}, {§executor-policy}).
 Every non-optional grammar in the mimetype framework's registry is a required
 service runtime dependency, and an optional one ({§mimetype-optional-grammars})
 must not be. Installation coverage loads each default grammar and verifies
@@ -3618,7 +3662,7 @@ Each knob's value lives on its panel and nowhere else (`plurnk-service config de
 | `PLURNK_SERVICE_PREVIEW_LINES` | First page of every markerless retrieval, in the projection's own units, and the head bound of an automatic preview ({§markerless-first-page}, {§body-projection}). |
 | `PLURNK_SERVICE_PREVIEW_CHARS` | Independent Unicode code-point bound on the same previews, with CRLF treated as one indivisible separator ({§body-projection}). |
 | `PLURNK_SERVICE_PROMPT_PROJECTION` | Aggregate curation-weight share of the provider-derived input capacity available to the automatic projection of arrivals from outside the workspace ({§message-projection}); alias-scoped overrides are supported. |
-| `PLURNK_SERVICE_LINE_ANCHOR_CONTEXT_LINES` | Complete neighboring lines hashed on each side of a model-facing line anchor ({§line-anchors}). |
+| `PLURNK_SERVICE_LINE_ANCHOR_CONTEXT_LINES` | Minimum neighboring lines hashed on each side; repeated handles expand their context ({§line-anchor-disambiguation}). |
 | `PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES` | Surrounding and landed lines shown at each EDIT result boundary ({§edit-result-receipt-projection}). |
 | `PLURNK_SERVICE_MIN_CYCLES` | Min repetitions before cycle detection fires ({§engine-rails}). |
 | `PLURNK_SERVICE_MAX_CYCLE_PERIOD` | Max period length cycle detection examines ({§engine-rails}). |
@@ -3660,6 +3704,12 @@ instead of a user's boot, and a dead knob cannot ship.
 | Operator env/shell | Model alias declarations and explicit selection overrides, provider capability such as GBNF, endpoints, credentials, tuning, and deliberate ceiling overrides. |
 | `test/setup.ts` | Mock-only alias, envelope, resource, storage, and isolation fixtures; unit/integration never consume the real-model profile. |
 
+The profile clears `PLURNK_SERVICE_POLICY`, disabling the implicit XDG
+`AGENTS.md` policy under {§policy-sections}. Mock tests do the same in their
+bootstrap. Live/demo and benchmarks may select a harness-owned policy explicitly;
+none implicitly inherit the daily-driving policy. This does not disable project
+`AGENTS.md` guidance or modify the operator's file.
+
 The profile does not repeat `NODE_OPTIONS`: runner selection belongs to the invoking command, and a process-global Node option would leak into the daemon and its children. Hard ceilings such as max turns, max commands, and Git denial remain operator-owned; harnesses bound paid experiments through their per-call contract and never widen a configured ceiling here.
 
 §operator-config-zero-pin-gate **Zero-pin is a counterfactual real-model gate,
@@ -3679,6 +3729,17 @@ The floor reports every removed key. A gate that succeeds only with those pins
 is red because provider capacity did not derive for
 a fresh-user configuration.
 
+§turn-cap-counts-the-tree **The turn ceiling is the worker tree's budget of model
+calls.** The owner is the current loop of the topmost ancestor-or-self worker that has
+one: for a tree a client started, the root worker's loop current when this loop began (its
+`max_turns`: the client's `maxTurns` clamped by the operator ceiling below); a loop with no
+such ancestor owns its own budget. Every model call on the owner's loop and on any later
+loop of the owner's descendants spends it, emission turns and BARE calls alike, open or
+settled, one per call however many physical requests it took. `LoopDriver` reads the tree's count before each turn and rules the `max-turns` 429
+terminal ({§loop-terminals}) when the ceiling is met; a BARE beyond the budget is refused
+429 `max-turns` before any provider call, so one turn cannot spend past it with a batch. A
+child loop inherits the value and binds the same count.
+
 §operator-config-max-turns-ceiling Enforcement is per-use-site — no central most-restrictive pass; each ceiling is checked where it bites. `PLURNK_SERVICE_MAX_TURNS` ships **off** (`-1` = no cap; the loop ends via SEND, budget, strikes, or cycle detection) and, when an operator sets a positive value, the per-call request is `min()`-capped against it.
 
 §operator-config-workspace-settings **Client open-context (per workspace).**
@@ -4043,7 +4104,8 @@ publications before inspection or shutdown.
 
 §functionality-documents **Generated documents describe the shared snapshot.**
 Documents are projected through the existing worker generated subtree
-({§worker-generated-subtree}); the projection does not confer ownership.
+({§worker-generated-subtree}); the projection does not confer ownership, and it
+follows the family's admission ({§schemes-directory}): a denied family projects none.
 Enabled, active definitions are discoverable. Disabled or unavailable
 definitions add no hot-path teaching. Their exact state and Problem remain
 available through `list`.
@@ -4501,7 +4563,7 @@ time of measurement.
 - **Derivation is exhaustive and demand-led.** Explicit searchable-resource changes may start one coalesced warm. Passive creation and attachment do not. The first model turn starts or joins that warm; later turns derive intervening changes before dispatch. No model operation observes partial graph or full-text coverage. Progress notices make the wait visible. {§derivation-exhaustive}
 - §membership-binary-sniff **Binary truth beats a text label.** Filesystem source acquisition, including tracked members and installed skill resources, inspects up to the first 8192 bytes when extension detection does not identify a binary type. NUL marks `application/octet-stream`; existing binary types retain their declared type. Member projections follow {§membership-source-projection}; installed skill projections follow {§skills-resources}.
 - §tokenomics-agnostic-ruler **One model-agnostic curation ruler.** The daemon runs workers on different models in one workspace concurrently, while catalog and log accounting are workspace-wide. `contentWeight = ceil(chars/2)` therefore gives one content one stable number without per-model workspace state or recount passes. It controls curation only; every provider call independently measures the complete request as well as it can.
-- §tokenomics-neutral-telemetry **Curation telemetry is state, not response allowance.** The model-facing `Context Curation` section is one JSON object carrying `logTokensTotal` and `logTokensMax` (and `tokensResponseMax` when an output floor is disclosed). It never presents their difference as free response tokens. The protocol definition directly requires KILL of irrelevant log items and ranges to keep the next packet within the maximum. Per-entry weights remain on log rows where they describe visible cost and curation savings. Generic packet composition and physical-token speculation are absent.
+- §tokenomics-neutral-telemetry **Curation telemetry is state, not response allowance.** The model-facing `Context Curation` section is one JSON object carrying `logTokensTotal` and `logTokensMax`. It never presents their difference as free response tokens. The protocol definition directly requires KILL of irrelevant log items and ranges to keep the next packet within the maximum. Per-entry weights remain on log rows where they describe visible cost and curation savings. Generic packet composition and physical-token speculation are absent.
 - §tokenomics-pressure-inventory **Pressure identifies its reclaimable concentration.** At `PLURNK_SERVICE_BUDGET_PRESSURE` of `logTokensMax`, a Markdown `> [!WARNING]` block follows the JSON with `> YOU MUST KILL superseded, stale, or irrelevant log items and ranges.` New output withholding replaces that mandate under {§context-output-warning}. The JSON may include `logTokensLargest`: at most `PLURNK_SERVICE_BUDGET_LARGEST_ITEMS` retained log items, each `{path, logTokens}`, ranked by that charge descending and then path. Native-only, suppressed, and metadata-only items remain eligible: whole-item KILL can reclaim their actual contribution. Include the largest prefix that fits; drop the optional list before the warning. Both participate in the final fixed-point total and complete request admission check.
 - §tokenomics-content-hash-identity **Content identity, not per-tokenizer counts.** A settled channel's `content_hash` (SHA-256) is its body's identity in the content store ({§content-store}); a writer may bind it, a bound hash must match the content, and an active stream has none until it settles. `weight` is stored beside that content and is never keyed or recomputed by model.
 - §tokenomics-provider-usage **Provider accounting is physical-request evidence, not curation state.** Every issued physical request has one durable pre-I/O `provider_requests` identity beneath the normalized {§inference-ledger} and settles once as response or error. Each record preserves conventional {§provider-usage} quantities and required {§provider-cost} evidence; an unreported quantity remains absent, including on response-less failures, and is never replaced by zero. `model_calls` own response/failure evidence, `turn_attempts` specialize emission admission, and `provider_requests` are the sole durable accounting representation. Emissions, BARE calls, rejected responses, retries, failovers, and errors therefore remain cardinal and ordered. Turn, loop, worker, workspace, digest, and protocol accounting are derived from those records through the shared {§provider-accounting} projection; only emission calls contribute the latest-packet context gauge. The baseline stores no floating-point money, denormalized totals, or rollup triggers. A documented direct charge becomes `charged`; otherwise the provider may compute an exact-decimal USD `estimated` amount from complete usage and the exact model's Models.dev rates; insufficient evidence becomes `unknown`. Derived `costUsd` sums every USD-expressible request and is `null` only when no request is expressible; a response-less failure or an uncataloged model is skipped, never allowed to erase the expressible evidence. Each derived aggregate usage field independently sums its reported quantity, so heterogeneous detail coverage remains partial rather than becoming fictitiously complete. This is operational request accounting, not invoice reconciliation. Output and reasoning are quantities the model cannot KILL, so they never alter the model-facing Budget ledger.
@@ -4783,7 +4845,7 @@ Retired terms stay retired: the lexicon guard rejects `thinking`, the unqualifie
 | inbound `SEND` from outside the workspace | budgeted head under {§message-projection} |
 | structured `EDIT` receipt or textual `COPY`/`MOVE` effects | complete receipt-owned join context |
 | every other nonempty body | head bounded independently by `PLURNK_SERVICE_PREVIEW_LINES` and `PLURNK_SERVICE_PREVIEW_CHARS` |
-| bodyless row | heading, written request, and any facts; no coordinate lines; `logTokens` includes any selected native part |
+| bodyless row | heading and any facts; no coordinate lines; `logTokens` includes any selected native part |
 
 §markerless-first-page **Every markerless retrieval takes the same implicit marker.** A marker's
 unit is whatever its projection counts, so `PLURNK_SERVICE_PREVIEW_LINES` is the first page of
@@ -4937,13 +4999,14 @@ retain distinct contracts and lifetimes.
 | Import `@plurnk/plurnk-service/digest` | Ships `Digest` and its package-owned SqlRite statements; importing performs no I/O or process action. The CLI wrapper alone invokes it.             |
 | `run({ dbPath })`                      | Reads the required database and writes a complete digest to `./test/digest` relative to the caller's working directory.                             |
 | `digestDir`                            | Selects a nonempty output directory. Both `run` and `requiem` refuse an output containing the input pathname or its resolved database before database/provider I/O or output writes; normalized and real paths participate in that check. `run` removes and recreates output so stale artifacts cannot survive; concurrent callers use distinct directories. |
-| Reader lifetime                       | Both methods close their database reader on successful or failed reads, before rendering output or awaiting witness inference. |
+| Reader lifetime                       | `run` reads heavy evidence on demand while rendering, then closes its reader on success or failure. `requiem` closes its reader before awaiting witness inference. |
+| Export completion                     | Packet and response bodies are read and serialized one record at a time, without discarding evidence. `digest.json` is promoted from a partial file only after every artifact is written; its absence identifies an incomplete export. |
 | `workerId`                             | Narrows workers and every dependent loop, turn, turn-attached logical inference, specialization, physical request, and log row to that one worker. |
 | `workspaceId`                          | Narrows workers plus every logical inference and dependent evidence owned by one workspace, when both selectors are present they intersect. |
 
 §digest-cost-kind **Cost basis named.** A rendered Cost line carries the basis of its dollar figure: `(charged)` only when every settled request's cost is provider-charged; `(estimated — catalog rates)` when any settled request's cost is an estimate, because a mixed sum is no more trustworthy than its weakest term. A dollar figure without its basis reads as billed truth, and an estimate must never impersonate a charge.
 
-§output-allowance-notice **The output allowance is disclosed, and a ceiling cut names its cause.** The packet's budget section carries `tokensResponseMax: <tokens>` beside the curation ceiling whenever the provider resolves an output budget — the per-turn response allowance is a capacity fact, disclosed rather than discovered by truncation. The disclosed number is the program's guaranteed room — the configured output floor less the reasoning subset, since reasoning spends from the same allowance — never the wire grant: overflow tolerance (#482) is never advertised in the packet, and a cut's notice names the true per-call grant from the response's own capacity record. When a provider finish is `length`, the engine emits an `output_truncated` notice (source `engine:capacity`) naming the allowance — the fact alone, never advice on what to do about it — on every path — railed or not — and the rails verdict never blames the model's grammar for a cut the engine's own ceiling made. The same precedence governs a cut so deep no operation parses: the rejection notice names the truncation as the cause, not the parser's symptom, overriding {§invalid-emission-attempts}'s parser diagnostic for `length` finishes.
+§output-allowance-notice **The output allowance is not disclosed; a ceiling cut names its cause.** The packet's budget section carries the curation state and no response allowance: a model does not plan in tokens and no harness tells it its output ceiling, so the number was a fact without a use — across 9,124 recorded model turns none was cut at the allowance, while 45 emissions or reasonings spent tokens interpreting it (#826, operator, 2026-09-24). Overflow tolerance (#482) is likewise never advertised; a cut's notice names the true per-call grant from the response's own capacity record. When a provider finish is `length`, the engine emits an `output_truncated` notice (source `engine:capacity`) naming the allowance — the fact alone, never advice on what to do about it — on every path — railed or not — and the rails verdict never blames the model's grammar for a cut the engine's own ceiling made. The same precedence governs a cut so deep no operation parses: the rejection notice names the truncation as the cause, not the parser's symptom, overriding {§invalid-emission-attempts}'s parser diagnostic for `length` finishes.
 
 §digest-wire-line **Wire health aggregated.** Each worker summary renders a `Wire:` line — total physical provider requests, error-outcome count, and the error percentage when nonzero. Provider-level failures are absorbed by retries below the packet stream, so without this aggregate a rate-limit storm is invisible in every summary while the model's experience stays clean.
 
@@ -5227,6 +5290,7 @@ section because they are language extensions rather than executable tools.
 |---|---|
 | Registered and model-visible scheme | Its reference is eligible when at least one supported resource capability is admitted by the effective policy ({§capability-admission}). Illustrative operations never determine admission. |
 | Runtime output scheme | Its runtime's reference owns discovery; no duplicate scheme reference. |
+| Family manager and its generated documents | Eligible while the family's manager runtime is admitted by the effective policy ({§capability-admission}), by name or by trait: a denied family has no page, no generated document and no runnable verb, so a masked family never stands in the survey empty (#842). |
 | Excluded scheme | `PLURNK_SERVICE_DOCS_EXCLUDE` omits its reference, not its functionality. |
 | Reference content | Required meta-owned content follows {§teaching-corpus}; other schemes may supply optional `manifest.documentation`. Absent optional content contributes nothing; a failed required source read surfaces its cause. |
 | Policy layers | Materialization, Turn0, and direct operations use the same current workspace policy and service ceiling. |

package/dist/build-info.json

@@ -1 +1 @@
-{"package":"@plurnk/plurnk-service","version":"1.20.0","revision":"e546e762f4003c68993473ab86bf635f55728912","dirty":false}
+{"package":"@plurnk/plurnk-service","version":"1.21.1","revision":"7650feb0526a2dd34ca0102af7a3f10ccfb15689","dirty":false}

package/dist/content/line-anchors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line-anchors.d.ts","sourceRoot":"","sources":["../../src/content/line-anchors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"line-anchors.d.ts","sourceRoot":"","sources":["../../src/content/line-anchors.ts"],"names":[],"mappings":"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"}