@plurnk/plurnk-service 1.22.0 → 1.23.0

package/.env.defaults

@@ -10,6 +10,10 @@
 # Database path; empty = $XDG_DATA_HOME/plurnk/plurnk.db (~/.local/share by default).
 # Module operational state: $XDG_STATE_HOME/plurnk (~/.local/state/plurnk by default).
 PLURNK_SERVICE_DB_PATH=
+# A private daemon's root ({§state-root}): empty = the XDG homes; an absolute path (a leading ~/
+# expands) roots data, state, cache and runtime under it as <root>/{data,state,cache,runtime}/plurnk.
+# Configuration and the shared Agent Skills root never move; PLURNK_SERVICE_DB_PATH still wins.
+PLURNK_SERVICE_STATE_ROOT=
 # Where `share` writes when no folder is named: each share is a stamped child folder.
 # A leading ~/ expands; empty = $XDG_STATE_HOME/plurnk/shares (~/.local/state/plurnk/shares by default).
 PLURNK_SERVICE_SHARE_FOLDER=

package/SPEC.md

@@ -224,6 +224,32 @@ before provider or capability initialization can perform external work. Every
 later startup failure closes resources in reverse ownership order while
 preserving the originating failure: daemon, observability, database, listener.
 
+§startup-readiness-line **Readiness is one stdout line.** After the client interface is mounted
+the service prints exactly one line, `plurnk-service agui=<url> db=<json string> route=<json string>`:
+the URL brackets an IPv6 host, and the database path and the route (the active model route or
+`no model`) are JSON strings, so a path or route containing spaces is exact and a consumer parses
+the URL as a URL and the strings as JSON; nothing else the service prints on stdout before it has
+that prefix. Before the line the listener answers `503 service-starting`; after it,
+`discover` is the identity check a launcher uses to tell this daemon from any other listener. A bind
+failure is an exit with the originating address error and means *occupied*, not *foreign* — another
+plurnk-service may be starting there, and only `discover` says which.
+
+§daemon-launch **The service ships its own launcher; launchers own policy.** `@plurnk/plurnk-service/launch`
+spawns a daemon argv with the caller's environment, an optional {§state-root}, host and port, and
+resolves on the readiness line with the published address, database path, route and a `stop()` that
+is SIGTERM, a stated grace, then SIGKILL, resolving when the process has ended. It holds no timing of
+its own: the caller states the readiness timeout and the stop grace. A start that fails — spawn error,
+exit before readiness, or timeout — is stopped and awaited before the failure is thrown with its kind
+and both output streams; the helper never creates, keeps or removes state. A shared daemon survives
+the launcher that started it (scheduled deliveries, other clients and inbound A2A depend on it); a
+private daemon is its launcher's child and ends with it under managed shutdown. The launcher
+spawns either: `lifetime: "private"` (the default) pipes both streams to the launcher; `lifetime:
+"shared"` puts the daemon in its own process group with both streams appended to the caller's
+`logFile`, reads readiness from that file, and releases the process once ready, so the launcher may
+exit while the daemon runs on and no output accumulates in a launcher that has left; until
+readiness the launcher owns it either way, and `stop()` ends it while the launcher lives. Shell and container
+launchers consume the same contract by reading the line themselves.
+
 ## §actor-boundary Workers and workspace boundaries
 
 ```mermaid
@@ -352,7 +378,7 @@ direct-entry-plus-directory count; `-1` enables the ordinary markerless page;
 unset / `0` disables previews. `log://` is absent because the current worker's
 log already renders in present mode.
 
-§worker-initialization-entry **Model-worker initialization is a real `_plurnk` turn.** A model worker's first loop begins with one packetless `{ producer="_plurnk", kind="initialization" }` turn submitted through {§turn-ops-admission-path}. Its reasoning and program are stored before execution. NOTEs from its reasoning and program, the orienting READ/FIND surveys, and the reasoning and program READs in {§reasoning-initial-read} execute under {§op-execution-order}. The full `<1,-1>` READ of its own `ops://<worker>/<loop>/<turn>` source supplies the worked program example; no actionless source row or simulated READ is added. Every orienting row is structurally classified `_plurnk` and `init`. The namespace surveys and their asides follow {§actor-boundary-catalog-preview}.
+§worker-initialization-entry **Model-worker initialization is a real `_plurnk` turn.** A model worker's first loop begins with one packetless `{ producer="_plurnk", kind="initialization" }` turn submitted through {§turn-ops-admission-path}. Its reasoning and program are stored before execution. NOTEs from its reasoning and program, the orienting READ/FIND surveys, and the reasoning READ in {§reasoning-initial-read} execute under {§op-execution-order}. Its program supplies the worked example as the first request's assistant message ({§packet-wire-envelope}); no program READ, actionless source row or simulated READ is added. Every orienting row is structurally classified `_plurnk` and `init`. The namespace surveys and their asides follow {§actor-boundary-catalog-preview}.
 
 Incoming messages publish once as inbound SEND rows in the first model turn
 ({§message-arrival}); initialization neither READs nor archives them. The turn
@@ -574,18 +600,22 @@ Every admitted authority is a literal `workers.name`; self-addressing uses the c
   `"parent": null` at a root, so a worker never infers its rank from silence.
 - §packet-current-turn **The packet says who and which turn, below the log.** The
   `## Worker` block is the first section after the log, carrying
-  `{"path": "worker://<name>", "parent": <address or null>, "loop": L, "turn": T}`: the actor,
-  whose child it is, and the coordinate this packet's response becomes, so `reasoning://<worker>/L/T`
-  and `ops://<worker>/L/T` are the model's own and `log:///L/T/*` its rows; a model never infers the
-  present from the last row's coordinate, which may or may not be its own turn. The block
+  `{"path": "worker://<name>", "parent": <address or null>, "loop": L, "turn": T, "previousEmission": <ops address or null>}`:
+  the actor, whose child it is, the coordinate this packet's response becomes, so `reasoning://<worker>/L/T`
+  and `ops://<worker>/L/T` are the model's own and `log:///L/T/*` its rows, and the address of the program
+  the envelope's assistant message carries ({§packet-wire-envelope}), so the rows sharing that coordinate
+  are its receipts; a model never infers the present from the last row's coordinate, which may or may
+  not be its own turn. The block
   changes every turn, so nothing of it precedes the log, and the packet carries no date, time
-  or zone anywhere. The coordinate only; the source addresses stay
-  documented, not taught.
+  or zone anywhere. The coordinates and the last program's address only; the other source
+  addresses stay documented, not taught.
 
 Worker control rides the daemon's inject seam (active→fold, idle→enqueue+drain), so the handler creates/branches the worker and hands off; the daemon owns provider + system prompt. FORK/WORK carry the seed task in the body and are their own ops, dispatched to worker control — never the entry-copy path.
 
 ## §membership File membership and project roots
 
+A file is a member of a workspace when Git tracks it or a members definition includes it and none excludes it; only members can be READ, found by FIND, or changed by EDIT, and every member path resolves under the project root.
+
 The project-file path has two explicit reconciliation gates. Internal entries do
 not participate in this disk loop.
 
@@ -1070,6 +1100,15 @@ single operation captures the equivalent boundary before dispatch. This limits
 only log-row selection: operation phasing and same-turn resource effects retain
 their ordinary contracts.
 
+### §engine-notifications One bundle of daemon callbacks
+
+The daemon's observation callbacks — stream, reasoning, outside-text and packet
+events, worker wake, inject and cancel, operation settlement, notices — are one
+declared bundle (`EngineNotifications`). The Engine receives them flat, carries
+them as one value, and every consumer reads the callbacks it uses from that
+value; adding one is a declaration and a use, never an edit to the constructors
+between. Scheme contexts still expose the specific callbacks a handler may call.
+
 ### §engine-rails Engine rails
 
 After each admitted turn, one inline verdict decides whether the loop continues.
@@ -1221,7 +1260,7 @@ Three current entry points:
 
 ### Engine → provider guarantees
 
-- `messages` is a complete prompt (the section list, pre-assembled into the system + user messages). Provider does not reorder.
+- `messages` is a complete prompt (the section list, pre-assembled into the wire envelope, {§packet-wire-envelope}). Provider does not reorder.
 - §provider-guarantees-signal-wired `signal` is wired to the worker's AbortController.
 - §provider-guarantees-serial-attempts Emission attempts for one engine turn are serial. They reuse the exact messages, coordinates, generation limits, and strike state; two attempts for that turn never overlap.
 - BARE calls admitted by one turn launch as one parallel batch; each call retains independent observer and failure state, and the engine awaits the complete batch before committing results in authored order ({§bare-inference}).
@@ -1547,7 +1586,7 @@ Registration precedes loop affinity:
 - §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`.
-- §edit-batch-merges **Normalizations require evidence and a receipt.** An EDIT body carrying only this resource's published `@xxxxx L:` prefixes is stripped when those prefixes verify against current anchors or this worker's preserved READ receipts (`rendered-prefix-stripped`); otherwise it remains literal content (`rendered-prefix-unverified`). Within a single atomic splice batch, the Slicer can deduplicate identical regions/bodies, concatenate same-boundary insertions, assign a shared endpoint to the sole body reproducing that line, or relocate an inner change when its original content occurs exactly once in the outer body. An already-applied inner body can be dropped. Unevidenced overlap remains a collision. These batch resolutions never reinterpret separate authored EDITs. Applied normalizations carry their exact merge facts and a notice; receipts describe only the applied effects.
+- §edit-batch-merges **Normalizations require evidence and a receipt.** An EDIT body carrying only this resource's published `L<@xxxxx>` prefixes (the number right-aligned) is stripped when those prefixes verify against current anchors or this worker's preserved READ receipts (`rendered-prefix-stripped`); otherwise it remains literal content (`rendered-prefix-unverified`). Within a single atomic splice batch, the Slicer can deduplicate identical regions/bodies, concatenate same-boundary insertions, assign a shared endpoint to the sole body reproducing that line, or relocate an inner change when its original content occurs exactly once in the outer body. An already-applied inner body can be dropped. Unevidenced overlap remains a collision. These batch resolutions never reinterpret separate authored EDITs. Applied normalizations carry their exact merge facts and a notice; receipts describe only the applied effects.
 
 ### Cross-scheme orchestration
 
@@ -1907,9 +1946,11 @@ 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
 `L` to the decimal width of the complete canonical selected channel's final
-addressable line and emits `@xxxxx L:<content>` with one or more ASCII spaces
-before `L`; a source line therefore retains the same prefix across projections
-of one revision.
+addressable line and emits `L<@xxxxx><content>` with `L` right-aligned to that
+width, the scope literal as the delimiter, the content beginning after `>`. The anchor
+stands against its own text and never opens the row after the previous line's text —
+the placement that reads correctly at long context on every model measured (#893); a
+source line therefore retains the same prefix across projections of one revision.
 An explicit default-channel fragment and its fragmentless spelling share that
 identity; a selected non-default channel retains its canonical `#channel`.
 
@@ -2270,7 +2311,10 @@ Authored `metadata` retains its opaque ordered block strings under {§scheme-met
   This is retained evidence, not a separate visibility or delivery lifecycle. Source mutation/deletion
   cannot change a retained observation. Explicit READ of its still-active log source can acquire the same media again.
   Every compatible-model packet includes one file part per retained, admitted READ observation, after the
-  packet text, in observation order. Model-response settlement never consumes an observation. KILL follows
+  packet text, in observation order, each preceded by a text part that names the observation's log
+  coordinate, source path and projection facts and states that the bytes are that READ's own, retained
+  until its row is KILLed: an uncaptioned native part on the user turn reads as a fresh arrival (#899).
+  Model-response settlement never consumes an observation. KILL follows
   {§log-kill-scope}; forks inherit the snapshot and ordinary projection state independently. Output withholding
   suppresses the complete native part under {§context-output-admission}. Unsupported routes receive only the
   text projection and no native charge; switching back to a compatible route exposes still-retained media.
@@ -2422,7 +2466,7 @@ per-operation projection on `rx`; the aggregate remains inside dispatch.
 | `effect.source`, `result`             | `effect` as `<source> -> <result>`                                | Resolved scopes mapping the source snapshot into the landed body; the admitted marker stays in durable `requested` and `tx`. |
 | `effect.removed`, `inserted`           | `change`                                                          | Removed and inserted counts in the receipt unit. |
 | `effect.removedText`                   | `removed`                                                         | {§edit-receipt-removed-text}: a pure deletion's removed text, its first `PLURNK_SERVICE_EDIT_RECEIPT_REMOVED_LINES` lines; absent when the edit inserted anything.                                                                          |
-| `effect.context`                       | Canonical row body                                                | Numbered physical lines at each landed boundary, bounded symmetrically by `PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES`.   |
+| `effect.context`                       | Canonical row body                                                | Numbered physical lines at each landed boundary, bounded symmetrically by `PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES`. A pattern batch's `last` context follows the first's when it differs, with no blank line between: every line of a row body carries its coordinate. |
 | `disposition`, `requested`             | `disposition`, `requested`                                       | A reviewer-replaced batch preserves the authored marker while stating that its attributed effect was superseded.          |
 | `replacement`                          | `replacement`, `change`, canonical proposal-owner body           | The one whole-resource effect actually applied by the reviewer replacement; never duplicated across authored rows.        |
 
@@ -2870,7 +2914,9 @@ anything spawns — a file is the script; a directory is refused `400 target-not
 pointing at `[{"cwd": "…"}]`; an absent path is refused `400 target-not-found`, giving the
 applicable accepted form without inferring what the model meant. When the target is a
 registered tool of another executor, recovery gives that tool's exact bracketed
-invocation; otherwise it points at an existing script or a bare shell-command body. A non-file resource
+invocation; when it names another available executor (`sh (python3)` over a Python body, #895),
+recovery names that executor's fence — `` `python3` is its own executor; use that name on the
+opening fence and put the program in the body. ``; otherwise it points at an existing script or a bare shell-command body. A non-file resource
 target that cannot be read keeps the owning READ's failure identity (#163) and states
 the slot contract in its recovery — the resource is the program and the body its stdin;
 a command belongs beneath a targetless heading — without guessing which was meant (#425). The started receipt always
@@ -3002,7 +3048,8 @@ Per-tool programs such as `go`, `cargo`, `make`, and `npm` do not earn executor
 
 §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
+absent is `loop`. The key is one of the service's reserved metadata keys, withheld
+from every owner by the framework ({§service-metadata-keys}). An execution takes no scope: a numeric coordinate on an
 executor target is refused `scope-unsupported` (400), naming the field.
 
 | `lifetime`   | The spawn |
@@ -3217,7 +3264,7 @@ body prefixes.
   wholesale ({§log-sensitive-request-evidence}); the spawn's record names each such value's
   provenance as the modifier's.
 - §exec-hold-until-concluded **The turn-hold exception** — for runtimes in `PLURNK_SERVICE_EXEC_HOLD` (a decision-table env), an in-flight stream **pauses the cycle**: the next packet does not assemble until the stream concludes, so the model never burns a turn asking "are we there yet" about a result the engine controls end-to-end. This exception is limited to seconds-bounded runtimes whose final result the engine controls end-to-end. Bounded by `PLURNK_SERVICE_EXEC_HOLD_MS` and **fail-open**: at the cap the standard cycle resumes untouched (waits, wakes, polls). Zero grammar or teaching surface — the model emits an executor fence, optionally followed by WAIT; the wake-shaped world simply arrives one packet sooner. It extends selected runtimes beyond the ordinary {§worker-optimistic-settlement} cap before the next packet assembles. A bare entry holds ALL of a runtime's spawns; a `<runtime>:<effect>` suffix (`github:read`) holds only that effect-class — an MCP server is one runtime whose tools split (a `read` `get_issue` is instant; a `host` `run_migration` is a slow mutation), so an operator opts the known-fast read-class in without parking on the mutation. Conservative stays default: an arbitrary third-party server's latency never parks the engine unless a suffix opts a class in.
-- §exec-entry-sink **The entry() sink** implements {§executor-entry-sink} over ordinary scheme-owned entries. Core owns allocation, materialization, and persistence; executors receive only the returned resource address.
+- §exec-entry-sink **The entry() sink** implements {§executor-entry-sink} over ordinary scheme-owned entries. Core owns allocation, materialization, and persistence; executors receive only the returned resource address. Web acquisition and materialization are the `https` handler's {§web-materialization-contract}, reached through the scheme registry; core names no leaf package.
 
   | Input / effect | Consumer behavior |
   | --- | --- |
@@ -3626,6 +3673,14 @@ and is ignored rather than resolved against the working directory.
 | Reproducible cache | `$XDG_CACHE_HOME` (default `~/.cache`) | Reserved; no directory is created without an owned artifact. |
 | Shared global Agent Skills | User home | `.agents/skills/<name>/SKILL.md` |
 
+§state-root **A private daemon has one root.** `PLURNK_SERVICE_STATE_ROOT` (absolute; a leading
+`~/` expands; a relative value fails hard by name) replaces the data, state, cache and runtime homes
+with `<root>/data`, `<root>/state`, `<root>/cache` and `<root>/runtime`, the database with them
+(`PLURNK_SERVICE_DB_PATH` still names the database exactly). Configuration stays where the cascade
+reads it and the shared Agent Skills root stays under the user's home: a state root separates what
+the daemon *writes*, not what the operator supplies, and is no execution sandbox. What a launcher
+keeps or removes under a root after the daemon stops is that launcher's retention decision.
+
 The service creates only a directory required by the current command. A newly
 created configuration or data directory uses mode `0700`; a newly seeded
 secret-bearing `.env` uses `0600`. Existing user-owned permissions are not
@@ -4048,7 +4103,12 @@ actions from model operations where the family contract requires it
 outcomes, and a snapshot with `commit`/`abort`. Successful publication commits;
 failure aborts; cooling tears down. Protocol continuations remain ordinary
 module actions. Optional `forget` releases an installed or provisioned
-definition before removal; failure rejects removal ({§skills-remove}).
+definition before removal; failure rejects removal ({§skills-remove}). The
+seam's shapes — the identity a verb acts under, its options, definition
+sources, outcomes, preparation, the prepared result and the family handle —
+are declared once in `plurnk-contracts` and imported by core and every
+module; core adds only its own face of the seam, the runtime registration a
+resident family prepares and the scheme facet it may expose.
 
 An adapter may expose a `scheme` facet beneath its family's runtime namespace
 ({§runtime-resource-binding}). A facet claims a path subtree and is the scheme's
@@ -4224,11 +4284,12 @@ Core's behavior behind them.
 | §methods-conversation-worker Workspace lifecycle  | `createConversationWorker({ workspaceId, name? })` | Creates a distinct model-origin root worker with empty history: a fresh conversation over the same world, not a fork or the stable default. |
 | Workspace lifecycle                               | `forkWorker({ workspaceId, workerId, name? })` | Creates a child worker that branches the source worker's history while sharing workspace state. |
 | §methods-workspace-rename Workspace metadata      | `renameWorkspace(workspaceId, name)` | Changes only the world's unique mutable name; workers, log, and membership remain intact. |
-| §methods-workspace-prompts Workspace metadata     | `listPrompts(workspaceId, limit?)` | Returns nonempty loop-seed prompts from the workspace's model-origin root conversations, newest-first. An omitted limit is `PLURNK_SERVICE_PROMPTS_PAGE`; spawned and forked child prompts are excluded. |
+| §methods-workspace-prompts Workspace metadata     | `listPrompts(workspaceId, limit?, workerId?)` | Returns nonempty loop-seed prompts a client addressed to the workspace's model workers, newest-first; `workerId` narrows to one worker. Authorship is the seed message's address ({§message-arrival}): a worker-issued seed (WORK, FORK, SEND to a worker) has none and is never history, whichever worker it seeded; a client prompt at a forked conversation worker is. An omitted limit is `PLURNK_SERVICE_PROMPTS_PAGE`. |
 | Workspace metadata                                | `listWorkspaces()`, `workspaceDerivationStatus(...)` | Reads current workspace identity and derivation progress. |
 | §methods-worker-read Worker topology              | `readWorker({ workspaceId, identity })` | Ownership-bounds an exact id-or-name lookup and returns one durable Worker projection or `null` under {§application-worker-observation}. Supplying both identities or neither is invalid. |
 | §methods-worker-list Worker topology              | `listWorkers(workspaceId, query?)` | Returns the workspace's durable Worker projections under {§application-worker-observation}. The origin filter is exact; an explicitly present `parentWorkerId` filters roots (`null`) or one immediate parent (id), while omission returns every lineage position. Each projection carries `kind` (`conversation`, `fork` for a child with a fork boundary, `work` for any other child) and `lifecycle`, the representative work loop's status through {§loop-lifecycle-vocabulary} (`idle` with no work loop), so a directory row shows the same lifecycle glyph the bound worker's own status gauge shows; clients infer neither (#523). |
 | §methods-worker-loops Loop lifecycle              | `listWorkerLoops({ workspaceId, workerId })` | Ownership-checks the Worker and returns its Loops in sequence order under {§application-loop-observation}, including the validated exact terminal result when one exists. It performs no scheduling or event replay. |
+| §methods-worker-descendants Descendant spend       | `descendantAccounting({ workspaceId, workerId, loopId })` | Ownership-checks the Worker and returns the {§provider-accounting} projection of every settled request on a loop that a descendant of the Worker (`parent_worker_id`, to any depth) ran after `loopId` — this delegation's spend, the same tree the turn cap counts ({§turn-cap-counts-the-tree}). The Worker's own loop is never included: its accounting stays {§notifications-loop-terminated}'s. `loopId: null` is the empty projection, explicit zero. Derived from the request ledger on every read ({§tokenomics-provider-usage}); no rollup, no second store. |
 | Extension actions | `listModuleActions()`, `invokeModuleAction(name, params, context)` | Lists setup-registered `{ name, scope, inputSchema, outputSchema }` descriptors in sorted order. Invocation requires a context matching the registered scope; missing names, forged scope, and missing workspace identity fail before the owner runs. Handler values remain opaque to core. |
 
 §methods-loop-run-fold-consistency **A folded prompt cannot silently reconfigure
@@ -4533,6 +4594,26 @@ flowchart LR
     measure --> rail[Engine budget admission and dispatch]
 ```
 
+### §packet-wire-envelope The wire envelope
+
+The packet reaches the provider under the roles the model was tuned on, its bytes unchanged:
+
+| Message | Role | Content |
+|:--|:--|:--|
+| 1 | `system` | the system slot, as rendered |
+| 2 … | `user` | the log's records, one message per completed turn in record order; the first opens with `## Log` |
+| next | `assistant` | the canonical rendering ({§statement-rendering}) of every statement the parser admitted from the worker's most recent program that admitted any ({§turn-source-resources}, kind `ops`), in order and alone: free text and unadmitted forms are absent, a recovered native call ({§native-tool-calls}) appears as the operation it was read as, and an operation whose receipt failed stays, since it produced its row; turn zero's survey ({§worker-initialization-entry}) is the first, so every model request carries one |
+| last | `user` | the current turn's records, then the remaining user sections in {§packet-cache-monotone} order; native parts ride here ({§packet-attachment-parts}) |
+
+Only role boundaries are added. Curation governs every record as before, so a KILLed
+row is absent from its turn's message; the one program is bounded and the model's own last operations,
+a demonstration of the grammar beside what the log made of it. Whatever sits under the assistant marker
+is what the model writes next, for better and for worse: shown its own slip, a model repeats it, so the
+slot carries the grammar's reading and never the bytes as typed. On the first request it is turn zero's
+survey, the worked example in the model's own place. The prefix through the last completed
+turn stays reusable across requests; the assistant message and the closing user message are the
+changing tail. The digest's packet artifacts record the packet; the envelope is its projection (#903).
+
 ### §packet-cache-monotone Default order and cache locality
 
 Conditional absence never reorders the surviving default sections.
@@ -4543,7 +4624,7 @@ Conditional absence never reorders the surviving default sections.
 |     2 | system | `system-policy`       | Operator policy; empty content is omitted on the wire. |
 |     3 | system | `inject`              | Present only when operator notes are configured. |
 |     4 | user   | `log`                 | Append-mostly model-visible history; the first user section, so the cached prefix ends inside it. |
-|     5 | user   | `worker`              | `Worker`: `{"path": "worker://alice", "parent": <address or null>, "loop": L, "turn": T}`, the actor and the coordinate this packet's response becomes ({§packet-current-turn}). |
+|     5 | user   | `worker`              | `Worker`: `{"path": "worker://alice", "parent": <address or null>, "loop": L, "turn": T, "previousEmission": <ops address or null>}`, the actor, the coordinate this packet's response becomes and the address of its previous program ({§packet-current-turn}). |
 |     6 | user   | `delegation`          | `Delegation`: per-turn `{workers, streams}` pointers; always present, each list `[]` when empty ({§packet-empty-sections}). |
 |     7 | user   | `errors`              | Per-turn failure pointers; empty content is omitted. |
 |     8 | user   | `notices`             | Per-turn observations; empty content is omitted. |
@@ -5041,6 +5122,8 @@ retain distinct contracts and lifetimes.
 
 §notice-event-notify **Client surface.** Engine Notices broadcast live via the `notice/event` notification — `{ workerId, loopId, notice: { source, kind, level, message?, position?, …kind-specific } }` per the grammar's `Notice` schema — the moment they land. A loop Notice names its owning Worker; workspace derivation progress alone carries `workerId=null, loopId=0`. AG-UI projects the same observation as the custom `plurnk.notice` event. Failures do not broadcast on this surface: they are log rows, and the client reads them through `log.read` / the `log/entry` notification, the durable log.
 
+§loop-status-notice **The drain beats the loop's lifecycle on the notice channel.** When the drain claims a loop to run it broadcasts `notice/event` `{ workerId, loopId, notice: { source: "engine:lifecycle", kind: "loop_status", level: "info", status: 102 } }`, and when it leaves a loop parked ({§loop-wake-identity}) the same with `status: 202`; a wake that the drain claims again is another `102`. The beat is transient: broadcast to the workspace like any notice ({§notice-event-notify}), never a log row, never in a packet. Terminals stay `loop/terminated`'s; a client that reads the beat has the running/parked edges a parked delegation otherwise never publishes.
+
 §share **A share is the database's record, ready to send.** `plurnk-service share [<file.db>] [<folder>]`, and `npm run share` from a checkout, take a consistent copy of the database (`VACUUM INTO`; a live database is never read in place), and write its digest into `<folder>`, an ordinary folder the user archives or attaches however they like. Without a database the service's own is shared. Nothing is overwritten: a folder that exists and is not empty is refused, and a caller reusing a place removes it first. The share is the user's bug report and our dogfood, benchmark and forensics artifact alike.
 
 §share-snapshot **A database is copied by SQLite, never by the filesystem.** `Share.snapshot(dbPath, copy)`, exported as `@plurnk/plurnk-service/share` with `Share.write`, is the one consistent copy: a byte copy of a WAL-mode database drops every committed page still in its `-wal` file. A harness that keeps the database beside its digest takes it through `snapshot`; an existing `copy` is refused.
@@ -5068,6 +5151,10 @@ retain distinct contracts and lifetimes.
 
 §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.
 
+§digest-cache-ledger **Cacheable versus cached, per request.** For every physical provider request the digest computes its cacheable prefix: the longest common prefix, in characters, between the prompt its turn stored (the packet's rendered `system` text followed by its `user` text — the bytes `.system.md` and `.user.md` carry) and the prompt of the previous provider request in the same loop, taken as that prefix's share of the whole prompt in the packet's own token estimate ({§tokenomics-agnostic-ruler}) and applied to the provider's reported input count, so `cacheableTokens` sits in the same units as the cache read beside it; a loop's first request has 0, and a request whose turn stores no valid packet or whose provider reported no input count has none. Beside it sit the provider's reported cache read as `cachedTokens` (`provider_requests.usage_input_cache_read`) and `inputTokens` (`usage_input`). `digest.json` carries the three on every provider-request row; an inference turn line carries `cache=<cached>/<cacheable>` summed over the turn's requests; each workspace heading is followed by `Cache: <cached> of <cacheable> cacheable tokens reported (<pct>%) over <n> requests`. A provider that reported no cache field at all (null, not 0) renders `?` on the turn line and is counted apart on the workspace line (`· <k> unreported (cached=?)`), outside both sums and the percentage; a request without a stored packet or without a reported input count is likewise counted apart. The prefix measures what the daemon kept identical between consecutive requests; it is no claim about the provider's tokenization or cache-block alignment, so a provider that under-caches an identical prefix reads as such, apart from a prefix the daemon itself broke.
+
+§digest-edit-census **Every model EDIT by the form it authored, how it landed, and whether it came back.** For each worker the digest reads every model-authored EDIT row and classifies the form from the row's stored marker and the durable statement's pattern: `hash` (one anchor), `line` (one line number), `range` (two marks), `insert` (the zero-width `<L,1,L,1>` form, {§zero-width-column-one-insert}), `column` (any other four-mark region), `prepend` / `append` (`<0>` / `<-1>`), `offset` (a tolerated anchor offset, {§anchor-offset}), `pattern` (a selection matcher), `whole` (no marker: a creation when it lands 201). It counts the EDITs, those refused (status ≥ 400), and the *revisits*: an EDIT of a path the same worker had edited within its previous two model turns — the shape of a repair without the claim of one. Each worker summary renders `EDITs: <n> · <form>=<count>… · refused=<k> · revisits=<r>` (`(no edits)` for none); `digest.json` carries the census as `edit_census` on every worker and stamps every EDIT log entry with its `edit_form` and `edit_revisit`. A form is a fact about what was written, never about intent; the bench sheet reads the counts as friction and leaves the judgement to the reader.
+
 §digest-forensic-fidelity **Forensic fidelity and cardinality.** The digest's machine-readable JSON preserves every log event with its initial and current projection, causal `source`, and structured `attrs`; every exact log-KILL target effect; the exact Problem on every failed row; each loop's exact terminal result, settlement time, scheduled due time, recurring interval, and recurrence lineage; and every ordered physical provider request. Programs still produce chronological `assistant.md` artifacts after every READ receipt is KILLed; source is independent of log curation. Each stored packet validates independently: one malformed historical packet remains exact raw evidence with its complete validation error chain and never prevents healthy turns from being projected. Accounting on broader rows is the shared exact derivation from that ledger, never a second stored fact. A worker's Cost line names how many settled requests carry no usage at all (errored or aborted exchanges) — their server-side spend is unrecorded rather than silently priced as zero. The reasoning chronology distinguishes readable reasoning content from provider-reported reasoning usage: when tokens were reported but no readable content was returned, it states both facts instead of implying that no reasoning occurred. The human Markdown waterfall shows a present causal source and may preview only the Problem detail because it remains a triage projection, not the machine record. Targets reconstruct the model-visible address, including hostname, port, serialized query, and fragment; an authority-bearing URL must never degrade from `https://host/path` to `https:///path`, and durable resource coordinates render back to their authority form. Its human Markdown waterfall groups identical per-turn op outcomes and typed `entry_materialized` narrations, reporting the exact count and sequence span (`xN (seq A-B)`). Grouping keys include source and the complete target, so distinct causes, authorities, or channels never collapse. Thus amplification is conspicuous without making the diagnostic artifact itself pathological; valid packet files remain byte-identical records of what the model saw.
 
 Unrecognized actionless log rows are retained and labelled as such, not
@@ -5687,3 +5774,152 @@ exits; a failed suite's evidence is never touched and stays exactly where the ru
 caller's own run directory.
 
 §fs-world-state **The world-state harness — coverage that closes the class.** Op-outcome tests check what an op returned; the harness checks the resulting world. `WorldState.check(db)` asserts, pure-db and read-only: identity uniqueness in practice (no tuple holds two rows), the canonical fixpoint on every file-class key, channel orphan-freedom, the closed admission set (every file row's origin is Git or constraint), and sig-coherence. Generated-pick incorporation and lifecycle require filesystem/Git evidence and are covered by the composed creation matrix rather than a false pure-database proxy. The harness runs as a lifecycle-test epilogue and at every soak turn boundary, where the delta half applies: an idle turn grows the entries table by ZERO. A violation names its law and its row.
+
+## Problem codes and pinned wording
+
+Every Problem code core mints is named here under its family ({§problem-error-carrier} carries it); the root lint (`scripts/problem-codes.mjs`) refuses a code no owning SPEC names.
+
+§problems-dispatch **Dispatch Problems.** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `target-required` | 400 | *OP* requires a target path. Recovery: Write the target in parentheses on the opening fence line: `OP (path)`. |
+| `scheme-not-found` | 501 | Scheme '*name*' is not registered. |
+| `scheme-metadata-unsupported` | 400 | *OP* on '*scheme*' does not accept the [metadata] modifier. |
+| `operation-not-implemented` | 501 | Scheme '*name*' does not implement *OP* (or exec). |
+| `entry-read-not-implemented` | 501 | The '*scheme*' scheme does not provide entry reads. |
+| `entry-write-not-implemented` | 501 | The '*scheme*' scheme does not provide entry writes. |
+| `entry-delete-not-implemented` | 501 | The '*scheme*' scheme does not provide entry deletion. |
+| `channel-delete-not-implemented` | 501 | The '*scheme*' scheme does not provide channel deletion. |
+| `scheme-handler-threw` | 500 | The '*scheme*' scheme did not produce a result for *OP*. |
+| `exec-source-not-data` | 501 | Scheme '*name*' is not a data source for an execution. |
+| `writer-forbidden` | 403 | Writer '*origin*' cannot modify scheme '*name*'. |
+| `capability-denied` | 403 | Capability '*route*' is denied by *scope* policy. |
+| `spawn-prompt-empty` | 422 | *OP* has no prompt text: the resource is empty and there is no body. |
+| `message-not-found` | 404 | No accepted message exists at *address*. |
+| `edit-collision` | 409 | EDIT collided with the current resource state ({§edit-collision}). Recovery: *n* of *m* edits applied. READ the target for current coordinates. |
+| `edit-target-required` | 400 | A line-anchored EDIT requires a target resource. Recovery: Provide the target that rendered the line anchor. |
+| `kill-target-required` | 400 | KILL requires a target path. |
+| `kill-target-scheme-required` | 400 | KILL target requires a scheme. |
+| `worker-not-found` | 404 | Worker '*name*' does not exist in this workspace. |
+| `entry-operation-unsupported` | 400 | KILL requires an entry-bearing target; '*scheme*' does not provide one. |
+| `resource-scheme-required` | 400 | Resource selection requires an address. |
+| `channel-required` | 400 | The '*scheme*' scheme has no default channel. Recovery: Address a named channel with a URI fragment. |
+| `binary-source-unsupported` | 415 | Channel #*name* is binary and its scheme keeps no bytes to transfer. |
+| `metadata-unsupported` | 400 | *OP* takes only the env option; '*key*' is not one. |
+| `worker-name-conflict` | 409 | Worker '*name*' already exists in this workspace. Recovery: To give '*name*' more work, write `SEND (worker://_name_)` with the task as the body; to start another worker, choose a name no worker holds. |
+| `no-operation` | 422 | The turn performed no operation ({§empty-turn}). |
+| `send-target-not-a-recipient` | 400 | The addressed scheme is not a SEND recipient. Recovery: A targetless SEND answers the open messages; a directed SEND requires a recipient that implements SEND. |
+
+§problems-content **Content and transfer Problems.** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `handler-crashed` | 415 | The *mimetype* content handler failed on *key*: *cause*. |
+| `line-anchor-unsupported` | 400 | The byte view of *target* publishes no anchors. Recovery: Use byte coordinates: `<first,last>`. |
+| `line-anchor-invalid` | 400 | A line anchor in the marker is malformed or names no current line ({§line-anchors}). |
+| `channel-not-found` | 404 | The addressed channel does not exist at *target*. Recovery: Use one of the available channels: #*a*, #*b*. |
+| `binary-read-unsupported` | 415 | The representation at *target* is binary and cannot be rendered. |
+| `pattern-unapplicable` | 422 | The pattern could not be applied to *target*. |
+| `move-region-overlap` | 409 | MOVE cannot insert a whole channel into itself and then remove that channel. |
+| `mimetype-mismatch` | 415 | COPY or MOVE cannot write '*source-mimetype*' into a '*destination-mimetype*' channel. |
+| `binary-region-unsupported` | 415 | Channel #*name* is binary and cannot receive a textual region. |
+| `copy-destination-exists` | 409 | COPY or MOVE destination *address* already contains different content. |
+| `proposal-apply-missing` | 500 | The source scheme accepted its MOVE proposal without applying the source mutation. |
+| `line-anchor-collision` | 409 | READ coordinates collided with current content at *target*. |
+
+§problems-file **File scheme Problems.** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `edit-empty` | 400 | EDIT requires at least one statement. Recovery: Provide an EDIT statement. |
+| `edit-batch-mismatch` | 400 | The EDIT batch spans multiple resources. Recovery: Submit a separate EDIT batch for each resource. |
+| `line-marker-required` | 400 | EDIT of an existing file requires a line marker ({§edit-marker-required-on-existing}). Recovery: Name the lines to replace with `<@hash>` or `<@start,@end>` from a READ of the file; `<L,1,L,1>` inserts before line L, and `<1,-1>` replaces the whole file. |
+| `creation-batch-conflict` | 409 | Multiple EDIT operations attempted to create the same file. Recovery: Create the file with one EDIT before applying additional edits. |
+| `member-read-only` | 403 | The mounted member '*path*' is read-only. |
+| `project-root-required` | 400 | The workspace has no project root, so it cannot write files. |
+| `path-names-no-file` | 403 | The spelling '*path*' does not name a file: it is empty, or it names a directory. |
+| `path-occupied-by-nonmember` | 403 | A non-member file already occupies '*path*'. Recovery: Choose an unoccupied member path. |
+| `path-outside-workspace` | 403 | A symlink on '*path*' resolves outside the namespace. |
+| `binary-write-unsupported` | 415 | A text EDIT cannot author binary '*mimetype*'; COPY or MOVE the bytes instead. |
+| `file-create-excluded` | 403 | A members exclusion (`!_glob_`) covers '*path*'. Recovery: Remove or disable the excluding members definition, or choose another path. |
+| `file-create-gitignored` | 403 | Active Git policy ignores '*path*', and no members definition includes it. Recovery: Choose a Git-admitted path or add a members definition that includes it. |
+| `file-materialization-limit` | 413 | The file exceeds the materialization byte limit and is not read into the workspace. |
+| `entry-not-found` | 404 | No member of this workspace is at '*path*'. Recovery: Check the path with FIND. EDIT creates files; `members (add)` admits existing files with a `{"glob": "<path>"}` body. |
+
+§problems-exec **Execution Problems.** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `invalid-input-target` | 400 | SEND input addresses an execution, without a channel or scope. |
+| `input-unavailable` | 409 | This execution's input receiver is no longer enabled. |
+| `stream-not-found` | 404 | No execution exists at the requested address. |
+| `input-closed` | 410 | Execution input is closed. |
+
+§problems-entries **Entry scheme Problems (log, worker, entries).** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `read-target-required` | 400 | READ requires a log coordinate. Recovery: Provide one exact log coordinate. |
+| `coordinate-malformed` | 400 | The log coordinate '*path*' is malformed. Recovery: Use one exact loop/turn/sequence coordinate. |
+| `worker-target-required` | 400 | EDIT requires a worker:// target. Recovery: Provide the worker target. |
+| `binary-edit-unsupported` | 415 | The #*channel* channel is binary and cannot be edited. |
+| `message-not-implemented` | 501 | SEND does not deliver messages to *scheme* entries. Recovery: To reply, SEND to an Open Message address or omit the target. `SEND (worker://<name>)` sends a new message. |
+| `worker-entity-not-editable` | 400 | A worker entity is not an editable entry. Recovery: EDIT requires an entry path, such as worker:///example.md. |
+| `message-empty` | 400 | SEND has no message text or attachments. |
+| `scope-unsupported` | 400 | A worker SEND takes no scope. |
+
+§problems-functionality **Server and Functionality Problems.** Every code this family mints, its status, and the sentence that is its contract (placeholders in *italics* are filled at emission; a fixed recovery follows its detail).
+
+| code | status | contract |
+|---|---:|---|
+| `service-starting` | 503 | The PLURNK service owns this listener but has not admitted its client interface yet. |
+| `configuration-unsupported` | 400 | Environment discovery reads this installation's declared configuration; client configuration contributes nothing. |
+| `name-reserved` | 400 | '*alias*' is plurnk's own: PLURNK_* configuration and provider credential names never reach a subprocess. |
+| `value-invalid` | 400 | '*alias*' needs a string value. |
+| `env-invalid` | 400 | `env` must be an object of string values; '*name*' is not a name a shell can export. |
+| `query-required` | 400 | discover takes a path or a glob. Recovery: Supply `{ "query": "<path or glob>" }`. |
+| `headless` | 409 | The workspace has no project root, so there are no file members. Recovery: Open the workspace on a project root. |
+| `definition-invalid` | 400 | A members definition is { glob }: a gitignore-style pattern, `!glob` to exclude; a skill definition names an installable skill. |
+| `model-scope` | 403 | The model may not change membership here: the members scope is none. Recovery: `git add` the file so git tracks it, or ask the operator to add it (/members add) or raise PLURNK_SERVICE_MEMBERS_MODEL_SCOPE. |
+| `registry-unreachable` | 502 | Skills registry *url* could not be reached. |
+| `registry-rejected` | 502 | Skills registry *url* answered *status*. |
+| `registry-invalid` | 502 | Skills registry *url* returned no skills array. |
+| `discover-failed` | 502 | Agent Skills source '*source*' could not be listed: *cause*. |
+| `alias-mismatch` | 400 | Alias '*alias*' must equal the skill name '*name*'. |
+| `scope-not-installable` | 400 | Service-provided skills can be enabled or disabled; adding a skill requires project or global scope. Recovery: Add it with scope "global" or open a workspace rooted in a project. |
+| `source-required` | 400 | Adding '*alias*' requires the standard installer source that provides it. |
+| `uninstall-failed` | 502 | Agent Skill '*name*' could not be removed from its *scope* root: *cause*. |
+| `workspace-not-found` | 404 | Workspace *id* does not exist. |
+| `state-not-json` | 400 | Worker module state is not JSON-serializable. |
+| `workspace-busy` | 409 | Workspace *id* is running an operation or another capability change. Recovery: Settle the current operation and retry the capability change. |
+| `not-configured` | 503 | No provider is configured for this worker. |
+| `model-worker-required` | 404 | No model worker exists for prompt injection (or to fork). |
+| `name-conflict` | 409 | The worker name is taken. Recovery: Choose another worker name. |
+| `offset-channel-required` | 400 | Recovery: Select the channel to read from the offset. |
+| `target-invalid` | 400 | Recovery: Use a scheme://path target. |
+| `proposal-not-pending` | 409 | Recovery: Refresh pending proposals before resolving one. |
+| `loop-policy-invalid` | 400 | An unattended loop cannot hold a proposal for review: nobody is present to answer. Recovery: State proposals accept or reject, or attend the loop. |
+| `scope-cancelled` | 499 | The worker scope was cancelled: *reason*. |
+| `range-not-satisfiable` | 416 | `Range <0,-1>` starts at 0, which is not a line; lines are numbered from 1. Recovery: Write `<1,-1>` to trim every line of the body; `KILL (log:///…/READ)` with no scope retires the item. |
+| `registry-not-configured` | 501 | Skills registry search is disabled; PLURNK_SERVICE_SKILLS_REGISTRY_URL is empty. |
+| `install-failed` | 502 | Agent Skill '*name*' could not be installed from '*source*': *cause* (or the installer reported it but its SKILL.md does not exist). |
+| `skill-missing` | 404 | Agent Skill '*alias*' is not installed under its *scope* root, or is not provided by this service. |
+| `skill-invalid` | 422 | Agent Skill '*alias*' is not a valid standard skill: *cause*. |
+
+§pinned-wording-core **Pinned wording.** Verbatim sentences tests pin: each is contract, and a change here is a change of contract.
+
+| sentence | arises when |
+|---|---|
+| Nothing is in flight. Continuing. | a WAIT (or a premature terminal) with no live work ({§wait-obligation-matrix}) |
+| Completion deferred. Conclude with KILL alone. | a concluding KILL that carries other operations ({§kill-conclusion}) |
+| Context Token Budget Overflow: logTokensTotal exceeds logTokensMax; retained context cannot be admitted. | output admission over the retained-context ceiling |
+| This run is unattended: nobody is present to answer. | a capability that needs a present operator in an unattended loop ({§loop-attendance}) |
+| Worker name '*name*' must match `[A-Za-z0-9][A-Za-z0-9_-]{0,62}`. Recovery: Use 1–63 ASCII letters, digits, '_' or '-', starting with a letter or digit. | an invalid worker name |
+| Provide the client identifier. / Provide an absolute project path. / Use a positive integer limit. / prompt is not a non-empty string. | client input validation on the daemon's methods |
+| The stream was cancelled by KILL. | a stream terminal after KILL |
+| '*program*' exited with code *n*. | an execution's non-zero exit |
+| '*path*' is a directory, not a file; READ reads one file. Recovery: List its files with `FIND (_path_/)`, then READ one by its path. | READ of a directory |
+| The execution at ops://*worker*/*loop* has not concluded. | a bare READ of a running worker's result (425) |
+| The child provider failed. | a child's provider failure read back by its parent |
+| '*path*' exists on disk but is not a member of this workspace. Recovery: Admit it with `members (add)` and a `{"glob": "<path>"}` body. | a non-member on disk at the addressed path |

package/dist/build-info.json

@@ -1 +1 @@
-{"package":"@plurnk/plurnk-service","version":"1.22.0","revision":"bd903eeab041b3438ce3c29786895bf8aa70848f","dirty":false}
+{"package":"@plurnk/plurnk-service","version":"1.23.0","revision":"e00d5d950a3dbcffcfb030716253491edcdee430","dirty":false}

package/dist/content/body-preview.js

@@ -1,5 +1,5 @@
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
-import Knob from "../core/Knob.js";
+import { Knob } from "@plurnk/plurnk-meta";
 // {§body-projection} — one selector for ordinary packet previews and implicit
 // text acquisition. Explicit operation scopes never pass through this policy.
 export default class BodyPreview {

package/dist/content/body-preview.js.map

@@ -1 +1 @@
-{"version":3,"file":"body-preview.js","sourceRoot":"","sources":["../../src/content/body-preview.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,IAAI,MAAM,iBAAiB,CAAC;AAEnC,8EAA8E;AAC9E,8EAA8E;AAC9E,MAAM,CAAC,OAAO,OAAO,WAAW;IAC5B,gGAAgG;IAChG,6FAA6F;IAC7F,MAAM,CAAC,SAAS;QACZ,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,IAAY;QACtB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;QACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,WAAW,CAAC,YAAY,EAAE,CAAC;QACzC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAE,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QACjF,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC,MAAM,IAAI,QAAQ,GAAG,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;YACnF,2EAA2E;YAC3E,YAAY,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC;gBACjD,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAE,CAAC,CAAC,MAAM,CAAC;QACvE,CAAC;QACD,IAAI,YAAY,GAAG,IAAI,CAAC,MAAM,IAAI,YAAY,IAAI,OAAO,EAAE,CAAC;YACxD,MAAM,YAAY,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;YAC1G,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;gBACtB,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,YAAY,CAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;YACvF,CAAC;YACD,MAAM,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;YAC9D,IAAI,MAAM,KAAK,IAAI;gBAAE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;YACnG,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;QAC9H,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC;IAC9D,CAAC;CACJ"}
+{"version":3,"file":"body-preview.js","sourceRoot":"","sources":["../../src/content/body-preview.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C,8EAA8E;AAC9E,8EAA8E;AAC9E,MAAM,CAAC,OAAO,OAAO,WAAW;IAC5B,gGAAgG;IAChG,6FAA6F;IAC7F,MAAM,CAAC,SAAS;QACZ,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,IAAY;QACtB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;QACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,8BAA8B,EAAE,CAAC,CAAC,CAAC;QACjE,MAAM,WAAW,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,WAAW,CAAC,YAAY,EAAE,CAAC;QACzC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAE,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QACjF,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,KAAK,IAAI,QAAQ,GAAG,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC,MAAM,IAAI,QAAQ,GAAG,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;YACnF,2EAA2E;YAC3E,YAAY,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC;gBACjD,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAE,CAAC,CAAC,MAAM,CAAC;QACvE,CAAC;QACD,IAAI,YAAY,GAAG,IAAI,CAAC,MAAM,IAAI,YAAY,IAAI,OAAO,EAAE,CAAC;YACxD,MAAM,YAAY,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC;YAC1G,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;gBACtB,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,YAAY,CAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;YACvF,CAAC;YACD,MAAM,MAAM,GAAG,WAAW,CAAC,iBAAiB,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;YAC9D,IAAI,MAAM,KAAK,IAAI;gBAAE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;YACnG,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;QAC9H,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC;IAC9D,CAAC;CACJ"}

package/dist/content/edit-receipt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-receipt.d.ts","sourceRoot":"","sources":["../../src/content/edit-receipt.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EACR,uBAAuB,EACvB,gBAAgB,EAEhB,WAAW,EAEX,oBAAoB,EACpB,mCAAmC,EACtC,MAAM,wBAAwB,CAAC;AAMhC,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAED,YAAY,EACR,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,mCAAmC,GACtC,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;CAClC;AA+DD,eAAO,MAAM,gBAAgB,8FAA8F,CAAC;AAqD5H,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,WAuBlD,CAAC;AAEF,eAAO,MAAM,sBAAsB,UAAW,OAAO,KAAG,gBA4BvD,CAAC;AAEF,eAAO,MAAM,qBAAqB,UAAW,OAAO,KAAG,SAAS,cAAc,EAqC7E,CAAC;AAEF,eAAO,MAAM,kBAAkB,YAAa,gBAAgB,SAAS,MAAM,KAAG,WA0B7E,CAAC;AAyNF,eAAO,MAAM,WAAW,aACV,MAAM,WACP,MAAM,SACR,SAAS,WAAW,EAAE,gBACf,oBAAoB,aACvB,MAAM,KAClB,uBAoBF,CAAC;AAEF,eAAO,MAAM,0BAA0B,YAC1B,gBAAgB,eACZ,oBAAoB,GAAG,SAAS,KAC9C,gBAQF,CAAC;AAEF,eAAO,MAAM,0BAA0B,aACzB,MAAM,WACP,MAAM,YACL,gBAAgB,gBACZ,oBAAoB,aACvB,MAAM,KAClB,mCA4BF,CAAC"}
+{"version":3,"file":"edit-receipt.d.ts","sourceRoot":"","sources":["../../src/content/edit-receipt.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EACR,uBAAuB,EACvB,gBAAgB,EAEhB,WAAW,EAEX,oBAAoB,EACpB,mCAAmC,EACtC,MAAM,wBAAwB,CAAC;AAMhC,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACzB;AAED,YAAY,EACR,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,mCAAmC,GACtC,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;CAClC;AA+DD,eAAO,MAAM,gBAAgB,8FAA8F,CAAC;AAqD5H,eAAO,MAAM,iBAAiB,UAAW,OAAO,KAAG,WAuBlD,CAAC;AAEF,eAAO,MAAM,sBAAsB,UAAW,OAAO,KAAG,gBA4BvD,CAAC;AAEF,eAAO,MAAM,qBAAqB,UAAW,OAAO,KAAG,SAAS,cAAc,EAqC7E,CAAC;AAEF,eAAO,MAAM,kBAAkB,YAAa,gBAAgB,SAAS,MAAM,KAAG,WA0B7E,CAAC;AAgNF,eAAO,MAAM,WAAW,aACV,MAAM,WACP,MAAM,SACR,SAAS,WAAW,EAAE,gBACf,oBAAoB,aACvB,MAAM,KAClB,uBAoBF,CAAC;AAEF,eAAO,MAAM,0BAA0B,YAC1B,gBAAgB,eACZ,oBAAoB,GAAG,SAAS,KAC9C,gBAQF,CAAC;AAEF,eAAO,MAAM,0BAA0B,aACzB,MAAM,WACP,MAAM,YACL,gBAAgB,gBACZ,oBAAoB,aACvB,MAAM,KAClB,mCA4BF,CAAC"}

package/dist/content/edit-receipt.js

@@ -4,7 +4,7 @@ import { InvalidOperationResultError } from "@plurnk/plurnk-contracts";
 import LineMarkerOps from "./line-marker.js";
 import ScopeFormat from "./scope-format.js";
 import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
-import Knob from "../core/Knob.js";
+import { Knob } from "@plurnk/plurnk-meta";
 const receiptRecord = (value, label) => {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new InvalidOperationResultError(`${label} must be an object.`);
@@ -314,14 +314,7 @@ const codePointEffects = (original, updated, edits) => {
         return effect;
     });
 };
-const contextRadius = () => {
-    const raw = process.env.PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES;
-    const value = Number(raw);
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new Error(`PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES must be a non-negative safe integer, got ${JSON.stringify(raw)}`);
-    }
-    return value;
-};
+const contextRadius = () => Knob.integer("PLURNK_SERVICE_EDIT_RECEIPT_CONTEXT_LINES", 0);
 // {§edit-receipt-anchored-context} — with the resource's anchor identity, the resulting context
 // renders exactly as a READ does (`@xxxxx L:text`), so the next batch can cite the landed
 // lines by anchor without a READ. Without an identity it stays line-numbered.
@@ -332,7 +325,7 @@ const addContext = (effects, updated, identity) => {
     const width = LineAnchors.lineNumberWidth(updated);
     const prefix = (line) => anchors === null
         ? `${line}:`
-        : `${anchors[line - 1]} ${String(line).padStart(width)}:`;
+        : `${String(line).padStart(width)}<${anchors[line - 1]}>`;
     return effects.map((effect) => {
         const selected = new Set();
         const addRange = (first, last) => {