@inventarch/runtime 3.0.0 → 3.1.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 (50) hide show
  1. package/README.md +63 -14
  2. package/SPEC.md +26 -26
  3. package/dist/door.d.ts +1 -2
  4. package/dist/door.d.ts.map +1 -1
  5. package/dist/door.js +1 -1
  6. package/dist/door.js.map +1 -1
  7. package/dist/editor/index.d.ts.map +1 -1
  8. package/dist/editor/index.js +1 -2
  9. package/dist/editor/index.js.map +1 -1
  10. package/dist/errors.d.ts +3 -3
  11. package/dist/errors.d.ts.map +1 -1
  12. package/dist/locator.d.ts +5 -6
  13. package/dist/locator.d.ts.map +1 -1
  14. package/dist/locator.js +5 -6
  15. package/dist/locator.js.map +1 -1
  16. package/dist/mandate-guard.d.ts +18 -19
  17. package/dist/mandate-guard.d.ts.map +1 -1
  18. package/dist/mandate-guard.js +14 -10
  19. package/dist/mandate-guard.js.map +1 -1
  20. package/dist/mandate-modes.d.ts +46 -46
  21. package/dist/mandate-modes.d.ts.map +1 -1
  22. package/dist/mandate-modes.js +44 -43
  23. package/dist/mandate-modes.js.map +1 -1
  24. package/dist/next.d.ts +9 -9
  25. package/dist/next.d.ts.map +1 -1
  26. package/dist/next.js +6 -6
  27. package/dist/next.js.map +1 -1
  28. package/dist/packet-host.d.ts +26 -28
  29. package/dist/packet-host.d.ts.map +1 -1
  30. package/dist/packet-host.js +9 -10
  31. package/dist/packet-host.js.map +1 -1
  32. package/dist/packet.d.ts +20 -20
  33. package/dist/packet.d.ts.map +1 -1
  34. package/dist/packet.js +10 -10
  35. package/dist/packet.js.map +1 -1
  36. package/dist/position.d.ts +19 -21
  37. package/dist/position.d.ts.map +1 -1
  38. package/dist/position.js +15 -15
  39. package/dist/position.js.map +1 -1
  40. package/dist/render.d.ts +1 -1
  41. package/dist/render.js +1 -1
  42. package/dist/scope-key.d.ts +4 -4
  43. package/dist/scope-key.d.ts.map +1 -1
  44. package/dist/scope-key.js +8 -8
  45. package/dist/scope-key.js.map +1 -1
  46. package/dist/steward.d.ts +4 -5
  47. package/dist/steward.d.ts.map +1 -1
  48. package/dist/steward.js +4 -5
  49. package/dist/steward.js.map +1 -1
  50. package/package.json +4 -4
package/README.md CHANGED
@@ -1,28 +1,77 @@
1
1
  # @inventarch/runtime
2
2
 
3
- Coordinate-based procedure and governance delivery over scoped database reads. [SPEC.md](SPEC.md) owns the behavior and runtime/hosts plan owns delivery.
3
+ [![npm](https://img.shields.io/npm/v/@inventarch/runtime?label=npm)](https://www.npmjs.com/package/@inventarch/runtime) [![Public quality](https://github.com/inventarch/ia/actions/workflows/platform-quality.yml/badge.svg?branch=main)](https://github.com/inventarch/ia/actions/workflows/platform-quality.yml) [![License](https://img.shields.io/badge/license-Apache--2.0-green)](LICENSE) [![Node](https://img.shields.io/badge/node-22.x-brightgreen)](package.json)
4
4
 
5
- The initial classifier and coordinate preparation API validate the native axes, retain declared/profile/derived/absent provenance, and keep shape focus lists separate from scalar selector constraints. Hosts must explicitly declare phase and primitive. A scope key is the other way in: `normalizeScopeKey(partial)` completes K = (seat, shape, phase, depth 0..2, budget 0..64, word) with the design's defaults (a partial naming nothing is `K0`; otherwise context, the anchor phase of the shape's primitive, depth 1 and budget 16), and `resolveScopeKey(handle, within, key)` validates it against the scoped read, resolves its seat to `{kind, identity?, path?, unknown?}` (`workspace` when none is named, the `@workspace` the database seats the repository root at; `record` for an identity; `location` for a path, workspace-relative or absolute inside the root, read by `rootRelative(root, path)`, the absolute-path rule `ia read` shares, whose database resolution, with the record it is declared at and its claimants, is returned beside the seat) and derives its primitive from the shape row, so shape and phase complete it; `K0` and `SCOPE_KEY_CAPS` are exported beside them (SPEC R14). `positionBody` (below) assembles the body a resolved key gives, and the version 1 `context`/`select` requests still need a declared primitive. Use `context(handle, {within, text, coordinate}, {tokens, records})` for scoped cell/governance/selector/subject/text delivery. It returns a packet or an explicit refusal, reserves blocking governance before optional entries, and reports text-estimator usage and separate envelope overhead. `select` applies the same ranking to explicit candidates and refuses ties or missing selector axes. `Door` exposes validated JSON read operations over a private scope issuer; privileged reports require host opt-in. CLI/MCP transports now expose that door. evaluateSteward resolves a system's typed native owner and evaluates an explicitly trusted actor; the steward-hook app owns host identity/path interpretation. Model execution and capability dispatch have separate owners. `@inventarch/runtime/entry` exports `isEntry`, which the `ia`, `ia-mcp-door` and `ia-mcp-service` binaries use to run when a link such as npm's `.bin` entry reaches them. `readBody(handle, locator, {read, mounts})` returns the body behind a locator (an identity, a cell or requirement fragment, or a source path and line) with its SHA-256 and never a certification: a fragment's own text, that of the record's cells at the address or of its requirement; else the document a record's source locator names, or the section under its markdown anchor, read through the host's `read` (an adopted mount's document from the directory `mounts` binds its tree label to); else the record's own `meaning.says`. `ia read` is its consumer.
5
+ > `@inventarch/runtime` turns scoped [`@inventarch/db`](../db/README.md) reads into what agents and hosts consume: position bodies, plan delivery views, record bodies, the position packet for Claude Code and Codex, mandate resolution and the Door machine protocol. `ia position`, `ia next` and `ia read`, the MCP server and the VS Code extension are built on it.
6
6
 
7
- `positionBody(handle, within, resolved)` (also on `@inventarch/runtime/internal/position`) returns body(K), `ia.position-body.v1`, for a key `resolveScopeKey` resolved through the same scope token, and writes nothing: the seat; the composition one level from it at cost 0 (its field references both ways, a workspace seat's capture members, a `@system` seat's word members, a location's declared-at record and claimants); the seeds the shape's kind or lane focus picks from it; the records reached by up to `depth` hops along the shape's predicate focus in either direction, never inside another workspace's declared root, a row that carries a condition followed only where it holds at the key's coordinate, as graph traversal follows it; the blocking governance among those candidates, reserved in `rules` outside the budget; `loaded`, the seat and the first `budget` of the rest in the design's total order; the pointers (the 9-tuple id, word, kind, lane, owner system, steward, band, hop and reaching row or field), 48 listed and the rest tallied per word and owner system; the frontier one hop past `loaded`, tallied per owner system and kind; the unknowns, such as a workspace that declares no sources; the counts; and the two widening keys. The `@law`, `@convention`, `@principle` and `@playbook` records whose `subject.subject-word` or `subject.subject-kind` names the word or kind of a loaded record, or of a blocking candidate reserved in `rules`, are listed in `appliesByWord` as a field match, not a row, each once with its re-seat key (48 listed, the rest tallied); the first four such playbooks give `cells`, each its cell at the key's phase and the shape's primitive as `ia read` reads that address, or the nearest phase with one; a blocking rule that applies by word to any candidate, whatever the budget truncates, is reserved in `rules`; and `mandates` lists the `@mandate` records that claim a location seat or whose `authority.scope` names the seat's workspace (SPEC R17). With a `word`, only records of that word load (the seat loads whatever its word), are pointers or are tallied, and a record of another word a hop reaches is only a waypoint; the word never filters `rules`, `appliesByWord`, `cells` or `mandates`, so it hides no blocking rule that governs what loads. It is a pure function of the key and the admitted records the token reads, and only a whole-workspace token also reads the admission findings it alone may disclose (a narrowed one names that it reads none), with no root path, token, time, capture state or record body in it, only the playbook cells it delivers (SPEC R15). A record at runtime placement (band 0) is no part of it: never composition, a seed, a hop, loaded, a rule, a pointer, a tally or frontier, nor a location's declarer or claimant, and a seat at runtime placement is refused.
7
+ ## ⚡ Quick start
8
8
 
9
- `position(handle, within, partial?)` (on the package root and the same subpath) is the call a host makes: it completes the partial key with `normalizeScopeKey`, resolves it, assembles the body and returns `{body, digest, hostNote}`, `digest` being graph's codec digest of the body and `hostNote` the undigested host state `{revision, capturedRevision?, previousRevision?, freshness, key}`, whose revisions are authored ones (db `authoredRevision`, `capturedAuthoredRevision`, `previousAuthoredRevision`), where freshness is `current`, `stale` or `no-capture` against the capture `ia capture` last wrote and `key` is the key used. Request text and tokens are refused as key parts, so nothing text-driven runs; two roots give one body and digest, and writing a capture moves only the note. The body's revision is the authored revision of the view the scope reads (db `Snapshot.authoredRevision`), which leaves runtime-placed sources out, so one appearing moves neither it, the digest nor the note's freshness, while the handle's `revision` moves, unless it moves an input that revision keeps: a system folder it adds or a `@system` or `@schema` it declares (db SPEC D05a); `ia.position-body.v1` keeps its name. A runtime-band record that changes which authored records admission admits (one repeating an authored requirement id refuses both) leaves the capture untrusted, `no-capture`, until the next `ia capture` (db SPEC D08). Admission's findings and the database's seat and root decisions still read every placement too, so a runtime-band record that an authored loaded record's reference names also takes that reference's missing-target or missing-field-reference finding out of the body's unknowns (SPEC R15, R16). Installed state is not reported yet. The `Door`'s `position` operation serves a position (below), and `ia position` prints one.
9
+ ```sh
10
+ npm install @inventarch/db @inventarch/runtime
11
+ ```
10
12
 
11
- `deliveryView(handle, within, seat?)` (also on `@inventarch/runtime/internal/next`) reads one plan's delivery view through a scope token and writes nothing: its tasks in one prerequisites-first order (ties by milestone, then task), each with the basis lines of its own and its milestone's requirements, a verdict (`exit evidence recorded (…)`, `no declared blocker` or `blocked (…)`) and the five state lines, plus review items and `next`, the `ia position` command for the first task with no declared blocker; its `revision` is the authored revision, so exit evidence at runtime placement moves verdicts, never the revision. What the scope does not read never counts as met: a requirement whose answer lies outside it blocks as unknown, and no milestone is satisfied through its tasks while one may go unread (a narrowed scope, or a refused `@task` or file, which a whole-workspace scope lists as review items). A relation row that carries a condition counts only where it holds at the coordinate the scope binds, as graph traversal decides it: the record that states it decides a provenance or artifact-set term, and a severity term where its own severity decides it at every coordinate; a term on an axis the scope binds no value for (the phase on the whole-workspace scope `ia next` reads, the severity on every scope) leaves it conditional with an unknown basis, never met, and an intent such a row could change is unknown, while one it cannot change at any coordinate reads as it does everywhere. A seat that is no plan, milestone or task, a missing or ambiguous plan and a require cycle are refusals (`NEXT_CODES`), each naming one next command. The `Door`'s `next` operation serves it.
13
+ Read a position and a plan's delivery view from the workspace in the [root README quick start](../../README.md#-quick-start). These reads do not execute the task:
12
14
 
13
- The `Door`'s `read` operation, which `MACHINE_PROTOCOL` version 2 appends with `since: 2` and the MCP tool `ia_read`, serves `readBody` through the door's scope token: `ReadBodyOptions.within` binds every lookup to that scope, and in a scope narrower than the whole workspace a locator no admitted record in it answers is one plain `IA-RUNTIME-READ-UNADMITTED` that names nothing beyond it. A whole-workspace token, one whose scope is at the workspace root with no `phase` or `identities` and was issued under no narrower one (db `isCompleteScope`), such as the initial one of a door opened without a `boundary` or one `scope` issues from it without narrowing it, reads what the root view reads, so its refusal says what the workspace's sources hold, a record admission refused named with its path, line and `reason`, as `next` names one. The door's reader names a document by its workspace-relative path, never by where the server keeps the workspace. The door reads documents through `DoorOptions.read`, by default db `readWorkspaceBytes`, which admits the paths the CLI's workspace file reader admits, within the same 4 MiB, and binds adopted mounts once, when it opens, from the `.ia/workspace.json` bindings, as `ia read` does; so `ia read` returns the Door's body and digest, and refuses a document the Door refuses with the same code. The nine version 1 rows are byte-identical to 1.1.0's. `DoorOptions.protocol` is the protocol version a door serves, by default the table's: a door at version 1 refuses `read` as the unknown operation 1.1.0 refused, and the CLI's machine routes open theirs at version 1, so they stay those nine; on the CLI `ia read` reads a body.
15
+ ```js
16
+ import { open } from '@inventarch/db';
17
+ import { deliveryView, position } from '@inventarch/runtime';
14
18
 
15
- The `Door`'s `next` operation, which `MACHINE_PROTOCOL` version 2 appends with `since: 2` and the MCP tool `ia_next`, takes `{within?, seat?}` and answers with the view `deliveryView` returns through the door's scope token, or with its refusal as that function returns it: a version 2 operation's refusal may carry more than 1.1.0's `{ok, code, message}`, here `next`, the one command to run, and the `plans` or `cycle` it names, while a version 1 operation's refusal, and every refusal the Door raises itself, keep that shape. A door serving version 1 refuses `next` as an unknown operation, so the CLI's machine routes do not serve it; on the CLI `ia next` prints the view.
19
+ const workspace = open('path/to/your-project', { cache: false, checks: 'structural' });
20
+ try {
21
+ const { token } = workspace.resolveScope();
22
+ const { body } = position(workspace, token, {
23
+ seat: 'work-system/definition/task/write-schema',
24
+ shape: 'sequence',
25
+ });
26
+ console.log(body.key.phase, body.loaded.map(({ identity }) => identity));
27
+ const delivery = deliveryView(workspace, token, 'work-system/definition/plan/public-api');
28
+ if (delivery.ok) console.log(delivery.view.next);
29
+ } finally {
30
+ workspace.close();
31
+ }
32
+ ```
16
33
 
17
- The `Door`'s `position` operation, which `MACHINE_PROTOCOL` version 2 appends with `since: 2` and the MCP tool `ia_position`, takes `{within?, seat?, shape?, phase?, depth?, budget?, word?}` and answers with `{body, digest, hostNote}`, exactly what `position` returns for that partial key through the door's scope token: no params is K0, and the parts take `normalizeScopeKey`'s defaults, so one key gives one body and digest wherever the workspace is. The params are closed, so request text is refused and nothing text-driven runs. A refusal of the key carries `next`, the one command to run, which the `RuntimeError` that `position` throws also carries: the closed set of a shape or phase, the cap of a depth or budget, `ia vocabulary` for a word, or the position without a seat the scope does not hold or one at runtime placement (the overview, when that seat is the repository's own `@workspace`). The Door's own refusals keep 1.1.0's shape, and a door serving version 1 refuses `position` as an unknown operation; on the CLI `ia position` prints a position.
34
+ ```text
35
+ plan [
36
+ 'work-system/definition/task/write-schema',
37
+ 'work-system/definition/task/review-schema'
38
+ ]
39
+ ia position --seat work-system/definition/task/write-schema --shape sequence
40
+ ```
18
41
 
19
- `renderPacket(handle, within, catalog)` (also on `@inventarch/runtime/internal/packet`) returns `{packet, digest, hostNote}`: the host-neutral position packet a host adapter renders, `ia.position-packet.v1`, its graph codec digest, and position's host note with `installed: 'unknown (no join checked here)'`, never digested. It calls `position` once at K0 and reads the rest through the same scope token: `body` is body(K0)'s digest; `seat` is the repository's `@workspace` with its sources, its system count and its steward; `mandates` are the authored `@mandate` records body(K0) lists whose `authority.participant` is an authored `@agent`, their authority fields as authored, and `participants` those `@agent` records, each once; none is no refusal (the seat line then says so), and no admitted mandate is refused; `systems` holds one pointer line per `composition.systems` reference, each with the words its registration lowers, band, steward and `ia position --seat <identity>`, or `unresolved`; `tallies` counts the authored records per word under the seat's own declared roots, none while it declares none; `intents` and `phases` are the five-shape and four-phase tables, each shape with the registered words it seeds; `commands` is the `catalog` passed in, in its order (apps/cli's `packetCatalog` builds one from its tagged COMMANDS rows); `lines` are the three SPEC lines; and `provenance` is the revision, body(K0)'s authored one, and the workspace's name. Its refusals are `position`'s. It names no absolute path, token, time, capture state or CLI version, so two roots give one packet and digest and a capture moves only the note. `entryCount(packet)` counts its entries by design §4's formula (SPEC R19). `renderHost` renders it for a host (below); nothing writes a file.
42
+ `position` completes a partial scope key (the `sequence` shape implies the `plan` phase, with depth 1 and budget 16 by default) and returns `{body, digest, hostNote}`. The body and its digest are a pure function of the key and the admitted records; the host note carries the revisions and capture freshness outside the digest. `deliveryView` returns `{ok: true, view}`, or a refusal that names the one command to run next.
20
43
 
21
- `renderHost(host, packet, digest, hostNote, target)` (also on `@inventarch/runtime/internal/packet-host`) renders that packet, with the digest and host note `renderPacket` returned, for the `claude` or `codex` host and returns the frozen `HostOutput` `{files, receipt}`; it writes nothing. No host gets an agent file: claude's `consumer` files are `.claude/rules/ia-workspace.md` and `.claude/skills/ia-authoring/SKILL.md`, its `repository` files `CLAUDE.md` and both `ia-authoring` skills, `.claude/skills/` and `.agents/skills/`; codex's are `AGENTS.md` and `.agents/skills/ia-authoring/SKILL.md`. Every file carries `PACKET_MARKER`, first in the entry file and after a skill's YAML frontmatter and a blank line, and each skill keeps the text compliance's retired 1.x renderers wrote for its target. The entry file holds the packet's sections in its field order (seat, participants, mandates, system pointer lines, captured-record tallies, intent table, phase table, command catalog, SPEC lines), under a title naming the provenance slug, one entry per list item or table row, so it renders `entryCount(packet)` entries, byte-identical for both hosts; each bare IA word token in free text, such as `@workspace`, is a code span, and an authored code span is kept as written with any token in it, so no rendered file shows a GitHub mention unless its author wrote the token touching a backtick; then the line `ia-generated <revision> <packet digest> <adapter>`, the adapter naming its version (`ia-claude@<version>`) only in the `consumer` target, so a committed repository file does not move with a release; then, in the `consumer` target only, the host note. The receipt, `ia.packet-receipt.v1`, names the host, the adapter with its version, the revision, the packet's provenance slug, the packet and body digests, the entry count, each file's path and SHA-256, the host note, and the participant and mandate identities; its `cli`, `removed`, `foreign`, `guard` and `writtenAt` are left for the caller that writes the files to set (`@inventarch/cli`'s `applyHostProjection`). An unknown host or target, or a digest that is not the packet's, is refused (SPEC R20). The receipt may also carry the optional authored-generation sections, `generated`, `definitions` (typed `PacketDefinition` rows: an `OperationDefinition` or a `HarnessDefinition`), `hooks` (`HostHookDeclaration` rows) and `unsupported` (an authored agent profile, playbook or hook the host does not render, with the reason), and `HostOutput` an optional `hooks`; `renderHost` fills none of them, and a receipt without them is a receipt from before authored generation. The `./internal/packet-host` subpath also exports `inline`, `code` and `prose`, the line helpers the packet writes free text with, for workspace-runtime's host generators.
22
- # Editor and authoring consumers
44
+ ## 🧭 What it does
23
45
 
24
- `@inventarch/runtime/editor` exposes `EditorWorkspace`: cache-free local source capture, versioned overlays, diagnostics, completion, source actions, inspector/graph projection, schema-backed drafting and create-only candidate validation. It also re-exports language's schema-aware source edits (`draftSource`, `draftValue`, `encodeValue`, `appendRecord`, `addRelationship`, `setField`, `annotateRecord`, `relationshipConsent`, `SourceEditError`) and `VERB_PHRASES`, for hosts that may not import the language package; `EditorWorkspace.draft` reports a form value `draftSource` refuses with `SourceEditError` (one that would add a condition or a comment, or open a string, prose or list it does not close) as `EditorError` 'invalid'. `ViewStamp` binds opaque source actions to one root owner and generation; refresh/update invalidates prior actions. This is a privileged local facade, not a replacement for scoped remote Door APIs. It performs no file creation or network requests.
46
+ | Export | Use it for |
47
+ | --- | --- |
48
+ | `position`, `positionBody`, `normalizeScopeKey`, `resolveScopeKey`, `K0`, `SCOPE_KEY_CAPS` | The body `ia position` prints for a scope key of seat, shape, phase, depth, budget and word. |
49
+ | `deliveryView`, `NEXT_CODES` | The plan view `ia next` prints: tasks in prerequisite order, each with a verdict from recorded exit evidence, and the next `ia position` command. |
50
+ | `readBody`, `parseLocator` | The body behind an identity, cell, requirement or source locator, with its SHA-256, as `ia read` prints it. |
51
+ | `Door`, `MACHINE_PROTOCOL` | The structured read protocol behind the CLI's machine commands and the MCP server: nine version 1 operations, plus `read`, `next` and `position` since version 2. |
52
+ | `context`, `select`, `prepareCoordinate`, `classify` | Coordinate-based context packets that reserve blocking governance first, and selection among explicit candidates. |
53
+ | `renderPacket`, `renderHost`, `PACKET_MARKER` | Build the host-neutral position packet and render it for `claude` or `codex` as files and a receipt. |
54
+ | `governingMandates`, `defaultActor`, `profileRefusal`, `evaluateMandateGuard`, `MOVES`, `MODE_MOVES` | Resolve the `@mandate` records that govern an actor, and judge a command mode or a guarded edit against them. |
55
+ | `preparePublication`, `inspectPublication`, `validateCandidate` | Publish generated drafts create-only, and validate candidate files against the sources a host disclosed. |
56
+ | `@inventarch/runtime/editor` | `EditorWorkspace` for editors (overlays, diagnostics, completion and source actions), with language's single-record edit helpers. |
57
+ | `@inventarch/runtime/authoring` | Version 1 remote authoring request, proposal, receipt, event and chat contracts, and a bounded HTTPS client. |
58
+ | `@inventarch/runtime/authoring-execution` | Guarded dispatch of authoring operations from a fixed catalog the host supplies. |
59
+ | `@inventarch/runtime/entry` | `isEntry`, which a package binary calls to tell whether it is the process entry. |
25
60
 
26
- `@inventarch/runtime/authoring` owns protocol-1 disclosure/request/proposal/receipt/event validation, digests and bounded same-origin HTTPS transport for separately configured account services. Applications own auth tokens, service state, model calls and effects. The extension and separate API use these same contracts; no native brief/spec/plan vocabulary is introduced.
61
+ The `./internal/*` subpaths serve specific toolchain consumers and are not a stable contract.
27
62
 
28
- See Workbench evidence and the [VS Code guide](../../apps/vscode/README.md) for actual consumers and qualification limits.
63
+ ## ⚖️ What it does not do
64
+
65
+ - **It writes no source.** `position`, `deliveryView`, `readBody`, `renderPacket` and `renderHost` write nothing; the CLI writes projection files. Publication is the one writer: create-only files under a host-selected `.ia/work/generated/<id>` directory, never `.ia/src`.
66
+ - **It runs nothing.** The Door makes no source writes, model calls, sessions or capability dispatch. A delivery view reads verdicts from recorded evidence and never executes a task, and what a scope does not read never counts as met.
67
+ - **A position takes no free text.** Request text is refused as a scope key part, so nothing text-driven decides what a position loads.
68
+ - **Mandates are cooperative restrictions.** Mandate resolution reads authored declarations; it authenticates no one and grants no host permission. A `@mandate` that fails admission fails every mandate-gated decision closed.
69
+ - **Remote authoring needs a separate service.** `./authoring` validates and transports messages; the service owns authentication, authorization, persisted runs and model execution, and the application owns credentials and effects.
70
+ - **Publication locks coordinate cooperating processes.** They are not a sandbox against malicious changes by the same user.
71
+
72
+ ## 📚 Learn more
73
+
74
+ - [SPEC.md](SPEC.md): the runtime contract, including scope keys, position bodies, delivery views, the Door protocol and host packets.
75
+ - [LANGUAGE.md](LANGUAGE.md): the public vocabulary this release carries.
76
+ - The [root README](../../README.md) and the [architecture reference](../../docs/reference/architecture/README.md).
77
+ - Related packages and apps: [`@inventarch/db`](../db/README.md), [`@inventarch/workspace-runtime`](../workspace-runtime/README.md), the [CLI guide](../../apps/cli/README.md) and the [MCP server](../../apps/mcp-door/README.md).