@inventarch/runtime 3.5.0 → 3.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/SPEC.md +1 -1
  2. package/package.json +4 -4
package/SPEC.md CHANGED
@@ -72,7 +72,7 @@ R13. Steward-write evaluation is a bounded pure consumer over admitted compiled
72
72
 
73
73
  R14. Scope key. `src/scope-key.ts` holds it: the package root exports `K0`, `SCOPE_KEY_CAPS`, `normalizeScopeKey`, `resolveScopeKey` and `rootRelative` with the `ScopeKey`, `ResolvedSeat` and `ResolvedScopeKey` types, and the `./internal/scope-key` subpath carries the module; `scopeCoordinate` (R01) is in `src/coordinate.ts`, on the `./internal/coordinate` subpath only. `ScopeKey` is K = (seat, shape, phase, depth, budget, word), with an optional primitive override: `shape` one of the five SHAPE_ROWS shapes, `phase` one of the four phases, `depth` an integer in 0..2, `budget` an integer in 0..64 and `word` optional; `SCOPE_KEY_CAPS` exports the two caps, and `K0` is the frozen key (no seat, context, orient, 0, 0, no word). Three seat notions are kept apart, each named once here. The key's `seat` is what a caller names: absent for the repository's own `@workspace`, a record identity, or `{path}` for a location. The resolved seat (`ResolvedSeat`) is what that names once read through the scope: `{kind, identity?, path?, unknown?}`, kind `workspace` for no seat (identity the repository's `@workspace`), `record` for an identity (identity that record) and `location` for a path (path its canonical workspace-relative path; a location is not a record and has no identity). The database's `SeatResolution.seat` (db D02b) is the record a path is declared at, a `@system` or `@workspace`; it stays in the result's `resolution` with the rule `by` and the path's claimants, and is never a location's resolved seat. `normalizeScopeKey(partial?)` completes a partial key with its defaults, the one place every host applies them: a partial that names no part (a part whose value is undefined is not named) is K0; otherwise `shape` defaults to context, `phase` to the anchor of the explicit primitive or the shape's primitive, PRIMITIVE_ANCHORS[primitive ?? SHAPE_ROWS[shape].primitive] (context orient, governance plan, execution act, sequence plan, learning learn), `depth` to 1 and `budget` to 16, and a seat, word or primitive override stays absent unless named. It reads nothing, so it checks the key's form and leaves the word and the seat to resolution. `resolveScopeKey(handle, within, key)` requires a scope token like every runtime read, checks a complete key and returns a frozen `{key, seat, resolution?, coordinate}`: `key` copies the validated parts in K order, a location as the canonical path it resolved to, so a key never carries the root; `seat` is the resolved seat; `resolution` is the database's resolution of the repository root `''` or of the path, for a workspace or location seat; and `coordinate` is scopeCoordinate's (R01), shape and phase declared, category derived, primitive declared when supplied and otherwise derived. Every key refusal is IA-RUNTIME-REQUEST-INVALID naming the closed set or bound: an unknown part, a shape, phase or primitive outside its closed set, a depth or budget outside its cap or not an integer, a seat that is neither an identity nor `{path}`, a word the read's view does not register for its admitted systems (db D09a `words`), the refusal listing those it does, an identity that is not an admitted record in the scope, and a path outside the workspace root or escaping it. The key's parts, closed sets, caps and seat form are checked before any read, so a key malformed in them is refused whatever the token. An absolute path reads by `rootRelative(root, path)`, the one absolute-path rule, which `ia read` also reads the path of a `<path>:<line>` locator with (2026-10-08, which gave the two one rule): the path from the handle's root that Node's `path.relative` gives (on Windows without case, with either separator), `/`-separated, and the root itself, however it is spelled, as `''`, the location that `.` also names (`ia read`, whose line locator needs a path, spells it `.`). It names no path inside the root, so it is undefined and the path goes on as given, refused below, when that path's first segment is `..`, a check made segment by segment, so an in-root name that only begins with `..`, such as `..cache`, is inside the root whichever way it is spelled, or when the path is on another drive, which has no path from the root. A relative path goes as given to the database's `resolveSeat` (db D02b), as does the path `rootRelative` reads, and the database canonicalises it segment by segment and names one that escapes the workspace `outside`, refused here: a `..` segment escapes. No seat takes the seat the database resolves for `''`: the `@workspace` declaring a `sources` root of the whole repository, else the repository's own `@workspace` as D02b decides it. When no admitted record in the scope is declared at a workspace or location seat, the resolved seat names `unknown: 'undeclared'`, and a workspace seat then has no identity: K0 is the empty composition with the unknown named, never a refusal (db D02b). Database token failures (SCOPE-UNAVAILABLE, STALE, CLOSED) keep their IA-DB codes on every read the resolution makes: the word's, the identity's and the path's. This row types, completes, validates and resolves the key; R15 assembles the body a resolved key gives (seeding, pointers to 48 then tallies, the word's restriction of seeds and tallies, blockers reserved outside the budget), and `position` (R16) completes, resolves and assembles a key with its digest and host note. The Door's `position` operation reads a key (R12 refinement, position); the nine version 1 Door routes, `context` and `select` included, and `ia scope` neither read nor accept one, and the consumer verb is `ia position`. Each key refusal's `RuntimeError` carries `next`, the one command to run: the closed set of a shape or phase, the cap of a depth or budget, `ia vocabulary` for a word, and `ia position`, K0, for a key that is no object or names an unknown part and for a seat of another form, outside the scope or outside the workspace. `RuntimeError` gains the optional `next` for it, absent from every other refusal. `tests/scope-key.test.ts` pins the caps and K0; the defaults, an empty partial being K0 and every shape's anchor phase; a key naming only a shape resolved, and depth 3 and budget 65 refused; a key completed from shape and phase alone for every shape and phase; the unchanged version 1 refusal bytes of a context or select request that declares only shape and phase; the closed sets, caps and seat form refused by both functions, an unknown part and a key that is no object naming `ia position` as `next`, and the key's form refused before a forged token is read; the token on every seat form and the word, a forged, stale or closed one keeping its database code; the registered word checked in the scope's own view; each seat form and a location pruned by a narrower scope; absolute paths inside the root, in native, forward and mixed separators (and on Windows with the drive letter in either case), read as the relative path, the root in every spelling as the location `''`, an in-root name beginning with `..` read alike in both spellings, and absolute paths outside the root (a sibling whose name extends the root's among them), escaping paths and another drive refused; `rootRelative` itself on each of those spellings, a relative path returned as given; K0 seated by a workspace that declares the whole repository as a root; and K0 with the repository workspace undecided.
74
74
 
75
- R15. Position body (2026-10-08): `src/position.ts`, exported from the package root and the `./internal/position` subpath, publishes `positionBody(handle, within, resolved)` with the `PositionBody`, `LoadedEntry`, `LoadedPlace`, `LoadedRecord`, `PositionRecord`, `PositionPointer`, `PositionVia`, `PointerTally`, `FrontierTally`, `PositionUnknown`, `PositionCounts` and `PositionWidening` types. `resolved` is what resolveScopeKey (R14) returned for the same scope token `within`. Every read carries that token: the snapshot and its D02a membership rows, directed views (db D09), the declared roots (db D02c `roots`) and the seat of `''` (D02b); a missing token is IA-RUNTIME-REQUEST-INVALID, and an unknown, stale or closed one keeps its database code, and a resolved seat identity the token does not admit (a key resolved through another token) is IA-RUNTIME-REQUEST-INVALID, `The seat '<identity>' is not an admitted record in this scope`, naming as its `next` `ia position`, the position without that seat, as R14 names it for a seat outside the scope. body(K) is a pure function of the key and the admitted records the token reads, and only a whole-workspace token (db `isCompleteScope`, PT5) also reads the admission findings it alone may disclose: it carries no root path, token, time, request text, capture state or record body (a body is read on demand by `ia read`; R17's cells carry a playbook cell's text, not its record's body), and nothing is written. A record at runtime placement (band 0) is no part of a body (2026-10-08: runtime-band evidence is admitted below authored, where it must not move what agents are given): the body reads the scope's records without those records and without every directed-view row and claimant that names one, so none is composition, a seed, a hop or waypoint, loaded, in `rules`, a pointer, tallied or frontier, none primes, reaches or names the steward of another record, and none claims a location or is the record one is declared at, so a location whose declarer and claimants are all at runtime placement names the `seat` unknown it would name without them; a seat at runtime placement, whether the key names it or it is the repository's own `@workspace` (K0 included), is IA-RUNTIME-REQUEST-INVALID, `The seat '<identity>' is at runtime placement (band 0), which no position body enters`, whose `next` (2026-10-08, moved here from the Door) is `ia inspect`, the overview, when the seat is the one K0 takes, the repository's own `@workspace` (`resolveSeat('')`), whether the key names it or not, since K0 is refused alike, and `ia position`, the position without it, for any other seat. Two inputs still read every placement, so a runtime-band record appearing can still move the body. The database's own decisions: a runtime-band `@workspace` or `@system` can move the D02a membership roots, the D02c declared roots, the D02b seat of a path and the repository's own `@workspace` that the closure is built from, and a location's resolved `seat` (R14) then names no `unknown` while `unknowns` names the seat. Admission's findings, which resolve every reference against every placement: a runtime-band record that an edge or field reference of an authored loaded record names resolves it, so that record's IA-GRAPH-TARGET-MISSING or IA-COMP-FIELD-REF-MISSING `finding` leaves `unknowns`, and the row to it, naming a band-0 record, is dropped, so the body names that relation neither as a pointer nor as an unknown. The body's `revision` is not one of them: it is the authored revision of the view the scope reads (db D05a), which no runtime-band source moves (R16). It is `{format: 'ia.position-body.v1', revision, key, seat, loaded, rules, pointers, pointerTallies, appliesByWord, appliesByWordTallies, cells, mandates, frontier, unknowns, counts, widening}`, `key` and `seat` being the resolved key and seat and the four sections after `pointerTallies` R17's. The seat's workspace is the seat when it is a `@workspace`; else, of the repository's own `@workspace`, the one D02b seats `''` at, and the workspace of the first declared root, in D02c order, that contains the D02a membership root of the seat record (for a location, of the record it is declared at), the first whose closure holds that record; else no workspace holds the seat. A floor or adopted record, an installed one included, is in every closure, so it is seated in the repository's own workspace with the records the repository authors, even when the installed or adopted `@workspace` that ships it declares the root it sits in, as the bundled base's language-workspace declares `.ia/src @authored` in the store (2026-10-08: the floor, the adopted records and the repository's own roots); the workspace whose root holds the record is taken for an authored record of another workspace's root. A workspace's closure is every floor (band 10) and adopted (band 90) record, plus the members of its own declared roots or, while it declares none, every record whose membership root no workspace declares; when no workspace holds the seat, the closure is that fallback. Reading the closure as the declared members alone would leave a repository without a declared root (the conformance corpus, and every repository an earlier `ia init` made, which declared none) unable to reach any record of its own; and falling back to the repository's workspace whatever its roots would, when none of them holds the seat record, leave the seat outside its own closure (the seat S always resolves inside it) and its own system's blocking governance out of `rules`. Both fallbacks are named under `unknowns`. A record outside the closure is never entered: it is a pointer that names, as `workspace`, the `@workspace` whose declared root holds it, when one does. The composition C0, at cost 0 and one level from the seat, is the seat's field references both ways (directed-view `field-ref` rows); a `@workspace` seat's capture members, the membership rows under its own declared roots; a `@system` seat's word members, the admitted records whose owner system it is; and a location's declared-at record and claimants from `resolution`. A location is no record and has no fields, and a workspace seat no record declares has an empty composition. The first class that reaches a C0 record is its `via`, unless a hop reaches it (below): `field` (`from`, `field`, `direction`, read from `from`'s side), `membership` (`root`), `word` (`system`), `declared-at` (`rule`) or `claim` (`matches`); C0 counts only what the closure admits, a composition record a hop reaches included. The seeds Σ are the seat and the C0 records whose kind is in SHAPE_ROWS[shape].kinds or whose lane, graph `laneOf` (G05), is in its lanes. Hops 1..depth start from Σ and follow directed-view edge rows only, declared or derived inverse, in either direction, whose predicate is in SHAPE_ROWS[shape].predicates, never leaving the closure; each record other than the seat and the seeds that a hop reaches, a C0 record among them, keeps the first row that reaches it, from the seat, then the seeds and each later hop in identity order, as `via: {by: 'row', from, predicate, spelling, declaredBy}`, and is in C. A row that carries a condition is a row of the body only where its condition holds at the key's coordinate (2026-10-08): graph `conditionHolds` over the coordinate R14's scopeCoordinate builds, the key's shape and phase with the derived category and selected primitive, the condition's subject being the record that states the row (its `declaredOn`, the author graph G06 keeps as an edge's condition subject), so the body agrees with graph traversal for the same coordinate. A row that does not hold is not followed and its counterpart is not reached through it: it is no hop, primes no record, names no out-of-focus pointer and counts in no frontier, while a field reference carries no condition. The phase can so change the loaded set; a body whose rows carry no condition is unchanged by it. The conformance corpus's fixture law `enforced-by @check instance-schema-check when phase is act and severity is blocking` reaches the check at act only. With `word` set (the word restricts seeds and tallies inside the body, and blockers are reserved outside n), C0, the seeds, the hop-reached records that load, the pointers, their tallies and the frontier are records of that word only; a record of another word that a hop reaches is a waypoint, followed but never loaded or listed; the seat loads whatever its word. The word never filters `rules` (2026-10-08: a word must not hide a blocking rule that governs what it loads, as one claiming a location seat or applying by its subject-word to a record of the word would be hidden if R were read under the word): R is taken from the candidates of the walk without the word, each with the row or class that reaches it there, so `rules` under a word is the body's without it, and R17's applies-by-word section with its tallies, its cells and the mandates are not filtered either. The order keys are total: governance (prime ↑, band ↓, hop ↑, sev ↑, identity ↑) and every other shape (band ↓, hop ↑, lane ↑, identity ↑). prime is the least index in SHAPE_ROWS.governance.priming (govern, constrain, forbid, enforce, implement) of an edge row incident to the record, else 5; sev is the rank of graph `effectiveSeverity` in [blocking, advisory, informational], a record with none last; lane is its index in the shape's lanes, else their count; hop is 0 for Σ and for a C0 record no hop reaches, else the first hop that reached it. The candidates K = {S} ∪ C0 ∪ Σ ∪ C, C the hop-reached records, are taken before any truncation and before the word filter, and `rules` is R, the governance-kind candidates other than the seat whose effective severity is blocking, with the blocking rules that apply by word to a candidate (R17), in the governance order and never counted against the budget, so a blocking law that claims a location only through `subject.covers` is in `rules` at budget 0. `loaded` is the seat, then the first `budget` records of ((Σ \ {S}) ∪ C) \ R in the shape's order. A record seat loads as a `LoadedRecord`; a location, or a workspace seat no record declares, as the `LoadedPlace` `{path}` of its canonical path (`''` for the latter). A `LoadedRecord`, and each entry of `rules`, is the pointer tuple plus the record's G13 `digest`. `pointers` are the C0 and hop-reached records outside `loaded` and `rules`, those the budget truncated among them; the records outside the closure that composition or a hop reached; and the counterparts of each loaded record's out-of-focus edge rows and field references, at that record's hop. Each is listed once, by the first that reaches it, in the shape's order, as the pointer 9-tuple `{identity, word, kind, lane, system, steward?, band, hop, via}`, `system` being the owner system and `steward` the `head.steward` field reference of its `@system` record (`floor/definition/system/<name>`) when the scope admits it, read without the registry. The first 48 are listed, and the rest are tallied per (word, owner system) as `{system, word, steward?, count}`, sorted by system then word. `frontier` tallies per (owner system, kind), as `{system, kind, steward?, count}`, the counterparts of the in-focus rows of the loaded records at hop `depth` that the body neither lists nor reached, never entered. `unknowns` are `{kind, subject?, code?, path?, line?, message}`: `seat` for a location no admitted record is declared at, a location that nothing claims and none is declared at (`no record claims '<path>' and none is declared at it; widening key: the workspace`, or on a narrowed scope, which prunes the claimants it does not admit, `no record in this scope claims '<path>' and none in it is declared at it; widening key: the workspace`), or the repository root no `@workspace` is declared at; `sources` when the seat's workspace declares no sources (`workspace declares no sources: …`) or no workspace holds the seat; `finding`, read only on a whole-workspace scope (db PT5, as R18 reads admission findings), each IA-GRAPH-TARGET-MISSING, IA-GRAPH-TARGET-AMBIGUOUS, IA-GRAPH-EDGE-UNCONSENTED and IA-COMP-FIELD-REF-MISSING report finding on the source span of a loaded record, the innermost one, with its code, path, line and message; and `unread` on a narrowed scope, which reads none. `counts` are `{composition: |C0|, seeds: |Σ| with the seat, loaded: |L| with the seat, rules, pointers (listed and tallied), appliesByWord (R17), frontier, truncatedLoaded, truncatedPointers, truncatedAppliesByWord}`. `widening` is `{deeper: the key at depth + 1, absent at depth 2; reseat: {shape, phase, primitive?, depth: 1, budget: 16}}`, to be seated at any pointer, no seat being the repository's workspace. `position` (R16) returns the body with its digest and host note; R17 adds the applies-by-word section, the playbook cells and the mandates; and the Door's version-2 `position` operation and the MCP tool `ia_position` serve it (R12), as does the `ia position` CLI verb (apps/cli/SPEC.md). `tests/position.test.ts` pins, over the conformance corpus, golden bodies of K0, governance at the fixture law (at plan, where its conditional `enforced-by` row does not hold, and at act, where it does), sequence at depth 2 from the workspace and the word law at the governance-system seat, in `tests/golden/` with the revision masked and asserted apart (only `node packages/runtime/tests/golden/write.mjs` regenerates them); K0's single loaded seat, five system pointer lines from `composition.systems`, frontier and named missing sources; byte-equal bodies for equal keys through every whole-workspace token and handle of one revision, and a token selecting every admitted identity differing only by the `unread` note; hops in either direction, out-of-focus pointers and a seed a later hop reaches keeping hop 0; each order key deciding in turn (band, then hop, then lane in the other shapes; prime, then band, an adopted record against a local one, then hop, then sev in governance) and two blocking laws in `rules` in the governance order under governance and context; seeds picked by kind and by lane (an authority-facet contract); the counts of a budget below |Σ ∪ C| and one tally past 48 per word and owner system; the word law loading the seat and only laws, waypoints and only-law pointers, tallies and frontier; a location seat claimed only through `subject.covers` by a blocking law at budget 0, the law in `rules`, not a pointer, the seat alone loaded; a location nothing claims, and one claimed but declared at no record; a record of another workspace's root never entered and named as a pointer, whether a hop or the seat's `composition.systems` reaches it, and not listed under a word it is not of; a location in that root's system folder, closed in that workspace; an adopted `@system` seated in the repository's workspace though its adopted `@workspace` declares the root it sits in, the repository's own blocking law of its word reserved; a conditional row followed at each phase exactly where graph traversal follows it for the key's coordinate, from either side and with its severity term read from the record that states it, and a task reached through a conditional requirement only at the phase it names; the narrowed location unknown; K0 with the repository workspace undecided; a seat no declared root holds, under the fallback closure and named, its blocking law still in `rules`; on a whole-workspace scope, missing targets, unconsented rows and missing field references named on the loaded record whose span holds them, never on an earlier record of the file or on a pointer, and the `unread` note on a narrowed one; and the token. `tests/purity.test.ts` pins the runtime-placement rule (R16). The conformance corpus places no source at runtime, so the rule leaves the golden bodies unchanged.
75
+ R15. Position body (2026-10-08): `src/position.ts`, exported from the package root and the `./internal/position` subpath, publishes `positionBody(handle, within, resolved)` with the `PositionBody`, `LoadedEntry`, `LoadedPlace`, `LoadedRecord`, `PositionRecord`, `PositionPointer`, `PositionVia`, `PointerTally`, `FrontierTally`, `PositionUnknown`, `PositionCounts` and `PositionWidening` types. `resolved` is what resolveScopeKey (R14) returned for the same scope token `within`. Every read carries that token: the snapshot and its D02a membership rows, directed views (db D09), the declared roots (db D02c `roots`) and the seat of `''` (D02b); a missing token is IA-RUNTIME-REQUEST-INVALID, and an unknown, stale or closed one keeps its database code, and a resolved seat identity the token does not admit (a key resolved through another token) is IA-RUNTIME-REQUEST-INVALID, `The seat '<identity>' is not an admitted record in this scope`, naming as its `next` `ia position`, the position without that seat, as R14 names it for a seat outside the scope. body(K) is a pure function of the key and the admitted records the token reads, and only a whole-workspace token (db `isCompleteScope`, PT5) also reads the admission findings it alone may disclose: it carries no root path, token, time, request text, capture state or record body (a body is read on demand by `ia read`; R17's cells carry a playbook cell's text, not its record's body), and nothing is written. A record at runtime placement (band 0) is no part of a body (2026-10-08: runtime-band evidence is admitted below authored, where it must not move what agents are given): the body reads the scope's records without those records and without every directed-view row and claimant that names one, so none is composition, a seed, a hop or waypoint, loaded, in `rules`, a pointer, tallied or frontier, none primes, reaches or names the steward of another record, and none claims a location or is the record one is declared at, so a location whose declarer and claimants are all at runtime placement names the `seat` unknown it would name without them; a seat at runtime placement, whether the key names it or it is the repository's own `@workspace` (K0 included), is IA-RUNTIME-REQUEST-INVALID, `The seat '<identity>' is at runtime placement (band 0), which no position body enters`, whose `next` (2026-10-08, moved here from the Door) is `ia inspect`, the overview, when the seat is the one K0 takes, the repository's own `@workspace` (`resolveSeat('')`), whether the key names it or not, since K0 is refused alike, and `ia position`, the position without it, for any other seat. Two inputs still read every placement, so a runtime-band record appearing can still move the body. The database's own decisions: a runtime-band `@workspace` or `@system` can move the D02a membership roots, the D02c declared roots, the D02b seat of a path and the repository's own `@workspace` that the closure is built from, and a location's resolved `seat` (R14) then names no `unknown` while `unknowns` names the seat. Admission's findings, which resolve every reference against every placement: a runtime-band record that an edge or field reference of an authored loaded record names resolves it, so that record's IA-GRAPH-TARGET-MISSING or IA-COMP-FIELD-REF-MISSING `finding` leaves `unknowns`, and the row to it, naming a band-0 record, is dropped, so the body names that relation neither as a pointer nor as an unknown. The body's `revision` is not one of them: it is the authored revision of the view the scope reads (db D05a), which no runtime-band source moves (R16). It is `{format: 'ia.position-body.v1', revision, key, seat, loaded, rules, pointers, pointerTallies, appliesByWord, appliesByWordTallies, cells, mandates, frontier, unknowns, counts, widening}`, `key` and `seat` being the resolved key and seat and the four sections after `pointerTallies` R17's. The seat's workspace is the seat when it is a `@workspace`; else, of the repository's own `@workspace`, the one D02b seats `''` at, and the workspace of the first declared root, in D02c order, that contains the D02a membership root of the seat record (for a location, of the record it is declared at), the first whose closure holds that record; else no workspace holds the seat. A floor or adopted record, an installed one included, is in every closure, so it is seated in the repository's own workspace with the records the repository authors, even when the installed or adopted `@workspace` that ships it declares the root it sits in, as the bundled base's language-workspace declares `.ia/src @authored` in the store (2026-10-08: the floor, the adopted records and the repository's own roots); the workspace whose root holds the record is taken for an authored record of another workspace's root. D02b's unique init entry point keeps the repository seat decidable when local domain workspaces declare sources; this does not widen a closure. A repository and a domain that need the same local records must both declare those membership roots explicitly, and private domain roots remain outside other closures. A workspace's closure is every floor (band 10) and adopted (band 90) record, plus the members of its own declared roots or, while it declares none, every record whose membership root no workspace declares; when no workspace holds the seat, the closure is that fallback. Reading the closure as the declared members alone would leave a repository without a declared root (the conformance corpus, and every repository an earlier `ia init` made, which declared none) unable to reach any record of its own; and falling back to the repository's workspace whatever its roots would, when none of them holds the seat record, leave the seat outside its own closure (the seat S always resolves inside it) and its own system's blocking governance out of `rules`. Both fallbacks are named under `unknowns`. A record outside the closure is never entered: it is a pointer that names, as `workspace`, the `@workspace` whose declared root holds it, when one does. The composition C0, at cost 0 and one level from the seat, is the seat's field references both ways (directed-view `field-ref` rows); a `@workspace` seat's capture members, the membership rows under its own declared roots; a `@system` seat's word members, the admitted records whose owner system it is; and a location's declared-at record and claimants from `resolution`. A location is no record and has no fields, and a workspace seat no record declares has an empty composition. The first class that reaches a C0 record is its `via`, unless a hop reaches it (below): `field` (`from`, `field`, `direction`, read from `from`'s side), `membership` (`root`), `word` (`system`), `declared-at` (`rule`) or `claim` (`matches`); C0 counts only what the closure admits, a composition record a hop reaches included. The seeds Σ are the seat and the C0 records whose kind is in SHAPE_ROWS[shape].kinds or whose lane, graph `laneOf` (G05), is in its lanes. Hops 1..depth start from Σ and follow directed-view edge rows only, declared or derived inverse, in either direction, whose predicate is in SHAPE_ROWS[shape].predicates, never leaving the closure; each record other than the seat and the seeds that a hop reaches, a C0 record among them, keeps the first row that reaches it, from the seat, then the seeds and each later hop in identity order, as `via: {by: 'row', from, predicate, spelling, declaredBy}`, and is in C. A row that carries a condition is a row of the body only where its condition holds at the key's coordinate (2026-10-08): graph `conditionHolds` over the coordinate R14's scopeCoordinate builds, the key's shape and phase with the derived category and selected primitive, the condition's subject being the record that states the row (its `declaredOn`, the author graph G06 keeps as an edge's condition subject), so the body agrees with graph traversal for the same coordinate. A row that does not hold is not followed and its counterpart is not reached through it: it is no hop, primes no record, names no out-of-focus pointer and counts in no frontier, while a field reference carries no condition. The phase can so change the loaded set; a body whose rows carry no condition is unchanged by it. The conformance corpus's fixture law `enforced-by @check instance-schema-check when phase is act and severity is blocking` reaches the check at act only. With `word` set (the word restricts seeds and tallies inside the body, and blockers are reserved outside n), C0, the seeds, the hop-reached records that load, the pointers, their tallies and the frontier are records of that word only; a record of another word that a hop reaches is a waypoint, followed but never loaded or listed; the seat loads whatever its word. The word never filters `rules` (2026-10-08: a word must not hide a blocking rule that governs what it loads, as one claiming a location seat or applying by its subject-word to a record of the word would be hidden if R were read under the word): R is taken from the candidates of the walk without the word, each with the row or class that reaches it there, so `rules` under a word is the body's without it, and R17's applies-by-word section with its tallies, its cells and the mandates are not filtered either. The order keys are total: governance (prime ↑, band ↓, hop ↑, sev ↑, identity ↑) and every other shape (band ↓, hop ↑, lane ↑, identity ↑). prime is the least index in SHAPE_ROWS.governance.priming (govern, constrain, forbid, enforce, implement) of an edge row incident to the record, else 5; sev is the rank of graph `effectiveSeverity` in [blocking, advisory, informational], a record with none last; lane is its index in the shape's lanes, else their count; hop is 0 for Σ and for a C0 record no hop reaches, else the first hop that reached it. The candidates K = {S} ∪ C0 ∪ Σ ∪ C, C the hop-reached records, are taken before any truncation and before the word filter, and `rules` is R, the governance-kind candidates other than the seat whose effective severity is blocking, with the blocking rules that apply by word to a candidate (R17), in the governance order and never counted against the budget, so a blocking law that claims a location only through `subject.covers` is in `rules` at budget 0. `loaded` is the seat, then the first `budget` records of ((Σ \ {S}) ∪ C) \ R in the shape's order. A record seat loads as a `LoadedRecord`; a location, or a workspace seat no record declares, as the `LoadedPlace` `{path}` of its canonical path (`''` for the latter). A `LoadedRecord`, and each entry of `rules`, is the pointer tuple plus the record's G13 `digest`. `pointers` are the C0 and hop-reached records outside `loaded` and `rules`, those the budget truncated among them; the records outside the closure that composition or a hop reached; and the counterparts of each loaded record's out-of-focus edge rows and field references, at that record's hop. Each is listed once, by the first that reaches it, in the shape's order, as the pointer 9-tuple `{identity, word, kind, lane, system, steward?, band, hop, via}`, `system` being the owner system and `steward` the `head.steward` field reference of its `@system` record (`floor/definition/system/<name>`) when the scope admits it, read without the registry. The first 48 are listed, and the rest are tallied per (word, owner system) as `{system, word, steward?, count}`, sorted by system then word. `frontier` tallies per (owner system, kind), as `{system, kind, steward?, count}`, the counterparts of the in-focus rows of the loaded records at hop `depth` that the body neither lists nor reached, never entered. `unknowns` are `{kind, subject?, code?, path?, line?, message}`: `seat` for a location no admitted record is declared at, a location that nothing claims and none is declared at (`no record claims '<path>' and none is declared at it; widening key: the workspace`, or on a narrowed scope, which prunes the claimants it does not admit, `no record in this scope claims '<path>' and none in it is declared at it; widening key: the workspace`), or the repository root no `@workspace` is declared at; `sources` when the seat's workspace declares no sources (`workspace declares no sources: …`) or no workspace holds the seat; `finding`, read only on a whole-workspace scope (db PT5, as R18 reads admission findings), each IA-GRAPH-TARGET-MISSING, IA-GRAPH-TARGET-AMBIGUOUS, IA-GRAPH-EDGE-UNCONSENTED and IA-COMP-FIELD-REF-MISSING report finding on the source span of a loaded record, the innermost one, with its code, path, line and message; and `unread` on a narrowed scope, which reads none. `counts` are `{composition: |C0|, seeds: |Σ| with the seat, loaded: |L| with the seat, rules, pointers (listed and tallied), appliesByWord (R17), frontier, truncatedLoaded, truncatedPointers, truncatedAppliesByWord}`. `widening` is `{deeper: the key at depth + 1, absent at depth 2; reseat: {shape, phase, primitive?, depth: 1, budget: 16}}`, to be seated at any pointer, no seat being the repository's workspace. `position` (R16) returns the body with its digest and host note; R17 adds the applies-by-word section, the playbook cells and the mandates; and the Door's version-2 `position` operation and the MCP tool `ia_position` serve it (R12), as does the `ia position` CLI verb (apps/cli/SPEC.md). `tests/position.test.ts` pins, over the conformance corpus, golden bodies of K0, governance at the fixture law (at plan, where its conditional `enforced-by` row does not hold, and at act, where it does), sequence at depth 2 from the workspace and the word law at the governance-system seat, in `tests/golden/` with the revision masked and asserted apart (only `node packages/runtime/tests/golden/write.mjs` regenerates them); K0's single loaded seat, five system pointer lines from `composition.systems`, frontier and named missing sources; byte-equal bodies for equal keys through every whole-workspace token and handle of one revision, and a token selecting every admitted identity differing only by the `unread` note; hops in either direction, out-of-focus pointers and a seed a later hop reaches keeping hop 0; each order key deciding in turn (band, then hop, then lane in the other shapes; prime, then band, an adopted record against a local one, then hop, then sev in governance) and two blocking laws in `rules` in the governance order under governance and context; seeds picked by kind and by lane (an authority-facet contract); the counts of a budget below |Σ ∪ C| and one tally past 48 per word and owner system; the word law loading the seat and only laws, waypoints and only-law pointers, tallies and frontier; a location seat claimed only through `subject.covers` by a blocking law at budget 0, the law in `rules`, not a pointer, the seat alone loaded; a location nothing claims, and one claimed but declared at no record; a record of another workspace's root never entered and named as a pointer, whether a hop or the seat's `composition.systems` reaches it, and not listed under a word it is not of; a location in that root's system folder, closed in that workspace; an adopted `@system` seated in the repository's workspace though its adopted `@workspace` declares the root it sits in, the repository's own blocking law of its word reserved; a conditional row followed at each phase exactly where graph traversal follows it for the key's coordinate, from either side and with its severity term read from the record that states it, and a task reached through a conditional requirement only at the phase it names; the narrowed location unknown; K0 with the repository workspace undecided; a seat no declared root holds, under the fallback closure and named, its blocking law still in `rules`; on a whole-workspace scope, missing targets, unconsented rows and missing field references named on the loaded record whose span holds them, never on an earlier record of the file or on a pointer, and the `unread` note on a narrowed one; and the token. `tests/purity.test.ts` pins the runtime-placement rule (R16). The conformance corpus places no source at runtime, so the rule leaves the golden bodies unchanged.
76
76
 
77
77
  R16. Position and host note (2026-10-08): `src/position.ts`, on the package root and the `./internal/position` subpath, also publishes `position(handle, within, partial?)` with the `PositionOutput`, `HostNote` and `Freshness` types. It completes `partial` with normalizeScopeKey (R14), resolves the key with resolveScopeKey through the scope token `within`, assembles the body with positionBody (R15) and returns the frozen `{body, digest, hostNote}`, the two outputs of a position, printed together and never merged. `digest` is graph's codec `digest` of the body, the SHA-256 of its canonical JSON text, and the note carries none. Purity: the body is a function of the key and the admitted revision alone. A key's parts are closed (R14), so a partial naming `text`, `token`, `within` or any other part is an unknown part, IA-RUNTIME-REQUEST-INVALID, and nothing text-driven runs, no classifier, search or text ranking; the version 1 `context` and `select` operations stay text-driven and unchanged. The body names no root path (a location seat spelled as an absolute path enters it as its root-relative path), no scope token, no time, no request text and no capture: one key over two copies of a corpus at different roots gives byte-equal bodies and equal digests, a `context` call with any text on the same handle and token leaves both unchanged, and so does writing a capture. The host note is host state, never claimed identical across hosts or working trees: `{revision, capturedRevision?, previousRevision?, freshness, key}`. `revision` is the handle's authored revision (`handle.authoredRevision`, db D05a); `capturedRevision` the authored revision of the capture at `.ia/work/snapshot/current.json` (db D08a) and `previousRevision` the authored revision of the previous root snapshot the handle retains (db D08), each absent when there is none; `freshness` is `current` when the capture is at `revision`, `stale` when it is at another and `no-capture` when there is none; and `key` is the key used, the partial normalizeScopeKey completed, a location as the caller spelled it, while the body's `key` is the resolved one. The handle reads the capture pair once per state, on first use, so a capture written while it is open shows after its `refresh`, the scope token still valid. A position does not require a capture: the body is computed over the live admitted revision, and freshness is a note, never a refusal. The note reports no installed state per command, no CLI or adapter id@version and no classification rule number. Records at runtime placement are no part of the body (R15), so a runtime-band record appearing that no authored record names and that decides no database seat or root leaves it, its `revision` (the authored revision), its digest and the host note byte-equal. Only `handle.revision`, the graph revision that hashes every source at its placement (graph revisionOf), moves. The note compares authored revisions, so a capture taken before stays `current`. A runtime-band record that an authored loaded record's edge or field reference names moves `unknowns` too (R15): admission resolves the reference against every placement, so the record's missing-target or missing-field-reference finding leaves the body. That is the evidence flow itself, an observation an `ia validate` writes at runtime placement that a task's `work.exit-evidence` names. Such evidence can still move body(K) and its digest through `unknowns`, while it leaves the body's `revision` and a capture's freshness unchanged. Refusals are those of the three steps: the key's (R14), the token's (a missing one IA-RUNTIME-REQUEST-INVALID, an unknown, stale or closed one its database code) and a seat at runtime placement (R15), each refusal of the key or its seat carrying `next`. The Door serves it as the `position` operation (R12 refinement, position), the MCP door as `ia_position` and the CLI as the consumer verb `ia position` (apps/cli/SPEC.md). `tests/purity.test.ts` pins, for K0 and seven other keys (two locations among them), byte-equal bodies and digests at two roots, and the digest the codec digest of the body; an absolute location seat root-free in the body and as spelled in the note, with no token in the body; a capture that moves only the note: `no-capture`, then `current` after a refresh with the same token and on a new handle, then `stale` after an edit, the earlier revision captured and previous, which the body names neither; `text`, `token` and `within` refused as key parts, and the token refusals; bodies and digests unchanged by two `context` calls with text, in both rankings; runtime-band records (a blocking law that the check enforces and that claims two paths, and observations of the workspace and of the law) leaving each body, its revision and its digest unchanged while `handle.revision` moves, and a capture current across them, while the same records authored change every one, and a seat at runtime placement refused, a named one and K0's with the repository's own `@workspace` placed so; a location whose only declarer is a runtime-band `@system` naming the seat unknown, its body differing from the body without that `@system` in the resolved seat's `unknown` alone; the limit pinned: a runtime-band check and observation that an authored law's `enforced-by` and a task's `work.exit-evidence` name removing exactly those two findings from the bodies seated at the law and the task; and a key resolved through a whole-workspace token refused through a narrower one that does not admit its seat.
78
78
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@inventarch/runtime",
3
- "version": "3.5.0",
3
+ "version": "3.5.1",
4
4
  "type": "module",
5
5
  "main": "./dist/index.js",
6
6
  "types": "./dist/index.d.ts",
@@ -171,9 +171,9 @@
171
171
  "LANGUAGE.md"
172
172
  ],
173
173
  "dependencies": {
174
- "@inventarch/language": "3.5.0",
175
- "@inventarch/graph": "3.5.0",
176
- "@inventarch/db": "3.5.0"
174
+ "@inventarch/language": "3.5.1",
175
+ "@inventarch/graph": "3.5.1",
176
+ "@inventarch/db": "3.5.1"
177
177
  },
178
178
  "devDependencies": {
179
179
  "@types/node": "^22.19.0",