@plurnk/plurnk-contracts 1.20.0 → 1.21.0

package/SPEC.md

@@ -267,58 +267,52 @@ input
 `````
 
 §section-boundary Every statement is one backtick block. Its header occupies one
-physical line: a fence of at least three backticks ({§operation-fences}), an optional numeric delimiter
-({§numeric-delimiter}), then the name and its slots. A closer is shown by
+physical line: a fence of at least three backticks ({§operation-fences}), then the name
+and its slots. A closer is shown by
 convention and never demanded ({§fence-closer}, {§closer-fallback}). There are no
 operation suffixes or heading levels. Complete nested matches take precedence
 over local recovery ({§balanced-fences}).
 
-§fence-closer A block opened with N backticks and delimiter D (its digits, possibly
-none) closes at the first unclaimed line made of at least N backticks,
-exactly D, and nothing else but horizontal whitespace. Count follows CommonMark: a
-shorter fence inside the body is body; an equal or longer bare fence closes a bare
-block unless it closes a balanced nested block ({§balanced-fences}). The delimiter
-compares exactly: a bare fence never closes a delimited block,
-and a delimited fence never closes a bare one. The compact one-line form closes on
-its heading line after the modifiers under the same rule.
+§fence-closer A block opened with N backticks closes at the first unclaimed line made of
+at least N backticks and nothing else but horizontal whitespace, within three spaces of
+its line start ({§indented-fences}). Count follows CommonMark: a shorter fence inside the
+body is body; an equal or longer bare fence closes the block unless {§balanced-fences}
+claims it for a nested block. The compact one-line form closes on its heading line after
+the modifiers under the same rule.
 
 §balanced-fences A complete nested interpretation takes precedence over missing-closer
-recovery. Within an undelimited body, line-leading labeled fences open literal
-blocks; their matching closers close the innermost block first. The enclosing
-block and its nested blocks must all close, with matching widths and delimiters
-under {§fence-closer}. Equal opener/closer totals alone are insufficient. A complete
-inline block is already closed; a numerically delimited block is opaque until its
-own closer. Preserve every nested body byte, including apparent OPs and known
-executors, without dispatching them. If no complete enclosing interpretation exists,
-retain {§fence-heading-in-body} and {§closer-fallback}. These rules apply equally to
-model programs, stored programs, client operations, and reasoning quotations.
-
-§numeric-delimiter Digits between the opening backticks and the name (an opener
-carrying `42EDIT (x)`) identify the block, and only a fence carrying `42` closes it.
-This explicitly protects bare fences and headings, including incomplete examples.
-The delimiter is syntax, never AST or persistence
-state; `PlurnkParser.frame` chooses one when the body it wraps holds a heading line
-of four or more backticks ({§statement-rendering}).
-
-§operation-fences **Accept three or more backticks; teach and render four.** A top-level,
-unindented fence of three or more backticks naming a native operation or registered executor
-opens that operation. A three-backtick opener ran, and one warning-severity receipt follows its
-statement — `` `KILL` ran with three backticks; the taught fence is four. `` — because three is
-the habit and four is the taught form: a four-backtick fence holds any body, including
-three-backtick code. Indentation and enclosing quotations remain inert ({§quotation}); shorter
-fences inside a body are never promoted to operations ({§fence-heading-in-body}). `plurnk.md`
-teaches exactly four; other accepted widths are not taught. Every producer of a statement — the
-parser, a client composing `/look`, a client's tab-completion — writes `PLURNK_FENCE` rather than
-its own literal (plurnk/plurnk#92).
+recovery. Within a body, line-leading labeled fences open literal blocks. A bare fence
+closes the innermost open block of exactly its width, otherwise the outermost open block
+narrower than it; the narrower blocks it steps over are literal body, and a wider or
+differently fenced block inside stops it. So a wider outer fence holds any narrower body,
+finished or not, and equal widths nest when every inner block closes. The enclosing block
+and its nested blocks must all
+close under {§fence-closer}; equal opener/closer totals alone are insufficient, and a
+complete inline block is already closed. Preserve every nested body byte, including
+apparent OPs and known executors, without dispatching them. If no complete enclosing
+interpretation exists, retain {§fence-heading-in-body} and {§closer-fallback}. These
+rules apply equally to model programs, stored programs, client operations, and
+reasoning quotations.
+
+§operation-fences **Accept three or more backticks; teach and render three.** A line-start fence
+of three or more backticks naming a native operation or registered executor opens that
+operation ({§indented-fences}), and no width draws a receipt. Three is the taught form and the
+rendered form; a wider fence is the same statement, and it is how a body holding fence lines of
+its own is held: an opener wider than any of them ({§balanced-fences}). Enclosing quotations
+remain inert ({§quotation}), and a fence inside an intact block is never promoted to an
+operation ({§fence-heading-in-body}). `plurnk.md` teaches exactly three and shows the wider
+fence only as the nesting form. Every producer of a statement — the parser, a client composing
+`/look`, a client's tab-completion — writes `PLURNK_FENCE` rather than its own literal
+(plurnk/plurnk#92).
 
 §naked-operation **A native operation's name alone on a line opens it without a fence.** A
 column-zero line outside any block that is exactly an operation's name, with nothing but
-horizontal whitespace after it, opens that operation as if it were fenced with the taught four
+horizontal whitespace after it, opens that operation as if it were fenced with the taught three
 backticks: no target, no modifiers, and a body that runs to a line that is exactly the name
-again, to the next four-backtick heading, or to the end of the turn. Narrower fences inside are
-body, as inside any four-backtick block; the block expects no closer, so its body is never cut
+again, to the next heading ({§fence-heading-in-body}), or to the end of the turn. A fence inside
+naming nothing known is body; the block expects no closer, so its body is never cut
 back ({§closer-fallback}). It runs, and one warning-severity receipt follows its statement —
-`` `KILL` opened with no fence; the taught form is four backticks. `` One rule for every native
+`` `KILL` opened with no fence; the taught form is three backticks. `` One rule for every native
 operation: a naked `WAIT` parks, a naked `NOTE` takes its text, a naked `READ` meets the ordinary
 missing-target refusal. Only the bare name qualifies; a name with anything else on its line is
 the unfenced form and still refuses ({§unfenced-operation}), executors are runtimes rather than
@@ -327,54 +321,49 @@ operations, and reasoning is never read this way. Measured before it was accepte
 three loops lost to the refusal at the strike threshold.
 
 §fence-heading-in-body Outside a complete nested block ({§balanced-fences}), a fence
-line of three or more backticks, optional digits, and a name that is a native operation
-or a known executor is a heading. Inside an open block its width must also reach the block's
-opening width, capped at four: a three-backtick heading ends only a three-backtick block, and a
-four-backtick heading ends any block. A qualifying heading ends that block without closing it
-({§closer-fallback}) and opens the next statement. Fence lines of fewer than three
+line of three or more backticks and a name that is a native operation or a known executor
+is a heading. Inside an open block of any width it ends that block without closing it
+({§closer-fallback}) and opens the next statement: a wider fence holds the narrower headings
+inside it only while it closes ({§balanced-fences}). Fence lines of fewer than three
 backticks are never headings ({§operation-fences}). Known executors are `sh` plus what
-the host names in `ParseOptions.executors`. Consequences: a three-backtick executor line inside
-a four-backtick block is body, a closer glued to the next opener (eight backticks then `READ`)
-can never swallow an unbalanced turn, and a numeric delimiter preserves quoted headings even
-when their own fences are incomplete.
+the host names in `ParseOptions.executors`. Consequences: a closer glued to the next opener
+(six backticks then `READ`) can never swallow an unbalanced turn, and no unclosed block, however
+wide, swallows the operations after it.
 
 §closer-fallback A block that ends at a heading or at the end of the input has no
-closer of its own. Its body is cut back to its last bare fence line (any count,
-optional digits), which is the closer the author meant, and one terminating line
+closer of its own. Its body is cut back to its last bare fence line (any count, within
+three spaces of its line start), which is the closer the author meant, and one terminating line
 ending goes with it; when no bare fence line exists the body is the whole span less
 one terminating line ending. This carries no diagnostic: a missing closer is never
 an admission failure, and {§unparsed-tail-boundary} is not involved.
 
-`plurnk.md` teaches that operations *"begin and end with exactly four backticks, both
-immediately after a newline"*; this recovery is not taught. It sits at the quiet end of
+`plurnk.md` shows every operation closed; this recovery is not taught. It sits at the quiet end of
 the scale {§response-text-note} describes: the model opened the operation correctly
 and only failed to close it, so the harness reads what it plainly meant and says nothing.
 A departure that small earns no correction — telling a model its closer was missing costs
 a sentence in every future packet to fix something already fixed.
 
 §fence-boundary Balanced nesting is resolved before local recovery. Otherwise,
-fences are read by count and delimiter, except for the heading rule above:
+fences are read by count, except for the heading rule above:
 
 | Fence encountered inside a body | Meaning |
 |---|---|
 | Part of a complete nested block | Literal body, including its openers and closers |
+| Indented four spaces or more, or by a tab | Body ({§indented-fences}) |
 | Fewer backticks than the block's own | Body |
-| At least the block's backticks, bare, block undelimited | The block's closer |
-| At least the block's backticks carrying the block's delimiter | The block's closer |
-| At least the block's backticks with any other delimiter | Body |
-| At least the block's backticks, capped at four, naming a native operation or known executor | A heading: ends the block, opens the next statement |
-
-§indented-fences Leading horizontal whitespace before a CLOSER is not part of the fence: an
-indented closer, heading-that-ends-a-block, or closer fallback still closes, and a body keeps its
-own lines' indentation. An OPENER is different: an operation's backticks follow a newline
-directly (operator, 2026-09-18), so an indented fence opens a quotation, never an operation —
-CommonMark reads an indented block as code, and `plurnk.md` shows its own examples that way. This
-reverses the 2026-09-12 tolerance (then measured at five to ten percent of emissions on
-GLM-5.3-flash; 2.8% of that lane's emissions today). An offset fence is prose and draws no advisory:
-`plurnk.md` instructs the model to offset any example it does not intend to execute, so the form
-is correct by construction and there is no mistake to report (operator, 2026-09-21). The parser
-presumes nothing about why a fence is offset. Outside an operation, that quotation is
-response text under {§response-text}; inside a body, it stays literal body content.
+| At least the block's backticks, bare | The block's closer |
+| Three or more backticks naming a native operation or known executor | A heading: ends the block, opens the next statement |
+
+§indented-fences **CommonMark's indentation, everywhere.** A fence line may follow at most three
+spaces; four or more, or a tab, make it indented code. That one rule reads every fence purpose the
+same way: an opener within three spaces opens, a closer within three closes, a heading within
+three ends an unclosed block, and a body keeps its own lines' indentation. A fence indented
+further is literal wherever it stands — prose outside a block, body inside one — and draws no
+advisory: `plurnk.md` shows its own examples offset, so an offset fence is the page's own form
+and there is no mistake to report (operator, 2026-09-21). The parser presumes nothing about why a fence is offset. This one
+rule replaces the column-zero opener (operator, 2026-09-18) and the lenient closer beside it
+(operator, 2026-09-23). Outside an operation, offset text is response text under
+{§response-text}; inside a body, it stays literal body content.
 
 §inline-chain A closer on a heading line, or on a body's closing line, may be
 followed on that same line by the next opener; the closer still closes, and the
@@ -386,7 +375,7 @@ text there is the heading's own and is read under {§transparent-inline-closer}.
 closing fence on a heading line followed by more of that heading — a `<scope>`, an
 `[option block]`, a `<!-- aside -->`, or a naked matcher — does not end the reading: the
 heading keeps taking its slots under {§trailing-slots} and {§naked-pattern}, exactly as though
-the closer were absent, so ````` ````READ (a.md)```` ````` `<1,2>` is the same operation as `READ (a.md) <1,2>`.
+the closer were absent, so ```` ```READ (a.md)``` ```` `<1,2>` is the same operation as `READ (a.md) <1,2>`.
 The closer is still a closer: the block ends with that physical line and never reaches down for
 the next operation, which is what a bare heading carrying a matcher would do. A closer followed
 by the next opener is {§inline-chain}, and by nothing is the ordinary {§fence-closer}. There is
@@ -413,7 +402,7 @@ identity; absent `node`, the shorthand grants no executable capability.
 line: prose, then heading after heading with no line ending anywhere. Two
 rules absorb it. The next opener on a heading's own line, after the heading's
 slots, ends that heading's block bodyless and opens ({§empty-section}), so
-`````EDIT (a.rs) <60,66> <!-- drop --> ````EDIT (b.rs) <31,38>` is two scoped
+````EDIT (a.rs) <60,66> <!-- drop --> ```EDIT (b.rs) <31,38>` is two scoped
 deletions. Literal inline bodies follow {§heading-inline-body}.
 
 §anchor-digits In a text scope, `@` followed by one to four digits cannot be a
@@ -425,28 +414,33 @@ line takes the rest of the line as the aside, with one warning-severity advisory
 A closed aside followed by more text is unchanged.
 
 §quotation **A fence that opens no operation quotes.** Outside a body, a line-start fence that
-is not an operation heading — unlabeled, tagged like a code block (`ts`, `json`), indented,
-or naming nothing registered — opens a
+is not an operation heading — unlabeled, tagged like a code block (`ts`, `json`), or naming
+nothing registered — opens a
 quotation that runs to its matching closer (same character, width at least the opener's) or to
 the end of the input. Everything inside is data: no operation runs there and native tool-call
 markup is not read ({§native-tool-calls}). An operation fenced inside an unlabeled code block
-draws one warning that it was shown, not run; a labeled block is an example by declaration, and
-nothing else inside draws an advisory.
-So a model may show plurnk's own operations in an answer. Three exceptions keep programs whole:
+draws one warning that it was shown, not run. An unlabeled fence whose first line is an operation
+heading is the operation with its tag forgotten, and draws one warning — `` `READ` inside an
+unlabeled fence did not run; the tag is the operation. `` — a native name alone or with a slot, an
+executor's name with its operand (of 2,308 naked fences in 12,797 recorded emissions, 51 open that
+way and 2,238 hold code or quoted output, which is why the fence itself draws nothing). A labeled
+block is an example by declaration, and nothing else inside draws an advisory.
+So a model may show plurnk's own operations in an answer. Two exceptions keep programs whole:
 CommonMark's own rule that a backtick opener's line carries no further backtick, so
-```` ```READ (x)``` ```` is inline code and quotes nothing after it; a bare fence directly under a
-line carrying a fence run, which is an orphaned closer and quotes nothing; and a tag that is a
-missed operation — an unknown name at operation width — which still draws one warning; an
-offset example draws none. Quotation outside an operation is
+```` ```READ (x)``` ```` is inline code and quotes nothing after it; and a bare fence directly under
+a line carrying a fence run, which is an orphaned closer and quotes nothing. An unknown tag at
+any width is a code block and draws nothing, unless its line carries a target slot, `(…)`: that
+is an operation the model missed by its tag, and it draws one warning — `` `OP` is not an
+operation or a known executor here. `` An offset example draws nothing either
+({§indented-fences}). Quotation outside an operation is
 response text under {§response-text}, not an executable program or a completion envelope.
 
-`plurnk.md` teaches exactly one way to make an example inert — *"tab offset any example OP
-you do not intend to execute"* — and the other quoting fences are
-not taught: a tilde fence, an unlabeled fence and an unknown three-backtick tag all quote
-too. Each is a shape a model reaches for from ordinary Markdown rather than from this
+`plurnk.md` names the tab offset as the form for an example, in the aside of its nesting
+example, and shows its own examples offset; the other quoting fences are untaught: a tilde
+fence, an unlabeled fence and an unknown tag all quote. Each is a shape a model reaches for from ordinary Markdown rather than from this
 teaching, so honouring it protects an example the model already believed was safe
-({§response-text-note} places the scale). The taught offset remains the one form a
-model should rely on, because it is the only one that survives every fence style.
+({§response-text-note} places the scale). The offset is the one form that survives every
+fence style.
 
 §interstitial-fence Superseded by {§quotation}: an unlabeled fence no longer opens nothing, it
 quotes. (It in turn replaced the retired unlabeled-fence SEND of the fences chapter, whose
@@ -471,15 +465,24 @@ reading, with no diagnostic and no teaching (#758):
 Tokens keep their source positions; only their order in the stream changes.
 
 §native-tool-calls An emission that yields no operation may be a model's native
-tool-call markup (DeepSeek's `<｜｜DSML｜｜ calls>` block) naming a plurnk operation or
-a known executor. Each `invoke` is read as that operation's canonical fence:
-`path`/`target` fill the target, `scope`/`range`/`lines` the scope, `pattern` a
-matcher option, `aside` the aside, and `body`/`content`/`command` or plain lines
-inside the invoke the body; plurnk slots written after the invoke name are kept.
-Each block keeps its line count, so statement positions still name the source
-line. An invoke with an unknown name or parameter leaves the whole emission as it
-was. An emission that already yields an operation is never rewritten. No
-diagnostic, notice or teaching mentions the reading (#760).
+tool-call markup naming a plurnk operation or a known executor, and every popular
+family is read the same way: DeepSeek's `<｜｜DSML｜｜ calls>` and Anthropic-style
+`<function_calls>` blocks of `invoke` elements with `parameter` children; the
+`<tool_call>` family as `<function=NAME>` with `<parameter=key>` children (Qwen,
+MiMo), as a JSON object with `name` and `arguments` (Hermes and kin), or as a name
+followed by `<arg_key>`/`<arg_value>` pairs (GLM); a bare `<function=NAME>` element
+(Llama); Mistral's `[TOOL_CALLS]` JSON array; Llama's `<|python_tag|>` JSON object; and
+Kimi's `<|tool_call_begin|>` sections. Each call is read as that operation's
+canonical fence: `path`/`target`/`file_path`/`file`/`resource`/`uri` fill the target,
+`scope`/`range`/`lines` the scope, as do `start`/`end` written apart and `offset`/`limit`
+(a first line and a count), `pattern`/`regex`/`query` a matcher option, `aside`
+the aside, and `body`/`content`/`command`/`text`/`input` or plain text inside the
+call the body; plurnk slots written after the name are kept, a trailing scope's own
+bracket may close the tag. A block keeps its line count where its lines allow, so
+statement positions name the source line; an inline block grows to its fences.
+A call with an unknown name or parameter leaves the whole emission as it was. An
+emission that already yields an operation is never rewritten. No diagnostic, notice
+or teaching mentions the reading (#760).
 
 §empty-section Both the compact bodyless form and an empty multiline block
 normalize optional bodies to null. Closing fences are conventional, never required
@@ -489,10 +492,9 @@ normalize optional bodies to null. Closing fences are conventional, never requir
 runtime fences from the shared AST, with one blank line between operations.
 Every closing fence occupies its own line, including bodyless operations;
 inline fences remain accepted input, not generated examples.
-It chooses at least four backticks and more than any run within the body, and a
-numeric delimiter whenever the body holds a heading line of four or more backticks
-({§fence-heading-in-body}), preserving body bytes on reparse. Fence length and
-delimiter are syntax, not AST or persistence state. Core-authored programs use
+It chooses at least three backticks and more than any run within the body
+({§balanced-fences}), preserving body bytes on reparse. Fence length is syntax,
+not AST or persistence state. Core-authored programs use
 this serializer and the ordinary admission parser. Rendering preserves a matcher
 beside owner metadata, not only a matcher carried inside its `pattern` option.
 
@@ -1090,7 +1092,8 @@ under {§turn-ops-log-curation}; body bytes and source positions are unchanged.
 The model-turn entry point returns each non-whitespace text span outside operation
 regions as an ordered `text` item with its exact content and source position.
 Quoted blocks remain literal text, including every nested operation-looking line.
-Operation bodies, asides and malformed operation regions are not response text;
+Operation bodies, asides, malformed operation regions and unfenced operation lines
+({§unfenced-operation}) are not response text;
 nothing at or beyond a lost boundary is recovered as text. The statement and client
 tiers ignore outside text. Core alone owns filing it as a NOTE ({§response-text-note})
 and no-operation strikes ({§empty-turn}); parsing never infers delivery or completion
@@ -1099,12 +1102,17 @@ intent.
 §unfenced-operation **An operation written without its fence did not run, and the parser says
 so.** An outside-text line that opens at column zero with an operation's name and anything else
 — `KILL The answer…`, `READ (a.md)`, `KILL (notes.md)` — draws one warning: `` `KILL` has no
-fence, so it did not run. `` The line stays response text ({§response-text}); the bare name alone
-opens the operation instead ({§naked-operation}), and quoted blocks, offset lines, names inside a
-sentence and executor tags draw nothing. The model that wrote it believes it ran: filed as a NOTE
-({§response-text-note}), an unfenced KILL read back as an answer already given, and the model
-repeated it until the cycle detector ended the loop (`demo-overflow-recovery-AC4Ul4`; the same
-shape defeated SEND recovery and a count of invalid characters; operator, 2026-09-22).
+fence, so it did not run. `` The line is not response text ({§response-text}): it is neither filed as
+a NOTE nor echoed into the next packet, and the exact emission remains at `ops://` (operator,
+2026-09-23); the bare name alone
+opens the operation instead ({§naked-operation}). A registered executor's name followed by an
+operand slot — `gitea (list_issues)`, `sh(build.sh)` — draws the same warning under the executor's
+own spelling; quoted blocks, offset lines and names inside a sentence draw nothing, since `sh`,
+`env` and `members` are ordinary words. The model that wrote it believes it ran: while the line was
+still filed as a NOTE ({§response-text-note}), an unfenced KILL read back as an answer already given,
+and the model repeated it until the cycle detector ended the loop (`demo-overflow-recovery-AC4Ul4`;
+the same shape defeated SEND recovery and a count of invalid characters; operator, 2026-09-22). The
+warning and the exclusion together end that echo.
 
 §recorded-emissions **The parser is regressed against emissions models actually produced,
 not fixtures we wrote.** `test/fixtures/recorded-emissions.jsonl` holds one real exemplar
@@ -1540,6 +1548,14 @@ diagnostics are:
   diagnostic, with or without flags, without assuming what the extra text was
   intended to represent. Invalid patterns or flags retain the native
   regex failure; no branch silently removes or executes trailing content.
+- §unclosed-regex **A regex that never closes.** A `/pattern` matcher with no closing
+  `/` is read as the whole pattern with no flags, with one warning-severity advisory
+  naming the closing slash and the flag position. The reading is deterministic because
+  the heading's own boundaries bound it ({§naked-pattern}: the matcher runs to the end
+  of the heading, and an aside is lexed apart from it). A bare `/` with nothing after
+  it has no pattern to read and is refused as `invalid-operation-syntax` naming what
+  is missing. A matcher with a second unescaped `/` is not unclosed: it is
+  `/pattern/flags`, and invalid flags keep their native failure with the escape hint.
 - §naked-pattern **The matcher rides the heading bare.** After the path, and any
   scope or option block, the rest of a FIND, READ or KILL heading line is the
   matcher, in whichever dialect its first characters claim
@@ -1679,6 +1695,6 @@ runtime constructs this; the parser provides the fields):
     "column": 12,
     "source": "parser",
     "severity": "error",
-    "message": "READ block opened at line 1 but was not closed with 4 backticks"
+    "message": "READ block opened at line 1 but was not closed with 3 backticks"
 }
 ```

package/dist/src/types.d.ts

@@ -2,7 +2,7 @@ export * from "./types.generated.ts";
 import type { ClientStatement, LoopPolicy, Position, PlurnkStatement, ProviderRequestAccounting, ReasoningPolicy } from "./types.generated.ts";
 import type PlurnkParseError from "./PlurnkParseError.ts";
 export declare const PLURNK_OPS: readonly ["FIND", "READ", "EDIT", "COPY", "MOVE", "SEND", "BARE", "WORK", "FORK", "KILL", "NOTE", "WAIT"];
-export declare const PLURNK_FENCE = "````";
+export declare const PLURNK_FENCE = "```";
 export type PlurnkOp = (typeof PLURNK_OPS)[number];
 export type RuntimeTag = Lowercase<string>;
 export declare const RUNTIME_TAG: RegExp;

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,cAAc,sBAAsB,CAAC;AAKrC,OAAO,KAAK,EACR,eAAe,EACf,UAAU,EACV,QAAQ,EACR,eAAe,EACf,yBAAyB,EACzB,eAAe,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAC;AAM1D,eAAO,MAAM,UAAU,YACnB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC9E,MAAM,EAAE,MAAM,CACR,CAAC;AAGX,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAKnD,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAC3C,eAAO,MAAM,WAAW,QAAwB,CAAC;AACjD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAmC,CAAC;AACrF,eAAO,MAAM,aAAa,OAAQ,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,EAAE,IAAI,UAAyF,CAAC;AAC9J,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,aAAa,CAAC,KAAG,SAAS,IAAI,OAAO,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,UAAU,CAAA;CAAE,CAChH,CAAC;AAG3B,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,eAAe,GAAG,eAAe,aAAa,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,GAAG,UACT,CAAC;AAK5G,MAAM,WAAW,uBAAuB;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,yBAAyB,GAAG,CACpC,UAAU,EAAE,yBAAyB,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,MAAM,MAAM,uBAAuB,GAAG,CAClC,QAAQ,EAAE,uBAAuB,KAChC,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAIxC,eAAO,MAAM,kBAAkB,EAE1B,SAAS,eAAe,EAAE,CAAC;AAGhC,eAAO,MAAM,iBAAiB,EAEzB,SAAS,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;AAGxC,eAAO,MAAM,WAAW,QAAqC,CAAC;AAG9D,eAAO,MAAM,UAAU,QAAiE,CAAC;AAGzF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,QAAQ,CAAyC,CAAC;AAI1F,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAI9B,MAAM,MAAM,SAAS,CAAC,CAAC,GAAG,eAAe,IACnC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,CAAC,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,eAAe,IAAI;IAC3C,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,cAAc,sBAAsB,CAAC;AAKrC,OAAO,KAAK,EACR,eAAe,EACf,UAAU,EACV,QAAQ,EACR,eAAe,EACf,yBAAyB,EACzB,eAAe,EAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAC;AAM1D,eAAO,MAAM,UAAU,YACnB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC9E,MAAM,EAAE,MAAM,CACR,CAAC;AAGX,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAKnD,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAC3C,eAAO,MAAM,WAAW,QAAwB,CAAC;AACjD,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAmC,CAAC;AACrF,eAAO,MAAM,aAAa,OAAQ,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,EAAE,IAAI,UAAyF,CAAC;AAC9J,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,aAAa,CAAC,KAAG,SAAS,IAAI,OAAO,CAAC,CAAC,EAAE;IAAE,OAAO,EAAE,UAAU,CAAA;CAAE,CAChH,CAAC;AAG3B,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,eAAe,GAAG,eAAe,aAAa,CAAC,KAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,GAAG,UACT,CAAC;AAK5G,MAAM,WAAW,uBAAuB;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,yBAAyB,GAAG,CACpC,UAAU,EAAE,yBAAyB,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,MAAM,MAAM,uBAAuB,GAAG,CAClC,QAAQ,EAAE,uBAAuB,KAChC,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAIxC,eAAO,MAAM,kBAAkB,EAE1B,SAAS,eAAe,EAAE,CAAC;AAGhC,eAAO,MAAM,iBAAiB,EAEzB,SAAS,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;AAGxC,eAAO,MAAM,WAAW,QAAqC,CAAC;AAG9D,eAAO,MAAM,UAAU,QAAiE,CAAC;AAGzF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,QAAQ,CAAyC,CAAC;AAI1F,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAI9B,MAAM,MAAM,SAAS,CAAC,CAAC,GAAG,eAAe,IACnC;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,CAAC,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,eAAe,IAAI;IAC3C,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD,CAAC"}

package/dist/src/types.js

@@ -12,7 +12,7 @@ export const PLURNK_OPS = [
     "NOTE", "WAIT",
 ];
 // {§operation-fences} — canonical teaching/rendering width; ingestion also accepts three.
-export const PLURNK_FENCE = "````";
+export const PLURNK_FENCE = "```";
 export const RUNTIME_TAG = /^[a-z][a-z0-9+.-]*$/;
 export const INTERNAL_ROW_OPS = new Set(["extension", "error"]);
 export const isExecutionOp = (op) => typeof op === "string" && !INTERNAL_ROW_OPS.has(op) && RUNTIME_TAG.test(op);

package/dist/src/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,oFAAoF;AACpF,cAAc,sBAAsB,CAAC;AAErC,OAAO,gBAAgB,MAAM,2BAA2B,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAC/E,OAAO,qBAAqB,MAAM,gCAAgC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACzF,OAAO,qBAAqB,MAAM,gCAAgC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAWzF,0EAA0E;AAC1E,6CAA6C;AAE7C,4FAA4F;AAC5F,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAC9E,MAAM,EAAE,MAAM;CACR,CAAC;AAEX,0FAA0F;AAC1F,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC;AAQnC,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC;AACjD,MAAM,CAAC,MAAM,gBAAgB,GAAwB,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;AACrF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,EAA6B,EAAoB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC9J,MAAM,CAAC,MAAM,WAAW,GAAG,CAAiD,SAAY,EAAoD,EAAE,CAC1I,SAAS,IAAI,SAAS,CAAC;AAC3B,6FAA6F;AAC7F,kBAAkB;AAClB,MAAM,CAAC,MAAM,SAAS,GAAG,CAA8C,SAAY,EAA4C,EAAE,CAC7H,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,CAA6C,CAAC;AAkB5G,2EAA2E;AAC3E,uEAAuE;AACvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAC3C,qBAAqB,CAAC,IAAyB,CACpB,CAAC;AAEhC,oEAAoE;AACpE,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAC1C,gBAAgB,CAAC,UAAU,CAAC,SAAS,CAAC,IAAiC,CACpC,CAAC;AAExC,wFAAwF;AACxF,MAAM,CAAC,MAAM,WAAW,GAAG,kCAAkC,CAAC;AAE9D,mFAAmF;AACnF,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,qBAAqB,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAEzF,sFAAsF;AACtF,MAAM,CAAC,MAAM,gBAAgB,GAAuB,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,oFAAoF;AACpF,cAAc,sBAAsB,CAAC;AAErC,OAAO,gBAAgB,MAAM,2BAA2B,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAC/E,OAAO,qBAAqB,MAAM,gCAAgC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AACzF,OAAO,qBAAqB,MAAM,gCAAgC,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAWzF,0EAA0E;AAC1E,6CAA6C;AAE7C,4FAA4F;AAC5F,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAC9E,MAAM,EAAE,MAAM;CACR,CAAC;AAEX,0FAA0F;AAC1F,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,CAAC;AAQlC,MAAM,CAAC,MAAM,WAAW,GAAG,qBAAqB,CAAC;AACjD,MAAM,CAAC,MAAM,gBAAgB,GAAwB,IAAI,GAAG,CAAC,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;AACrF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,EAA6B,EAAoB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC9J,MAAM,CAAC,MAAM,WAAW,GAAG,CAAiD,SAAY,EAAoD,EAAE,CAC1I,SAAS,IAAI,SAAS,CAAC;AAC3B,6FAA6F;AAC7F,kBAAkB;AAClB,MAAM,CAAC,MAAM,SAAS,GAAG,CAA8C,SAAY,EAA4C,EAAE,CAC7H,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,CAA6C,CAAC;AAkB5G,2EAA2E;AAC3E,uEAAuE;AACvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAC3C,qBAAqB,CAAC,IAAyB,CACpB,CAAC;AAEhC,oEAAoE;AACpE,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAC1C,gBAAgB,CAAC,UAAU,CAAC,SAAS,CAAC,IAAiC,CACpC,CAAC;AAExC,wFAAwF;AACxF,MAAM,CAAC,MAAM,WAAW,GAAG,kCAAkC,CAAC;AAE9D,mFAAmF;AACnF,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC,qBAAqB,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAEzF,sFAAsF;AACtF,MAAM,CAAC,MAAM,gBAAgB,GAAuB,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plurnk/plurnk-contracts",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "description": "Canonical PLURNK language contract, schemas, generated types, and runtime-neutral wire contracts",
   "keywords": [
     "plurnk",

package/plurnk.md

@@ -1,95 +1,81 @@
 # Plurnk Harness
 
-Pattern Lookup Universal Resource NetworK: find anything by pattern, read it by address, change it by operation.
-
 ## Plurnk OP Syntax
 
-    ````OP (path)? <scope|range>? [metadata]? pattern? <!-- aside -->?
+    ```OP (path)? <scope|range>? [metadata]? pattern? <!-- aside -->?
     body?
-    ````
+    ```
 
 > [!IMPORTANT]
-> YOU MUST use valid Plurnk OPs.
-
-> [!TIP]
-> YOU SHOULD tab offset any example OP you do not intend to execute.
-
-* `[metadata]`: optional one-line special configuration.
-* `<!-- aside -->`: optional terse explanation.
-* Parameters and the aside stay on the OP line; the body starts on the next.
+> YOU MUST ONLY use valid Plurnk OPs, with all parameters and the optional terse aside on the fenced OP line.
 
 ## Core Plurnk OPs
 
-* NOTE: Reasoning scratchpad for remembering model conclusions, decisions, and facts.
+* NOTE: Reasoning scratchpad for recording conclusions, decisions, and facts.
 * FIND: List matching paths, or the match locations inside one path.
 * READ: Read files, entries, streams, or only the lines a pattern selects.
 * EDIT: Create a file or entry; replace existing text by scope or by pattern.
 * COPY: (path) <scope>? (path) <scope>? - Copy files, entries, streams, or text regions.
 * MOVE: (path) <scope>? (path) <scope>? - Move files, entries, streams, or text regions.
-* KILL: End things — delete an entry, stop a process, retire log items, or end the loop with final deliverable response.
+* KILL: End things — delete an entry, stop a process, retire log items, or end the loop.
 * WORK: Deploy a child worker (fresh log).
 * FORK: Deploy a forked worker (forked log).
-* BARE: Deploy an isolated inference query (no log or tools).
+* BARE: Deploy an isolated inference on the fence body (no log or tools).
 * WAIT: Yield until the next wake: a child worker's result or a stream's end.
 * SEND: Message endpoints or workers.
 
 ## Workflow Management
 
 > [!IMPORTANT]
-> The loop continues until KILLed with a turn that contains ONLY a parameterless KILL (with optional final deliverable response in body).
-
-> [!WARNING]
-> YOU MAY NOT end the loop with KILL before all other OPs, child workers, and streams are resolved and reviewed.
+> YOU MUST deliver the final response as a turn with ONLY a single parameterless KILL with the response in the body:
 
-    ````KILL
-    The answer is **42**.
-    ````
-
-> [!TIP]
-> Free text, NOTEs, and other messages are not the final deliverable response.
+    ```KILL
+    This is an example final deliverable response. It's alone. All child workers and streams are resolved and reviewed.
+    ```
 
 ## Workspace Navigation
 
-    ````FIND (src/**/*.ts) /TODO/ <!-- paths with matches -->
-    ````
+    ```FIND (src/**/*.ts) /TODO/ <!-- paths with matches -->
+    ```
 
-    ````READ (belfry.md) /\bbats?\b/i <!-- only the lines matching "bat" or "bats" -->
-    ````
+    ```READ (belfry.md) /\bbats?\b/i <!-- only the lines matching "bat" or "bats" -->
+    ```
 
-* `(path)` may be a glob, permitting bulk operations.
-* Log item paths nest: `log:///1/2/3/READ` is loop/turn/item/operation.
+* `(path)` may be a glob/extglob, permitting bulk operations.
+* Log item paths nest: `log:///1/2/3/READ` is loop/turn/item/OP.
 * FIND results hold one inner array per path: its channels, default first; append `#channel` to select another.
-* Percent-encode `(` as `%28` and `)` as `%29`.
+* Percent-encode in paths `(` as `%28` and `)` as `%29`.
 
 ## File Editing
 
-    ````EDIT (example.md) <@abcde>
+    ```EDIT (example.md) <@abcde>
     literal replacement text
-    ````
+    ```
 
-    ````EDIT (books.xml) //book[price > 35.00] <!-- an empty body removes each match -->
-    ````
+    ```EDIT (books.xml) //book[price > 35.00] <!-- an empty body removes each match -->
+    ```
 
-    ````42EDIT (edit-example.md) <!-- resolve nested OP conflicts with matching numeric delimiters after fencing -->
-    ````EDIT (edit-example.md)
-    OPs always begin and end with exactly four backticks, both immediately after a newline.
+    ````EDIT (edit-example.md) <!-- Nesting can be resolved with increased outer fences. Examples can use tabbed offset. -->
+    ```EDIT (create-example.md)
+    When representing markdown, `~~~` notation can disambiguate nested content.
+    ```
     ````
-    ````42
 
 > [!TIP]
 > The EDIT body is literal text. YOU SHOULD address lines by `<@hash>` or `<@start,@end>`; stale targets are rejected.
 
-> [!TIP]
-> Creating a file creates missing parent directories.
-
 ## Delegation
 
-    ````WORK (worker://reviewer) [{"env": {"NODE_ENV": "test"}}] <!-- the child's result lands in your log -->
-    Review src/ for unhandled promise rejections.
-    ````
+    ```WORK (worker://alice) <!-- the child's result lands in your log -->
+    The child's complete task.
+    ```
 
-    ````KILL (sh:///ab3d5678) <!-- stops a running command -->
-    ````
+    ```BARE
+    A self-contained prompt.
+    ```
+
+    ```KILL (sh:///ab3d5678) <!-- stops a running command -->
+    ```
 
 > [!TIP]
 > `SEND (worker://name)` messages a live worker.
@@ -99,11 +85,8 @@ Pattern Lookup Universal Resource NetworK: find anything by pattern, read it by
 > [!CAUTION]
 > logTokensTotal must not exceed logTokensMax. Successful log KILL receipts are not shown.
 
-    ````KILL (log:///1/[1-7]/*/{NOTE,READ}) <!-- removes matching log items, recovering context -->
-    ````
-
-    ````KILL (log:///**/READ) <17,-1> <!-- trims each item's log lines from 17 on, recovering context -->
-    ````
+    ```KILL (log:///1/[1-7]/*/{NOTE,READ}) <17, -1> <!-- trims matching log items, recovering context -->
+    ```
 
 ## `<scope|range>`
 
@@ -117,12 +100,6 @@ Pattern Lookup Universal Resource NetworK: find anything by pattern, read it by
 | `<SL,SC,EL,EC>` | start included, end excluded — `<2,3,3,6>` is line 2 column 3 through line 3 column 5 |
 | `<0>`, `<-1>`  | prepend / append on mutations; as an end line, `-1` is the last line |
 
-> [!CAUTION]
-> The hash anchor and line number (`@abcde 42:`) shown on editable text are not content.
-
-> [!TIP]
-> Log items often present partial preview ranges. READ more if it's relevant and you have the logTokensMax room for it.
-
 ## `pattern`
 
 > [!TIP]
@@ -135,4 +112,4 @@ Pattern Lookup Universal Resource NetworK: find anything by pattern, read it by
 | `$`    | jsonpath (RFC 9535)         | `$.items[?(@.price>500)]`       |
 | `~`    | full-text (SQLite FTS5)     | `~retry`                        |
 | `&`    | graph (treesitter symbols)  | `&sym`, `&<sym`, `&>sym`        |
-| none   | literal or extglob          | `?(export )?(async )function *` |
+| none   | literal or glob/extglob     | `?(export )?(async )function *` |