@orkestrel/scaffold 0.0.105 → 0.0.106

package/dist/host/claude/agents/orkestrel.md

@@ -78,7 +78,7 @@ so network-controlled descriptions never enter agent instruction context.
 | `@orkestrel/reason`     | `0.0.13`  | L2    | `@orkestrel/emitter` `^0.0.12`, `@orkestrel/contract` `^0.0.19`                                                                                                                                                                                                                                                                                  |                                                                |
 | `@orkestrel/relation`   | `0.0.16`  | L3    | `@orkestrel/emitter` `^0.0.12`, `@orkestrel/contract` `^0.0.19`, `@orkestrel/database` `^0.0.18`                                                                                                                                                                                                                                                 |                                                                |
 | `@orkestrel/router`     | `0.0.17`  | L2    | `@orkestrel/abort` `^0.0.13`, `@orkestrel/emitter` `^0.0.12`, `@orkestrel/contract` `^0.0.19`                                                                                                                                                                                                                                                    |                                                                |
-| `@orkestrel/scaffold`   | `0.0.104` | L3    | `@orkestrel/console` `^0.0.16`, `@orkestrel/emitter` `^0.0.12`, `@orkestrel/process` `^0.0.15`, `@orkestrel/contract` `^0.0.19`, `@orkestrel/markdown` `^0.0.17`, `@orkestrel/template` `^0.0.10`                                                                                                                                                |                                                                |
+| `@orkestrel/scaffold`   | `0.0.105` | L3    | `@orkestrel/console` `^0.0.16`, `@orkestrel/emitter` `^0.0.12`, `@orkestrel/process` `^0.0.15`, `@orkestrel/contract` `^0.0.19`, `@orkestrel/markdown` `^0.0.17`, `@orkestrel/template` `^0.0.10`                                                                                                                                                |                                                                |
 | `@orkestrel/sea`        | `0.0.19`  | L3    | `@orkestrel/emitter` `^0.0.12`, `@orkestrel/process` `^0.0.15`, `@orkestrel/contract` `^0.0.19`                                                                                                                                                                                                                                                  |                                                                |
 | `@orkestrel/server`     | `0.0.23`  | L3    | `@orkestrel/abort` `^0.0.13`, `@orkestrel/codec` `^0.0.6`, `@orkestrel/router` `^0.0.17`, `@orkestrel/emitter` `^0.0.12`, `@orkestrel/timeout` `^0.0.13`, `@orkestrel/contract` `^0.0.19`                                                                                                                                                        |                                                                |
 | `@orkestrel/sqlite`     | `0.0.14`  | L1    | `@orkestrel/contract` `^0.0.19`                                                                                                                                                                                                                                                                                                                  |                                                                |

package/dist/host/guides/agent.md

@@ -467,16 +467,18 @@ Write criteria for a judge that reads literally (see [Jev 1.13 jaggedness](https
 
 ### Serving a conversation through a ledger
 
-A ledger serves one conversation as an event-sourced briefing with per-owner records. The `createLedger(provider, options)` factory returns a `LedgerInterface` value that owns the conversation, the agent that answers it, and that agent's tools, and its `respond` method appends a request as a user message and serves it through to the reply. The conversation is the event log. Each request reads a briefing that the ledger projects from what a judge filed about every message, then a tail of the seed history (the messages added before the first request), then the request. An earlier request and its reply don't re-enter a planned prompt; what its lookups returned reaches a later request through the records and the `recall` tool. When the selection faults, the agent builds the prompt from the whole conversation view instead, earlier requests and replies included, with no briefing.
+A ledger serves one conversation as an event-sourced briefing with per-owner records. The `createLedger(provider, options)` factory returns a `LedgerInterface` value that owns the conversation, the agent that answers it, and that agent's tools, and its `respond` method appends a request as a user message and serves it through to the reply. The conversation is the event log. Each request reads a briefing that the ledger projects from what a judge filed about every message, then a tail, then the request. With `recent` omitted or false, the tail selects only seed history (the messages added before the first request), and an earlier request and its reply don't re-enter that tail; what its lookups returned reaches a later request through the records and the `recall` tool. When the selection faults, the agent builds the prompt from the whole conversation view instead, earlier requests and replies included, with no briefing.
 
 Run the ledger's agent only through the `respond` method. An active `respond` call owns a run whose request, the newest message, is that call's request or one of the ledger's notes. A run that no active `respond` call owns, such as a direct call to the agent's `generate` method, gets a faulted selection when its newest message is a user message: the selection's `fault` is a `LedgerError` with code `'REQUEST'`, so the agent emits `fault` and builds the prompt from the whole conversation view with no briefing, and the ledger asks its judge nothing for that run. When its newest message isn't a user message, the run gets no selection and builds from the whole view. Calibration admits no run, so a run during the `calibrate` method, or during the calibration that opens a `respond` call, is one that no active `respond` call owns.
 
 The method has the following pieces, each named by its export:
 
 - **The filing.** The `Classifier` class files each message through the judge the `judge` option injects. The ledger files a tool result, its own notes, an assistant call, and an assistant reply after the first request by their shape, and asks the judge about the rest: the `LEDGER_QUESTIONS` category question about each remaining non-request message, and the topic question, for each desk topic, about each non-quiet statement and each request unless that topic has `requested: false`; and the `amends` question about a later user message whose `correction` probability reaches the `correction` cutoff and an earlier message that isn't quiet and shares an id, an owner, or a desk topic with it, followed by the `supersedes` question about the same pair when the `amends` answer reaches its cutoff. Every answer lands in the conversation's `judgments` store, so a later request asks only what no earlier one asked. A judge failure leaves its question unanswered, and the next request asks it again, except for two failures that hold the question so that no later request asks it: a refused question, which the judge reports as a `JudgeError` with code `'QUESTION'`, and the deterministic logprob failure the `DETERMINISTIC_JUDGE_ERROR` constant matches. The `LedgerClassification` value reads the filing back at the cutoffs: an `amends` answer at its cutoff marks a pair amended only when the two messages share an id or a number, and a `supersedes` answer at its cutoff marks the pair superseded and amended whatever they share. Each `classify` call also returns one `ClassifierReading` value per logical filing question it attempted, in asking order, and observes the filing without changing it. A reading names the question's key and its `ClassifierPhase` value, and its `ClassifierOutcome` value says whether the conversation already held the judgment (`cached`), the classifier held the question after a deterministic failure (`skipped`), or the judgment manager's `resolve` call fulfilled (`resolved`), rejected under a live signal (`failed`), or was cut short by an abort (`aborted`). A `resolved`, `failed`, or `aborted` reading carries the monotonic milliseconds the classifier waited on that call as `duration`, and a `cached` or `skipped` reading carries none. A question that a caller abort preceded has no reading, because it never began. The readings count logical question attempts and resolve requests, never the physical wire calls a judge makes for them, and they record no join of pending requests. The `readings` member of the `LedgerResult` value holds the readings of the filing selections of that `respond` call alone; the `Selection` values the ledger emits carry none.
-- **The records.** The `buildRecords` helper projects the filing into one `LedgerRecord` value per owner a lookup result names, plus one rules record for the rules and corrections no owner claims. Each line is a sentence of a live message, verbatim except that a sentence that opens with a pronoun opens with its party and a colon. A message filed quiet or superseded isn't live, and a sentence that shares an id or a number with a later message that amends it is stale: the projection lists it in its `stale` member and leaves it out of every record and the briefing. The `recall` tool and the answer note keep the stored content of each message they carry, stale sentences included. The seed tail keeps stored content except for lookup results, which the plan replaces with stubs.
+- **The records.** The `buildRecords` helper projects the filing into one `LedgerRecord` value per owner a lookup result names, plus one rules record for the rules and corrections no owner claims. Each line is a sentence of a live message, verbatim except that a sentence that opens with a pronoun opens with its party and a colon. A message filed quiet or superseded isn't live, and a sentence that shares an id or a number with a later message that amends it is stale: the projection lists it in its `stale` member and leaves it out of every record and the briefing. The `recall` tool and the answer note keep the stored content of each message they carry, stale sentences included. The tail keeps stored content except for lookup results, which the plan replaces with stubs.
 - **Owner linking.** By default, only an id-shaped lookup subject links: an owner id links to itself, and another id links to the single owner named in the reading's text. With the boolean `link` option on, a subject such as `order:BC-7301` that carries exactly one id uses that id under the same rules. The link is keyed by `BC-7301`, so a later message or request naming that bare id resolves to the owner. A subject carrying no id or several ids links nothing; a non-owner id whose reading names no owner or several owners also links nothing. The option defaults to `false`.
-- **The plan.** For each request, the ledger selects the records the request names through the `selectRecords` helper and fits the briefing and the tail inside a token budget: the `capacity` option less the `predict` option, times the `prompt` share, less the overhead cost of the gauge and held back by the `LEDGER_SCALE_DRIFT` constant, of which the tail takes at most the `tail` share. The budget bounds only the briefing and the tail of a request's first call. The request, each lookup result, the pass's own assistant turns with their calls and replayed thinking, the answer note and the `cue` note, and the whole view a faulted selection builds from enter the prompt unbounded, so any of them can carry a prompt past the budget. The plan prices each lookup stub in the tail at the longer of its `shown` and `hidden` forms, so a tail that fits the plan still fits after the briefing decides which results it shows. The `share` option sets both shares, and the `DEFAULT_LEDGER_SHARE` constant holds the defaults. With lexical selection off, until the briefing fits, the ledger drops the rules off the request's topics, then the sources outside the selected records, then the rules on its topics, then the owner lines. The `Gauge` class prices the prompt; without the `gauge` option, the ledger calibrates before its first pass, and the `calibrate` method measures the price on demand. A lookup in the tail reaches the model as the stub the `renderStub` helper writes, which says whether the briefing shows its result. The plan reaches the agent as a `Selection` value: its `messages` member is the tail, and its `briefing` member is the text the `build` method appends as the last part of the system message.
+- **The plan.** For each request, the ledger selects the records the request names through the `selectRecords` helper and fits the briefing and the tail inside a token budget: the `capacity` option less the `predict` option, times the `prompt` share, less the overhead cost of the gauge and held back by the `LEDGER_SCALE_DRIFT` constant, of which the tail takes at most the `tail` share while `recent` is off. The budget bounds only the briefing and the tail of a request's first call. The request, each lookup result, the pass's own assistant turns with their calls and replayed thinking, the answer note and the `cue` note, and the whole view a faulted selection builds from enter the prompt unbounded, so any of them can carry a prompt past the budget. The plan prices each lookup stub in the tail at the longer of its `shown` and `hidden` forms, so a tail that fits the plan still fits after the briefing decides which results it shows. The `share` option sets both shares, and the `DEFAULT_LEDGER_SHARE` constant holds the defaults. After cutting any earlier work, with lexical selection off, until the briefing fits, the ledger drops the rules off the request's topics, then the sources outside the selected records, then the rules on its topics, then the owner lines. The `Gauge` class prices the prompt; without the `gauge` option, the ledger calibrates before its first pass, and the `calibrate` method measures the price on demand. A lookup in the tail reaches the model as the stub the `renderStub` helper writes, which says whether the briefing shows its result. The plan reaches the agent as a `Selection` value: its `messages` member is the tail, and its `briefing` member is the text the `build` method appends as the last part of the system message.
+- **Recent history.** Set the boolean `recent` option to `true` to select history up to the current request. The optional `pins` handler, a `LedgerPinHandler` predicate, holds each whole exchange containing a matching message. The newest unheld whole exchanges fill the tail allowance, in conversation order. Lookup groups stay whole and lookup results keep their stubs. Pins can exceed the allowance; the plan keeps them and cuts the briefing, recording the cuts in `trims` and wholly cut sources in `omitted`. With no handler, no exchange is held. Omission and `false` preserve the seed tail and never call the handler.
+- **Earlier work.** Set the boolean `work` option to `true` to append an “Earlier work” section after the Rules section. The optional `names` handler, a `LedgerNameHandler` function, names each earlier request with a nonempty call-free assistant reply. The `collectLedgerWork` helper pairs it with the last such reply before the next request, including an answer-pass reply. A name matches when it and the current request share an id token as read by `extractTokens`; token case is folded, and adjacent ids remain distinct. The `renderLedgerWork` helper carries the exact reply under `[NAME]`. The `LEDGER_WORK_HEADING` and `LEDGER_WORK_NOTE` constants label the section as your own earlier drafts, never evidence that an action happened. Replies already in the tail are excluded. Entries render in conversation order and are cut whole, oldest first, before every other briefing cut; `trims` counts those cuts. Work adds no source, owner, filed id, rendered source, sentence, or omitted source, and changes no judge question or recall behavior. With no naming handler, no request is named. Omission and `false` preserve the briefing and never call the handler.
 - **Lexical selection.** Set the boolean `lexical` option to `true` to enable BM25 (Best Matching 25) for lexical discovery and ranked recall; omission and `false` preserve the preceding selection behavior. The option is independent of `link`. The shared Unicode analyzer counts lowercase word occurrences for term frequency and length. Each plan and recall computes transient statistics over every call-free message, including held, tail, empty, and non-live messages. The coefficients are `LEDGER_BM25_K1` at 1.2 and `LEDGER_BM25_B` at 0.75. Existing candidate exclusions and keyed membership remain. Keyed units keep the same inverse-document-frequency sum for order and cut keys as with lexical selection off. BM25 decides only a discovery source's admission, order, and cut order in the briefing. A discovery source follows the existing planning groups, needs a positive score at or above `LEDGER_BM25_FLOOR` at `ln(2)`, and orders by descending score then earlier conversation position. The plan cuts discovery first, by lower score then later position, before every keyed unit and within the same room. Recall admits a lexical source only when every word in a topic part matches its content and at least one analyzed whole word overlaps. Recall keeps keyed matches first, then scores each entry root against the distinct analyzed whole topic, then orders equal scores by later position. It constructs amendment entries newest-first before ranking, keeps whole entries, and labels a ranked cut as “items” without age wording. The results note removes only the suffix form its arm writes: neutral wording with lexical selection enabled, and “older items” with the option omitted or false. Pass the same `ranked` value to `cutListing` and `matchesCutLine`; the matcher defaults to `false`. Empty analyzed queries and no lexical overlap add no lexical hits; punctuation-only recall matches no keyed source. Recall limits, room, and repeat identity stay the same.
 - **The `recall` tool.** The ledger registers a `recall` tool beside the application's lookups. The following listing order applies with lexical selection off. It lists the earlier messages and lookup readings that match a topic (an owner name, an id, or a desk topic) with their stored content, newest first, each source followed by the amenders the topic doesn't match itself; an amender the topic matches lists as its own newer item. The tool cuts the list by whole items to the room the gauge leaves for the reply, naming how many older items it left out. A request can call it as many times as the `limit` member of the `recall` option allows, the `DEFAULT_RECALL_LIMIT` constant by default; after that, or when the capacity left less the `predict` option falls under twice the reply's reserve, it returns the `closure` note.
 - **The repeat stop.** A lookup or `recall` call that repeats an earlier call of the same request, compared by tool name and canonical arguments, returns the `repeat` note as its failure, and the ledger aborts the pass. For a lookup, the repeat stop's identity compares string arguments as written. The projection's lookup identity, which the `identifyLookup` helper writes, trims and uppercases each top-level string argument and decides which reading replaces an earlier one. So `lookup_order` calls for `bw-5512` and `BW-5512` both run in one request, and the second reading replaces the first in the records.
@@ -509,7 +511,7 @@ The method has the following documented limits:
 - **A seed tool message counts as successful.** A tool message the application adds to the conversation has no recorded result, so the ledger reads it as a successful lookup and files it as a fact, and its reading handler decides what the result names.
 - **An abort during calibration rejects.** When the caller's signal aborts while the ledger calibrates, the `respond` method rejects with the abort reason instead of resolving a partial result; after calibration, an abort ends the request partial and skips the answer pass.
 - **A foreign signal rejects before anything is appended.** A `signal` that isn't a native `AbortSignal` rejects the `respond` method with a `ContractError` before the request is appended, and the ledger stays free for a later request.
-- **Only the seed forms the tail.** Only the messages added before the first request form the seed tail, so an application message added after the first request reaches a planned prompt only through the briefing or the `recall` tool.
+- **The default tail selects only the seed.** With `recent` omitted or false, only the messages added before the first request form the seed tail, so an application message added after the first request reaches a planned prompt only through the briefing or the `recall` tool.
 - **Records don't retire.** No age or request count retires a message: it leaves the records only when a later message supersedes it or makes its sentences stale, a later reading of the same lookup replaces it, or a later answer files it quiet. Only the plan decides which of its lines a briefing shows.
 - **The ledger refuses no over-window prompt.** A request, a lookup result, the pass's own turns, the answer note, or the whole view a faulted selection builds from reaches the provider whole when it's larger than the room the `capacity` option leaves, and the provider's own context limit decides what happens to it.
 
@@ -1272,61 +1274,64 @@ The `ledgers` module serves a conversation through an event-sourced briefing: th
 
 The following table lists the types the ledger declares, each with its shape:
 
-| Type                      | Kind      | Shape                                                                                                                                                                 | Summary                                                                                                                                                                                                                     |
-| ------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `LedgerCategory`          | type      | `'fact' \| 'rule' \| 'correction' \| 'request' \| 'opinion' \| 'chatter' \| 'distractor'`                                                                             | Names the category the ledger files a message under, one of `LEDGER_CATEGORIES`.                                                                                                                                            |
-| `LedgerQuestion`          | interface | `{ category, topic, amends, supersedes }`                                                                                                                             | Carries the wording of every question the ledger asks its judge.                                                                                                                                                            |
-| `LedgerThreshold`         | interface | `{ category, topic, amends, supersedes, correction }`                                                                                                                 | Carries the probability cutoff of each reading the ledger takes from its judge.                                                                                                                                             |
-| `LedgerTopic`             | interface | `{ name, criterion, requested? }`                                                                                                                                     | Carries one desk topic: the subject the ledger asks its judge about for statements and, when enabled, requests.                                                                                                             |
-| `LedgerShare`             | interface | `{ prompt, tail }`                                                                                                                                                    | Carries the share of the context capacity the prompt can take and the share of that budget the tail can take.                                                                                                               |
-| `LedgerNote`              | interface | `{ cue, results, repeat, closure }`                                                                                                                                   | Carries the text of each note the ledger writes into its conversation or returns to the model.                                                                                                                              |
-| `LedgerRecallOptions`     | interface | `{ limit? }`                                                                                                                                                          | Configures the ledger's `recall` tool.                                                                                                                                                                                      |
-| `LedgerOwner`             | interface | `{ id, names }`                                                                                                                                                       | Carries one owner a lookup result names: its id and the names it goes by.                                                                                                                                                   |
-| `LedgerLookupResult`      | interface | `{ ids, owners }`                                                                                                                                                     | Carries what a lookup handler read from one lookup result: the ids it names and the owners among them.                                                                                                                      |
-| `LedgerLookupHandler`     | type      | `(args, text) => LedgerLookupResult \| undefined`                                                                                                                     | Reads one successful lookup result into the ids and owners it names.                                                                                                                                                        |
-| `LedgerLookup`            | interface | `{ tool, read }`                                                                                                                                                      | Carries one application lookup: the tool the model calls and the handler that reads its results.                                                                                                                            |
-| `LedgerLookupReading`     | interface | `{ id, name, arguments, text, result }`                                                                                                                               | Carries one successful lookup result as the ledger read it.                                                                                                                                                                 |
-| `LedgerLookupState`       | type      | `'failed' \| 'empty' \| 'shown' \| 'hidden'`                                                                                                                          | Names what became of a lookup of an earlier request, as the tail stub of its result reports it.                                                                                                                             |
-| `LedgerRegistry`          | interface | `{ ids, owners }`                                                                                                                                                     | Carries the ids the ledger's lookups named and the owners among them.                                                                                                                                                       |
-| `LedgerGauge`             | interface | `{ scale, overhead }`                                                                                                                                                 | Carries the price of a prompt in tokens, measured against the model the ledger serves.                                                                                                                                      |
-| `LedgerAgentOptions`      | type      | `Pick<AgentOptions, 'limit' \| 'timeout' \| 'on'>`                                                                                                                    | Selects the agent bounds and hooks a ledger passes through to the agent it builds.                                                                                                                                          |
-| `LedgerOptions`           | interface | `{ judge, system, topics, questions, thresholds, capacity, predict?, think?: boolean, gauge?, lookups?, link?: boolean, lexical?: boolean, share?, recall?, agent? }` | Configures a ledger: its judge and the wording and cutoffs it files with, the desk topics, the context capacity, and the optional first-pass thinking, lookups, gauge, shares, recall, and agent bounds.                    |
-| `LedgerCarriage`          | type      | `'verbatim' \| 'record' \| 'recap' \| 'absent'`                                                                                                                       | Names how composition carries a selected source's content.                                                                                                                                                                  |
-| `LedgerSentence`          | interface | `{ source, sentence }`                                                                                                                                                | Identifies a source sentence the briefing compositor emitted.                                                                                                                                                               |
-| `LedgerWithdrawal`        | interface | `{ earlier, later }`                                                                                                                                                  | Identifies an effective amendment that withdrew an earlier sentence.                                                                                                                                                        |
-| `LedgerSource`            | interface | `{ source, carriage: LedgerCarriage \| undefined }`                                                                                                                   | Records a selected source's established content carriage.                                                                                                                                                                   |
-| `LedgerPlanReceipt`       | interface | `{ owners, filed, rendered, sentences, omitted, trims, withdrawn }`                                                                                                   | Preserves the projection and composition facts of one successful plan.                                                                                                                                                      |
-| `LedgerPlan`              | interface | `Selection plus receipt: LedgerPlanReceipt`                                                                                                                           | Holds a successful selection with its request-owned planning evidence.                                                                                                                                                      |
-| `LedgerSelectionReceipt`  | interface | `{ turn, tail, prior, plan, sources }`                                                                                                                                | Preserves one adopted selection after all message filtering.                                                                                                                                                                |
-| `LedgerCall`              | interface | `GaugeCall plus selection: number \| undefined`                                                                                                                       | Preserves one gauge observation and its selection at measurement time.                                                                                                                                                      |
-| `LedgerReceipt`           | interface | `{ selections, calls }`                                                                                                                                               | Preserves the adopted selections and gauge observations of one pass.                                                                                                                                                        |
-| `LedgerResult`            | interface | `{ content, thinking?, usage?, partial, stop?, request, passes, readings, receipts }`                                                                                 | Carries the reply, passes, filing readings, and evidence of a resolved request.                                                                                                                                             |
-| `LedgerInterface`         | interface | `{ agent, conversation, gauge } plus respond, calibrate`                                                                                                              | Serves the requests of one conversation through an agent whose prompt the ledger projects from what the judge filed.                                                                                                        |
-| `LedgerRequestInterface`  | interface | `{ message, plan, selection, boundary, usage, calls, readings, receipts } plus enter, open, adopt, observe, spend, think, file, admit, recall, close, list, listing`  | Holds what one `respond` call of a ledger keeps while it serves its request: the request message, the filing readings and the plan its selections produced, the gauge calls of its passes, and its repeat and recall stops. |
-| `LedgerTokenSet`          | interface | `{ ids, numbers }`                                                                                                                                                    | Carries the id-shaped tokens and the numbers of a text.                                                                                                                                                                     |
-| `LedgerWordSet`           | interface | `{ words, names }`                                                                                                                                                    | Carries the lowercase words and non-opening capitalized names of a message.                                                                                                                                                 |
-| `LedgerClassification`    | interface | `{ quiet, categories, topics, amendments, supersessions }`                                                                                                            | Carries the ledger's filing of its conversation's messages, keyed by message id.                                                                                                                                            |
-| `LedgerLine`              | interface | `{ text, source, sentence, party?, topics, role }`                                                                                                                    | Carries one record line: a sentence of a live message, verbatim except that a sentence that opens with a pronoun opens with its party and a colon.                                                                          |
-| `LedgerRecord`            | interface | `{ key, title, members, lines }`                                                                                                                                      | Carries one record: the live messages placed on one owner or on the rules, as lines.                                                                                                                                        |
-| `LedgerStaleSentence`     | interface | `{ source, sentence, tokens, later }`                                                                                                                                 | Carries one stale sentence and the effective amenders sharing its tokens.                                                                                                                                                   |
-| `LedgerProjection`        | interface | `{ records, stale, orphans }`                                                                                                                                         | Carries the records projected from a conversation, the stale sentences, and the live messages no record placed.                                                                                                             |
-| `LedgerProjectionInput`   | interface | `{ link?: boolean, system, exclusions, owners, messages, readings, entities, classification }`                                                                        | Carries what a projection reads.                                                                                                                                                                                            |
-| `LedgerProjectionRequest` | interface | `{ owners, topics }`                                                                                                                                                  | Carries the owners and the desk topics one request names, which select its records.                                                                                                                                         |
-| `LedgerCategoryHandler`   | type      | `(message) => LedgerCategory \| undefined`                                                                                                                            | Reads a message's category from its shape, or returns undefined to leave it to the judge.                                                                                                                                   |
-| `LedgerEntityHandler`     | type      | `(text, partial) => ReadonlySet<string>`                                                                                                                              | Lists the registry ids and owner ids a text names.                                                                                                                                                                          |
-| `ClassifierOptions`       | interface | `{ conversation, judge, questions, topics, thresholds, assign, entities }`                                                                                            | Configures a classifier: the conversation it files, the judge and the wording it asks with, the desk topics, the cutoffs, and the ledger's handlers.                                                                        |
-| `ClassifierPhase`         | type      | `'category' \| 'topic' \| 'amends' \| 'supersedes'`                                                                                                                   | Names the filing question a classifier asked: a message's category, a message's topic, or an earlier and later message's amendment or supersession.                                                                         |
-| `ClassifierOutcome`       | type      | `'cached' \| 'skipped' \| 'resolved' \| 'failed' \| 'aborted'`                                                                                                        | Names what became of one filing question.                                                                                                                                                                                   |
-| `ClassifierReading`       | interface | `{ key, phase, outcome, duration? }`                                                                                                                                  | Carries what became of one filing question: its judgment key, its phase, its outcome, and the time spent resolving it.                                                                                                      |
-| `ClassifierResult`        | interface | `{ judgments, usage?, readings, fault? }`                                                                                                                             | Carries the judgment keys one classification rests on and the judge usage it spent.                                                                                                                                         |
-| `ClassifierInterface`     | interface | `{} plus classify, category, quiet, decisive, topics, classification`                                                                                                 | Files a conversation's messages through a judge and reads the filing.                                                                                                                                                       |
-| `GaugeCall`               | interface | `{ estimate, prompt?, completion?, thinking?, tools }`                                                                                                                | Carries one agent call as the gauge reads it.                                                                                                                                                                               |
-| `GaugeOptions`            | interface | `{ scale, overhead, capacity, predict?, replay? }`                                                                                                                    | Configures a gauge: its starting price of a prompt and the context capacity it measures against.                                                                                                                            |
-| `GaugeInterface`          | interface | `{ scale, overhead } plus rate, remainder, reserve, room, observe`                                                                                                    | Prices prompts in tokens and measures the room a request has left.                                                                                                                                                          |
-| `LedgerPlanningGroup`     | type      | `1 \| 2 \| 3 \| 4`                                                                                                                                                    | Names a topic, rule, name, or lexical planning group.                                                                                                                                                                       |
-| `LedgerLexicon`           | interface | `{ frequencies, length }`                                                                                                                                             | Carries occurrence counts from the ledger's word matches.                                                                                                                                                                   |
-| `LedgerCorpus`            | interface | `{ count, frequencies, average }`                                                                                                                                     | Carries statistics over every call-free message.                                                                                                                                                                            |
-| `LedgerErrorCode`         | type      | `'REQUEST' \| 'THRESHOLD' \| 'SHARE' \| 'CAPACITY' \| 'LIMIT' \| 'TOPIC' \| 'LOOKUP' \| 'GAUGE'`                                                                      | Names the machine-readable conditions a `LedgerError` error reports.                                                                                                                                                        |
+| Type                      | Kind      | Shape                                                                                                                                                                                                                                                       | Summary                                                                                                                                                                                                                     |
+| ------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `LedgerCategory`          | type      | `'fact' \| 'rule' \| 'correction' \| 'request' \| 'opinion' \| 'chatter' \| 'distractor'`                                                                                                                                                                   | Names the category the ledger files a message under, one of `LEDGER_CATEGORIES`.                                                                                                                                            |
+| `LedgerQuestion`          | interface | `{ category, topic, amends, supersedes }`                                                                                                                                                                                                                   | Carries the wording of every question the ledger asks its judge.                                                                                                                                                            |
+| `LedgerThreshold`         | interface | `{ category, topic, amends, supersedes, correction }`                                                                                                                                                                                                       | Carries the probability cutoff of each reading the ledger takes from its judge.                                                                                                                                             |
+| `LedgerTopic`             | interface | `{ name, criterion, requested? }`                                                                                                                                                                                                                           | Carries one desk topic: the subject the ledger asks its judge about for statements and, when enabled, requests.                                                                                                             |
+| `LedgerShare`             | interface | `{ prompt, tail }`                                                                                                                                                                                                                                          | Carries the share of the context capacity the prompt can take and the share of that budget the tail can take.                                                                                                               |
+| `LedgerNote`              | interface | `{ cue, results, repeat, closure }`                                                                                                                                                                                                                         | Carries the text of each note the ledger writes into its conversation or returns to the model.                                                                                                                              |
+| `LedgerRecallOptions`     | interface | `{ limit? }`                                                                                                                                                                                                                                                | Configures the ledger's `recall` tool.                                                                                                                                                                                      |
+| `LedgerOwner`             | interface | `{ id, names }`                                                                                                                                                                                                                                             | Carries one owner a lookup result names: its id and the names it goes by.                                                                                                                                                   |
+| `LedgerLookupResult`      | interface | `{ ids, owners }`                                                                                                                                                                                                                                           | Carries what a lookup handler read from one lookup result: the ids it names and the owners among them.                                                                                                                      |
+| `LedgerLookupHandler`     | type      | `(args, text) => LedgerLookupResult \| undefined`                                                                                                                                                                                                           | Reads one successful lookup result into the ids and owners it names.                                                                                                                                                        |
+| `LedgerLookup`            | interface | `{ tool, read }`                                                                                                                                                                                                                                            | Carries one application lookup: the tool the model calls and the handler that reads its results.                                                                                                                            |
+| `LedgerLookupReading`     | interface | `{ id, name, arguments, text, result }`                                                                                                                                                                                                                     | Carries one successful lookup result as the ledger read it.                                                                                                                                                                 |
+| `LedgerLookupState`       | type      | `'failed' \| 'empty' \| 'shown' \| 'hidden'`                                                                                                                                                                                                                | Names what became of a lookup of an earlier request, as the tail stub of its result reports it.                                                                                                                             |
+| `LedgerRegistry`          | interface | `{ ids, owners }`                                                                                                                                                                                                                                           | Carries the ids the ledger's lookups named and the owners among them.                                                                                                                                                       |
+| `LedgerGauge`             | interface | `{ scale, overhead }`                                                                                                                                                                                                                                       | Carries the price of a prompt in tokens, measured against the model the ledger serves.                                                                                                                                      |
+| `LedgerAgentOptions`      | type      | `Pick<AgentOptions, 'limit' \| 'timeout' \| 'on'>`                                                                                                                                                                                                          | Selects the agent bounds and hooks a ledger passes through to the agent it builds.                                                                                                                                          |
+| `LedgerPinHandler`        | type      | `(message) => boolean`                                                                                                                                                                                                                                      | Decides whether the recent tail holds a history message's whole exchange regardless of age.                                                                                                                                 |
+| `LedgerWork`              | interface | `{ request, reply }`                                                                                                                                                                                                                                        | Pairs an earlier request with its last nonempty call-free assistant reply before the next request.                                                                                                                          |
+| `LedgerNameHandler`       | type      | `(request) => string \| undefined`                                                                                                                                                                                                                          | Names an earlier request for matching against the current request's id tokens.                                                                                                                                              |
+| `LedgerOptions`           | interface | `{ judge, system, topics, questions, thresholds, capacity, predict?, think?: boolean, gauge?, lookups?, link?: boolean, lexical?: boolean, recent?: boolean, pins?: LedgerPinHandler, work?: boolean, names?: LedgerNameHandler, share?, recall?, agent? }` | Configures a ledger: its judge and the wording and cutoffs it files with, the desk topics, the context capacity, and the optional first-pass thinking, lookups, gauge, shares, recall, and agent bounds.                    |
+| `LedgerCarriage`          | type      | `'verbatim' \| 'record' \| 'recap' \| 'absent'`                                                                                                                                                                                                             | Names how composition carries a selected source's content.                                                                                                                                                                  |
+| `LedgerSentence`          | interface | `{ source, sentence }`                                                                                                                                                                                                                                      | Identifies a source sentence the briefing compositor emitted.                                                                                                                                                               |
+| `LedgerWithdrawal`        | interface | `{ earlier, later }`                                                                                                                                                                                                                                        | Identifies an effective amendment that withdrew an earlier sentence.                                                                                                                                                        |
+| `LedgerSource`            | interface | `{ source, carriage: LedgerCarriage \| undefined }`                                                                                                                                                                                                         | Records a selected source's established content carriage.                                                                                                                                                                   |
+| `LedgerPlanReceipt`       | interface | `{ owners, filed, rendered, sentences, omitted, trims, withdrawn }`                                                                                                                                                                                         | Preserves the projection and composition facts of one successful plan.                                                                                                                                                      |
+| `LedgerPlan`              | interface | `Selection plus receipt: LedgerPlanReceipt`                                                                                                                                                                                                                 | Holds a successful selection with its request-owned planning evidence.                                                                                                                                                      |
+| `LedgerSelectionReceipt`  | interface | `{ turn, tail, prior, plan, sources }`                                                                                                                                                                                                                      | Preserves one adopted selection after all message filtering.                                                                                                                                                                |
+| `LedgerCall`              | interface | `GaugeCall plus selection: number \| undefined`                                                                                                                                                                                                             | Preserves one gauge observation and its selection at measurement time.                                                                                                                                                      |
+| `LedgerReceipt`           | interface | `{ selections, calls }`                                                                                                                                                                                                                                     | Preserves the adopted selections and gauge observations of one pass.                                                                                                                                                        |
+| `LedgerResult`            | interface | `{ content, thinking?, usage?, partial, stop?, request, passes, readings, receipts }`                                                                                                                                                                       | Carries the reply, passes, filing readings, and evidence of a resolved request.                                                                                                                                             |
+| `LedgerInterface`         | interface | `{ agent, conversation, gauge } plus respond, calibrate`                                                                                                                                                                                                    | Serves the requests of one conversation through an agent whose prompt the ledger projects from what the judge filed.                                                                                                        |
+| `LedgerRequestInterface`  | interface | `{ message, plan, selection, boundary, usage, calls, readings, receipts } plus enter, open, adopt, observe, spend, think, file, admit, recall, close, list, listing`                                                                                        | Holds what one `respond` call of a ledger keeps while it serves its request: the request message, the filing readings and the plan its selections produced, the gauge calls of its passes, and its repeat and recall stops. |
+| `LedgerTokenSet`          | interface | `{ ids, numbers }`                                                                                                                                                                                                                                          | Carries the id-shaped tokens and the numbers of a text.                                                                                                                                                                     |
+| `LedgerWordSet`           | interface | `{ words, names }`                                                                                                                                                                                                                                          | Carries the lowercase words and non-opening capitalized names of a message.                                                                                                                                                 |
+| `LedgerClassification`    | interface | `{ quiet, categories, topics, amendments, supersessions }`                                                                                                                                                                                                  | Carries the ledger's filing of its conversation's messages, keyed by message id.                                                                                                                                            |
+| `LedgerLine`              | interface | `{ text, source, sentence, party?, topics, role }`                                                                                                                                                                                                          | Carries one record line: a sentence of a live message, verbatim except that a sentence that opens with a pronoun opens with its party and a colon.                                                                          |
+| `LedgerRecord`            | interface | `{ key, title, members, lines }`                                                                                                                                                                                                                            | Carries one record: the live messages placed on one owner or on the rules, as lines.                                                                                                                                        |
+| `LedgerStaleSentence`     | interface | `{ source, sentence, tokens, later }`                                                                                                                                                                                                                       | Carries one stale sentence and the effective amenders sharing its tokens.                                                                                                                                                   |
+| `LedgerProjection`        | interface | `{ records, stale, orphans }`                                                                                                                                                                                                                               | Carries the records projected from a conversation, the stale sentences, and the live messages no record placed.                                                                                                             |
+| `LedgerProjectionInput`   | interface | `{ link?: boolean, system, exclusions, owners, messages, readings, entities, classification }`                                                                                                                                                              | Carries what a projection reads.                                                                                                                                                                                            |
+| `LedgerProjectionRequest` | interface | `{ owners, topics }`                                                                                                                                                                                                                                        | Carries the owners and the desk topics one request names, which select its records.                                                                                                                                         |
+| `LedgerCategoryHandler`   | type      | `(message) => LedgerCategory \| undefined`                                                                                                                                                                                                                  | Reads a message's category from its shape, or returns undefined to leave it to the judge.                                                                                                                                   |
+| `LedgerEntityHandler`     | type      | `(text, partial) => ReadonlySet<string>`                                                                                                                                                                                                                    | Lists the registry ids and owner ids a text names.                                                                                                                                                                          |
+| `ClassifierOptions`       | interface | `{ conversation, judge, questions, topics, thresholds, assign, entities }`                                                                                                                                                                                  | Configures a classifier: the conversation it files, the judge and the wording it asks with, the desk topics, the cutoffs, and the ledger's handlers.                                                                        |
+| `ClassifierPhase`         | type      | `'category' \| 'topic' \| 'amends' \| 'supersedes'`                                                                                                                                                                                                         | Names the filing question a classifier asked: a message's category, a message's topic, or an earlier and later message's amendment or supersession.                                                                         |
+| `ClassifierOutcome`       | type      | `'cached' \| 'skipped' \| 'resolved' \| 'failed' \| 'aborted'`                                                                                                                                                                                              | Names what became of one filing question.                                                                                                                                                                                   |
+| `ClassifierReading`       | interface | `{ key, phase, outcome, duration? }`                                                                                                                                                                                                                        | Carries what became of one filing question: its judgment key, its phase, its outcome, and the time spent resolving it.                                                                                                      |
+| `ClassifierResult`        | interface | `{ judgments, usage?, readings, fault? }`                                                                                                                                                                                                                   | Carries the judgment keys one classification rests on and the judge usage it spent.                                                                                                                                         |
+| `ClassifierInterface`     | interface | `{} plus classify, category, quiet, decisive, topics, classification`                                                                                                                                                                                       | Files a conversation's messages through a judge and reads the filing.                                                                                                                                                       |
+| `GaugeCall`               | interface | `{ estimate, prompt?, completion?, thinking?, tools }`                                                                                                                                                                                                      | Carries one agent call as the gauge reads it.                                                                                                                                                                               |
+| `GaugeOptions`            | interface | `{ scale, overhead, capacity, predict?, replay? }`                                                                                                                                                                                                          | Configures a gauge: its starting price of a prompt and the context capacity it measures against.                                                                                                                            |
+| `GaugeInterface`          | interface | `{ scale, overhead } plus rate, remainder, reserve, room, observe`                                                                                                                                                                                          | Prices prompts in tokens and measures the room a request has left.                                                                                                                                                          |
+| `LedgerPlanningGroup`     | type      | `1 \| 2 \| 3 \| 4`                                                                                                                                                                                                                                          | Names a topic, rule, name, or lexical planning group.                                                                                                                                                                       |
+| `LedgerLexicon`           | interface | `{ frequencies, length }`                                                                                                                                                                                                                                   | Carries occurrence counts from the ledger's word matches.                                                                                                                                                                   |
+| `LedgerCorpus`            | interface | `{ count, frequencies, average }`                                                                                                                                                                                                                           | Carries statistics over every call-free message.                                                                                                                                                                            |
+| `LedgerErrorCode`         | type      | `'REQUEST' \| 'THRESHOLD' \| 'SHARE' \| 'CAPACITY' \| 'LIMIT' \| 'TOPIC' \| 'LOOKUP' \| 'GAUGE'`                                                                                                                                                            | Names the machine-readable conditions a `LedgerError` error reports.                                                                                                                                                        |
 
 #### Constants
 
@@ -1346,6 +1351,8 @@ The following table lists the constants that hold the ledger's categories, recor
 | `LEDGER_OWNER_PREFIX`       | const | `string`                    | Prefixes the key of an owner's record, which the owner's id follows.                                                                                         |
 | `LEDGER_QUESTIONS`          | const | `LedgerQuestion`            | Supplies the wording of every question the ledger asks its judge.                                                                                            |
 | `LEDGER_NOTES`              | const | `LedgerNote`                | Supplies the text of each ledger note, worded for a model that answers in its final message.                                                                 |
+| `LEDGER_WORK_HEADING`       | const | `string`                    | Heads the briefing section carrying the agent's named earlier replies.                                                                                       |
+| `LEDGER_WORK_NOTE`          | const | `string`                    | Labels earlier replies as the agent's drafts rather than evidence of an action.                                                                              |
 | `DEFAULT_LEDGER_SHARE`      | const | `LedgerShare`               | Supplies the default prompt and tail shares.                                                                                                                 |
 | `DEFAULT_LEDGER_LIMIT`      | const | `number`                    | Caps the tool-iteration turns of a ledger's agent at 8 turns.                                                                                                |
 | `DEFAULT_RECALL_LIMIT`      | const | `number`                    | Caps the `recall` calls of one request at 2 calls.                                                                                                           |
@@ -1405,6 +1412,8 @@ The following table lists the pure helpers that read text, project and select re
 | `buildRecords`         | function | `(input) => LedgerProjection`                                         | Projects the owner records and the rules record from a conversation's messages.                             |
 | `selectRecords`        | function | `(projection, request) => readonly LedgerRecord[]`                    | Selects a request's view of the projected records.                                                          |
 | `findLedgerCall`       | function | `(group, message) => ToolCall \| undefined`                           | Finds the call that owns a tool message within a collected tool group.                                      |
+| `collectLedgerWork`    | function | `(messages, requests) => readonly LedgerWork[]`                       | Collects each request's last nonempty call-free assistant reply before the next request.                    |
+| `renderLedgerWork`     | function | `(name, work) => string`                                              | Renders one named earlier reply without changing its content.                                               |
 | `collectProjectionIds` | function | `(projection) => ReadonlySet<string>`                                 | Collects the live message ids placed in records or left without a record.                                   |
 | `scanAmendments`       | function | `(amendments, start, admit) => readonly string[]`                     | Scans admitted amendments in breadth-first order without revisiting a message.                              |
 | `buildLedgerSources`   | function | `(emitted, stored, sections, plan) => readonly LedgerSource[]`        | Builds source carriage from emitted messages and established composition facts.                             |

package/dist/host/guides/scaffold.md

@@ -392,32 +392,32 @@ The inventory contracts carry these data members.
 
 #### Constants
 
-| Name                                | Kind  | Summary                                                                                          |
-| ----------------------------------- | ----- | ------------------------------------------------------------------------------------------------ |
-| `BRANCH_PATTERN`                    | const | Matches the Git branch syntax the repository endpoint accepts.                                   |
-| `DEFAULT_BRANCH`                    | const | Holds the repository branch a raw content read addresses when a caller names none.               |
-| `DEFAULT_REGISTRY_BASE`             | const | Holds the registry a version read addresses when a caller names none.                            |
-| `DEFAULT_REPOSITORY_BASE`           | const | Holds the raw content host a repository read addresses when a caller names none.                 |
-| `DEFAULT_UPSTREAM_CONCURRENCY`      | const | Sets the simultaneous upstream requests a reader opens with, under `MAX_UPSTREAM_CONCURRENCY`.   |
-| `DEFAULT_UPSTREAM_RETRIES`          | const | Sets the retries one upstream request is given when a caller names none.                         |
-| `DEFAULT_UPSTREAM_TIMEOUT`          | const | Sets the timeout one upstream request is given when a caller names none, in milliseconds.        |
-| `DIGEST_PATTERN`                    | const | Matches the exact SHA-256 syntax a digest is stated in: sixty-four lowercase hexadecimal digits. |
-| `DRIVE_PATTERN`                     | const | Matches the drive prefix a Windows host path may open with.                                      |
-| `INVALID_SEGMENT_CHARACTER_PATTERN` | const | Matches the visible characters no host path segment may carry.                                   |
-| `MANIFEST_NAME`                     | const | Reserves the metadata name a staged vendored host writes at its own root.                        |
-| `MAX_BRANCH_LENGTH`                 | const | Caps the characters one repository branch may carry.                                             |
-| `MAX_ENDPOINT_LENGTH`               | const | Caps the characters one caller-supplied upstream endpoint may carry.                             |
-| `MAX_INVENTORY_PATHS`               | const | Caps the paths one target's working-tree inventory may report.                                   |
-| `MAX_PATH_DEPTH`                    | const | Caps the segments one host path may carry.                                                       |
-| `MAX_PATH_SEGMENT_BYTES`            | const | Caps the UTF-8 bytes one host path segment may encode to.                                        |
-| `MAX_UPSTREAM_CONCURRENCY`          | const | Caps the simultaneous upstream requests.                                                         |
-| `MAX_UPSTREAM_RETRIES`              | const | Caps the retries one upstream request may be given after a transport fault.                      |
-| `MAX_UPSTREAM_TIMEOUT`              | const | Caps the timeout one upstream request may be given, in milliseconds.                             |
-| `ORKESTREL_SCOPE`                   | const | Names the npm scope and repository owner the fleet's packages and sources are published under.   |
-| `PACKUMENT_MEDIA_TYPE`              | const | Names the media type that selects the registry's abbreviated packument.                          |
-| `RESERVED_SEGMENT_PATTERN`          | const | Matches the Windows device names that stay reserved even when an extension follows.              |
-| `SCAFFOLD_REPOSITORY`               | const | Names the repository this package's own vendored files are served from.                          |
-| `UNREADABLE_VERSION_NOTE`           | const | Holds the note a release carries when its packument names no readable latest version.            |
+| Name                                | Kind  | Summary                                                                                               |
+| ----------------------------------- | ----- | ----------------------------------------------------------------------------------------------------- |
+| `BRANCH_PATTERN`                    | const | Matches the Git branch syntax the repository endpoint accepts.                                        |
+| `DEFAULT_BRANCH`                    | const | Holds the repository branch a raw content read addresses when a caller names none.                    |
+| `DEFAULT_REGISTRY_BASE`             | const | Holds the registry a version read addresses when a caller names none.                                 |
+| `DEFAULT_REPOSITORY_BASE`           | const | Holds the raw content host a repository read addresses when a caller names none.                      |
+| `DEFAULT_UPSTREAM_CONCURRENCY`      | const | Sets the simultaneous upstream requests a reader opens with, under `MAX_UPSTREAM_CONCURRENCY`.        |
+| `DEFAULT_UPSTREAM_RETRIES`          | const | Sets the retries one upstream request is given when a caller names none.                              |
+| `DEFAULT_UPSTREAM_TIMEOUT`          | const | Sets the timeout one upstream request is given when a caller names none, in milliseconds.             |
+| `DIGEST_PATTERN`                    | const | Matches the exact SHA-256 syntax a digest is stated in: sixty-four lowercase hexadecimal digits.      |
+| `DRIVE_PATTERN`                     | const | Matches the drive prefix a Windows host path may open with.                                           |
+| `INVALID_SEGMENT_CHARACTER_PATTERN` | const | Matches the visible characters no host path segment may carry.                                        |
+| `MANIFEST_NAME`                     | const | Reserves the metadata name a staged vendored host writes at its own root.                             |
+| `MAX_BRANCH_LENGTH`                 | const | Caps the characters one repository branch may carry.                                                  |
+| `MAX_ENDPOINT_LENGTH`               | const | Caps the characters one caller-supplied upstream endpoint may carry.                                  |
+| `MAX_INVENTORY_PATHS`               | const | Caps the paths one target's working-tree inventory may report.                                        |
+| `MAX_PATH_DEPTH`                    | const | Caps the segments one host path may carry.                                                            |
+| `MAX_PATH_SEGMENT_BYTES`            | const | Caps the UTF-8 bytes one host path segment may encode to.                                             |
+| `MAX_UPSTREAM_CONCURRENCY`          | const | Caps the simultaneous upstream requests.                                                              |
+| `MAX_UPSTREAM_RETRIES`              | const | Caps the retries one upstream request may be given after a transport fault.                           |
+| `MAX_UPSTREAM_TIMEOUT`              | const | Caps the timeout one upstream request may be given, in milliseconds.                                  |
+| `ORKESTREL_SCOPE`                   | const | Names the npm scope and repository owner the fleet's packages and sources are published under.        |
+| `PACKUMENT_MEDIA_TYPE`              | const | Names the media type that selects the registry's abbreviated packument.                               |
+| `RESERVED_SEGMENT_PATTERN`          | const | Matches the Windows device names that stay reserved even when an extension follows.                   |
+| `SCAFFOLD_REPOSITORY`               | const | Names the repository this package's own vendored files are served from.                               |
+| `UNREADABLE_VERSION_NOTE`           | const | Holds the note a release carries when its packument names no readable version under the `latest` tag. |
 
 #### Guards
 
@@ -538,7 +538,7 @@ publishes no interface and is documented directly.
 
 | Method    | Summary                                                                                     |
 | --------- | ------------------------------------------------------------------------------------------- |
-| `lookup`  | Looks up the newest release each declared range admits.                                     |
+| `lookup`  | Looks up the highest release each declared range admits.                                    |
 | `fetch`   | Fetches each named package's guide, beside the local mirror it answers for.                 |
 | `read`    | Reads each named vendored file from the repository, beside the target bytes it answers for. |
 | `catalog` | Catalogs the published fleet from the registry's organization package list.                 |
@@ -1846,7 +1846,7 @@ An edge counts only when it names a package this catalog publishes. An edge leav
 edge to a row that found no version each constrain nothing, so neither holds its dependent back.
 
 The order is load-bearing because these packages are `0.0.x`, where a caret pins one exact release.
-A dependent sees a new dependency version only after the dependent re-pins and republishes, so
+A dependent sees an updated dependency version only after the dependent re-pins and republishes, so
 publishing a dependent before its dependency leaves the dependent pinned to the older release.
 Ranges that disagree install duplicate copies of one package, and the compiler reads those copies as
 distinct types.
@@ -1860,8 +1860,8 @@ lookup verdict records why the registry row could not enter a layer.
 ## Dependency floors
 
 Except for the selected showcase policy, every scaffold-owned runtime or development range is a floor: a caret over a whole
-`major.minor.patch` version. The triple is the newest release the registry served when that floor
-was last raised, so a workspace generated with no network still receives the latest floor scaffold
+`major.minor.patch` version. The triple is the highest release the registry served when that floor
+was last raised, so a workspace generated with no network still receives the declared floor scaffold
 knew rather than a bare `major.0.0`. A `Blueprint.peers` row is written during creation into a
 vacant target. After creation, peer declarations and `peerDependenciesMeta` are caller-owned:
 `audit`, `repair`, `catalog`, and `overwrite` do not invent, rewrite, insert, or remove them. Caller
@@ -1869,7 +1869,7 @@ extras pass through unchanged except for the selected showcase pair. Extras foll
 `ORKESTREL_RANGE_PATTERN`; foreign peers follow `FLOOR_RANGE_PATTERN`.
 
 A browser application with `showcase: true`, including its Vue face, selects exact
-`vite-plugin-singlefile: 2.3.3`, Vite `^8.3.4` from scaffold's manifest, and the npm override
+`vite-plugin-singlefile: 2.3.3`, Vite `^8.3.5` from scaffold's manifest, and the npm override
 `"vite-plugin-singlefile@2.3.3": { "micromatch": "npm:picomatch@2.3.2" }`. This policy applies
 after extras. Online resolution excludes this pair from ordinary foreign-major updates; other
 dependencies retain their usual resolution. Repair preserves each package's runtime or development
@@ -1895,7 +1895,7 @@ The floors live in scaffold's own `package.json`. `BASE_DEV_DEPENDENCIES` and th
 derive each row scaffold installs from that manifest, and the self-pin from its `version` field, so
 the toolchain a generated workspace receives is the toolchain scaffold runs. The rows scaffold does
 not install are seeds — `@vitejs/plugin-vue`, `vue`, `vue-tsc`, `vite-plugin-singlefile`, and the
-application-server fleet packages — and each carries the newest triple its supported major served
+application-server fleet packages — and each carries the highest triple its supported major served
 when it was written.
 [`tests/src/core/constants.test.ts`](../tests/src/core/constants.test.ts) names that seeded set, so a
 row entering or leaving the manifest moves a test rather than passing unnoticed. `sass`, the one row
@@ -1936,7 +1936,7 @@ committed before a later catalog refusal and records that refusal in `note`.
 
 A fleet row is compared exactly — `^0.1.0` is stale the moment the registry serves `0.1.2` — and
 that inequality alone raises `audit` to exit `1`. A foreign row is compared inside its declared
-major, and each verdict is a non-blocking question: one for a floor below the newest release that
+major, and each verdict is a non-blocking question: one for a floor below the highest release that
 major serves, and one for a newer major the registry publishes.
 
 ### Raising the floor before a release
@@ -1949,7 +1949,7 @@ while the registry is reachable:
 2. Run `scaffold repair`, or `npm update` followed by the same audit, until no question remains.
 3. Run the gate chain, then bump the version and publish.
 
-That cycle is what keeps every release shipping the then-latest floor, and it is what a consumer
+That cycle is what keeps every release shipping the registry floor read for that release, and it is what a consumer
 generating a workspace with no network receives.
 
 ## Vendored data root
@@ -1963,7 +1963,7 @@ licence, the harness permission file, the scaffold-owned `scripts` directory, th
 shared policy register, the shared policy proof, the shared policy plugin, the shared configuration
 leaf and its proof, and the byte-identical root dotfiles. The session-start hooks inside `scripts`
 split by job. The bench probe reports whether a bench CLI resolves. In a remote session one command
-runs three hooks in order: the npm hook installs the newest npm in the major of the floor the
+runs three hooks in order: the npm hook installs the highest npm in the major of the floor the
 workspace's `devEngines` record declares when the container's npm is older, the dependency hook
 installs the lockfile's closure, and the browser hook installs the Chromium builds the
 `playwright-core` package pins when the container's browser store lacks them.
@@ -2418,10 +2418,10 @@ verdict carrying its cause rather than thrown, so one unreachable package never
 rest of the answer. The organization package list is the exception, because without it there is no
 fleet to report.
 
-A found verdict carries the newest version the declared range admits, not whatever `dist-tags.latest`
+A found verdict carries the highest version the declared range admits, not whatever `dist-tags.latest`
 names. `lookup` reads the packument's version map, selects across it before any collection bound can
-truncate the map, and falls back to the latest tag only when that tag is itself admitted. A range of
-`*` admits every version, which is how a caller asks for the newest release outright.
+truncate the map, and falls back to the `latest` tag only when that tag is itself admitted. A range of
+`*` admits every version, which is how a caller asks for the highest release outright.
 
 Each bound counts decoded bytes, and a version lookup asks the registry for the abbreviated
 packument — `dist-tags` and a trimmed version map, rather than the full per-version metadata no

package/dist/host/manifest.json

@@ -538,7 +538,7 @@
 			"storage": "claude/agents/orkestrel.md",
 			"destination": ".claude/agents/orkestrel.md",
 			"executable": false,
-			"digest": "0f1f2ca81f4f3d068111443bc3f732a7abe3450350bdc382bea33ccbf514e7b0"
+			"digest": "3a8756c323e1ea31e2f9879ed9a14477c34ed5eef1654c60d760a7357cff2f48"
 		},
 		{
 			"storage": "claude/agents/planner.md",
@@ -898,7 +898,7 @@
 			"storage": "guides/agent.md",
 			"destination": "guides/agent.md",
 			"executable": false,
-			"digest": "b5fa296bf5337e11da8e0c78ec8adbbb76ceb5c3261c3400b9e8ca9c77951c9e"
+			"digest": "1b3c160ae18fe5c8d726a67e0a46a8fc4439267d84789cd7437caf0ca75e6d78"
 		},
 		{
 			"storage": "guides/brief.md",
@@ -1090,7 +1090,7 @@
 			"storage": "guides/scaffold.md",
 			"destination": "guides/scaffold.md",
 			"executable": false,
-			"digest": "145806a4116276ffefc4f2eea08887a7238cb1b572b8f03c1f07392914a7efe7"
+			"digest": "1bca2f3d385aa7ffcc2bbc870e7789e1e6c7b110ca0b772962b0531e1470b7cd"
 		},
 		{
 			"storage": "guides/sea.md",
@@ -2178,5 +2178,5 @@
 			]
 		}
 	],
-	"digest": "f9b542cd1414446dbb503989f51828b56a170084fe804e0ead1c530131c502d8"
+	"digest": "bfd5da9b524cab604a72ff7a9f09c3a52beaab8d9229260b2c3279dced3d2ef3"
 }