Draft Weksa interlingua standard

README.md

@@ -37,6 +37,9 @@ See [Project Model](./docs/project-model.md) for the engine / language project /
 setting split, and [Runtime and Authoring Split](./docs/runtime-authoring-split.md)
 for the LLM-free hot path.
 
+See [Interlingua Standard](./docs/interlingua-standard.md) for the shared
+meaning-packet contract Weksa clients should target.
+
 ## Implementation Status
 
 No runtime language has been selected yet. The first committed artifact is the

docs/architecture.md

@@ -13,6 +13,10 @@ There is no runtime mechanism yet. The repo contains persistent state surfaces
 that define the intended data flow and the ownership boundaries future code must
 respect.
 
+The first shared contract is the [Interlingua Standard](./interlingua-standard.md):
+clients submit interlingua packets before any language project projects them
+through its ontology.
+
 ## Invariants
 
 - Meaning precedes words.
@@ -26,9 +30,9 @@ respect.
 ## Intended Change
 
 Future implementation should turn the pipeline in `state/map.yaml` into a small,
-inspectable machine. The first executable slice should probably read a tiny
-language project definition, render a handful of structured meaning packets, and
-produce traceable glossed output.
+inspectable machine. The first executable slice should probably validate a tiny
+interlingua packet, read a tiny language project definition, render glossed
+output, and produce a trace explaining which stage made each decision.
 
 Runtime should be fast and deterministic. Model-assisted English decomposition
 belongs in authoring tools or offline import flows, not in the required hot path.

docs/best-modern-approach.md

@@ -204,7 +204,7 @@ This is how Weksa avoids making a dictionary of costumes.
 ## Interlingua
 
 Do not translate English directly into alien words. Translate English into a
-structured meaning representation first.
+Weksa interlingua packet first.
 
 Example source:
 
@@ -212,24 +212,36 @@ Example source:
 I saw the stranger steal water.
 ```
 
-Example interlingua:
+Example interlingua packet:
 
-```json
-{
-  "event": "steal",
-  "agent": {
-    "role": "stranger",
-    "social_status": "outside_oath"
-  },
-  "patient": {
-    "concept": "water",
-    "ecological_status": "shared_life_resource"
-  },
-  "witness": "speaker",
-  "evidence": "direct_visual",
-  "moral_frame": "obligation_to_report",
-  "tense_aspect": "completed"
-}
+```yaml
+interlingua_version: 0.1-draft
+packet_id: example-theft-001
+kind: utterance
+provenance:
+  source_type: authored
+referents:
+  - id: speaker
+    kind: person
+  - id: stranger
+    kind: person
+    attributes:
+      social_status: outside_oath
+  - id: water
+    kind: abstract
+    attributes:
+      ecological_status: shared_life_resource
+predications:
+  - id: theft
+    predicate: steal
+    aspect: completed
+    evidentiality: direct_visual
+    roles:
+      agent: stranger
+      patient: water
+      experiencer: speaker
+extensions:
+  example.moral_frame: obligation_to_report
 ```
 
 Then render that through the alien ontology and grammar. The interlingua is the

docs/interlingua-standard.md

@@ -0,0 +1,388 @@
+# Interlingua Standard
+
+Version: `0.1-draft`
+
+The Weksa interlingua is the language-neutral meaning contract between clients,
+setting surfaces, authoring tools, language projects, ontology projection, and
+renderers.
+
+It is not English. It is not a grammar tree. It is not a target-language
+ontology. It is the smallest structured packet that says what is meant, who is
+involved, what the context is, and which facts are stable enough for a language
+project to reinterpret.
+
+## Objective
+
+Give every Weksa client one shared way to submit meaning without forcing all
+settings through one worldview.
+
+The interlingua should support:
+
+- game telemetry and commentary intents
+- naming briefs for places, species, institutions, artifacts, and ecological
+  structures
+- dialogue and narration authoring
+- corpus examples
+- model-assisted semantic decomposition
+- deterministic runtime rendering
+- traceable ontology projection
+
+## Prior Art
+
+Weksa should learn from existing semantic annotation work without becoming a
+research format clone.
+
+- AMR gives a useful model for abstract graph meaning that is not a surface parse.
+- UMR extends that direction with cross-linguistic and document-level concerns
+  such as coreference, temporal relations, modal dependencies, aspect, and
+  multilingual diversity.
+- FrameNet keeps scenes and roles central.
+- Universal Dependencies shows a useful governance pattern: common categories
+  with language-specific extensions when needed.
+
+Weksa's difference is purpose. It is a rendering contract for constructed
+languages and alien ontologies, not a general-purpose annotation benchmark.
+
+## Ownership
+
+The interlingua owns:
+
+- referents
+- events, states, and relations
+- roles between referents and predicates
+- time, aspect, modality, evidence, and polarity when known
+- discourse function and speaker intent
+- context needed for rendering
+- provenance and confidence
+- extension slots with explicit namespaces
+
+The interlingua does not own:
+
+- target-language concept splits or collapses
+- grammar obligations
+- morphology
+- phonology
+- diachronic history
+- final wording
+- culture-specific metaphors unless the source meaning explicitly contains them
+
+Those belong downstream.
+
+## Design Principles
+
+- Meaning before words.
+- Graph before sentence.
+- Explicit uncertainty beats fake precision.
+- Use common fields for common meaning.
+- Use namespaced extensions for client or setting pressure.
+- Extensions are evidence, not authority, until a language project consumes them.
+- Runtime packets must be deterministic and serializable.
+- The renderer must be able to trace every target-language decision back to a
+  packet field, ontology rule, or language-project rule.
+
+## Packet Shape
+
+The canonical packet is an object with these top-level families:
+
+```yaml
+interlingua_version:
+packet_id:
+kind:
+provenance:
+context:
+discourse:
+referents:
+predications:
+relations:
+constraints:
+extensions:
+trace:
+```
+
+Only `interlingua_version`, `packet_id`, `kind`, and at least one semantic
+payload family are required. The rest should be present when known.
+
+## Top-Level Fields
+
+### `kind`
+
+The packet's broad use case.
+
+Initial values:
+
+- `utterance`
+- `name_request`
+- `commentary_intent`
+- `narration`
+- `dialogue_line`
+- `corpus_example`
+- `debug_probe`
+
+### `provenance`
+
+Where the packet came from.
+
+```yaml
+provenance:
+  source_type: authored | model_decomposition | game_telemetry | imported_corpus
+  source_ref:
+  author:
+  created_at:
+  confidence:
+```
+
+### `context`
+
+World and situation information that is not itself the main semantic claim.
+
+```yaml
+context:
+  setting:
+  scene:
+  time:
+  location:
+  participants:
+  audience:
+  medium:
+```
+
+### `discourse`
+
+Why this packet is being said, rendered, or named.
+
+```yaml
+discourse:
+  speech_act:
+  intent:
+  tone:
+  register_hint:
+  addressee:
+  audience_function:
+```
+
+This is not target-language register. It is source-side communicative pressure.
+
+### `referents`
+
+Entities, groups, locations, abstract objects, institutions, ecological actors,
+routes, memories, artifacts, and other nodes that can participate in meaning.
+
+```yaml
+referents:
+  - id:
+    kind:
+    label:
+    ontology_hint:
+    animacy:
+    agency:
+    number:
+    definiteness:
+    salience:
+    attributes:
+    extensions:
+```
+
+Initial broad kinds:
+
+- `person`
+- `group`
+- `organism`
+- `place`
+- `artifact`
+- `institution`
+- `ecology`
+- `route`
+- `memory`
+- `event`
+- `abstract`
+
+### `predications`
+
+Events, states, processes, properties, and frame-like scenes.
+
+```yaml
+predications:
+  - id:
+    predicate:
+    frame:
+    aspect:
+    tense:
+    polarity:
+    modality:
+    evidentiality:
+    roles:
+      agent:
+      patient:
+      experiencer:
+      instrument:
+      source:
+      goal:
+      location:
+      beneficiary:
+    attributes:
+    extensions:
+```
+
+`predicate` is a broad source-side claim. `frame` is optional but recommended
+when a scene model is known. Roles may use common names or namespaced frame
+roles.
+
+### `relations`
+
+Edges that are not naturally owned by one predication.
+
+```yaml
+relations:
+  - type:
+    from:
+    to:
+    attributes:
+    extensions:
+```
+
+Initial relation families:
+
+- `coreference`
+- `part_of`
+- `member_of`
+- `located_at`
+- `near`
+- `before`
+- `after`
+- `causes`
+- `enables`
+- `prevents`
+- `owns`
+- `owes`
+- `knows`
+- `names`
+- `represents`
+- `contrasts_with`
+
+### `constraints`
+
+Hard requirements the downstream renderer must respect.
+
+```yaml
+constraints:
+  preserve_referents:
+  preserve_relations:
+  required_outputs:
+  forbidden_outputs:
+  max_latency_ms:
+  deterministic:
+```
+
+These are engineering and content constraints, not ontology rules.
+
+### `extensions`
+
+Namespaced setting or client data.
+
+```yaml
+extensions:
+  zyphos.memory_relation:
+  zyphos.boundary_permeability:
+  rtd.aesthetic_reading:
+  game.priority:
+```
+
+Extension rules:
+
+- Namespaces must be explicit.
+- Extensions must not replace common fields when common fields are sufficient.
+- A downstream language project may choose to ignore an extension.
+- If an extension becomes broadly required across clients, promote it into the
+  standard in a later version.
+
+### `trace`
+
+Optional authoring/debug data.
+
+```yaml
+trace:
+  notes:
+  decomposition_steps:
+  uncertainty:
+  rejected_readings:
+```
+
+Runtime may strip `trace` from compiled packets when latency or size matters.
+
+## Minimal Examples
+
+### Name Request
+
+```yaml
+interlingua_version: 0.1-draft
+packet_id: zyphos-name-001
+kind: name_request
+provenance:
+  source_type: authored
+context:
+  setting: Eusocial Interbeing
+referents:
+  - id: target
+    kind: ecology
+    label: disconnected tree network
+  - id: namer
+    kind: group
+    label: Airawa imperial surveyor
+relations:
+  - type: names
+    from: namer
+    to: target
+extensions:
+  zyphos.memory_relation: severed_from_saturated_substrate
+  zyphos.boundary_permeability: hidden_refusal
+```
+
+### Commentary Intent
+
+```yaml
+interlingua_version: 0.1-draft
+packet_id: rtd-commentary-001
+kind: commentary_intent
+context:
+  setting: Rust to Dust
+  medium: broadcast
+discourse:
+  speech_act: commentary
+  audience_function: spectacle
+referents:
+  - id: actor
+    kind: person
+  - id: target
+    kind: person
+predications:
+  - id: event
+    predicate: eliminate
+    frame: combat
+    roles:
+      agent: actor
+      patient: target
+extensions:
+  rtd.aesthetic_reading:
+    form: raw
+    spectacle_value: high
+```
+
+## Promotion Rule
+
+The interlingua should stay boring. When a new requirement appears:
+
+1. Put it in a namespaced extension.
+2. Use it in at least two real packets.
+3. Ask which invariant it protects.
+4. Promote it only if multiple clients or language projects need it.
+
+No generic bucket earns permanence by sounding useful. That is how a schema
+becomes a junk drawer with a hat.
+
+## References
+
+- [Abstract Meaning Representation 1.0 Specification](https://www.isi.edu/results/publications/14628/abstract-meaning-representation-amr-1-0-specification/)
+- [Uniform Meaning Representation release paper](https://aclanthology.org/2024.lrec-main.229.pdf)
+- [Global FrameNet](https://www.globalframenet.org/)
+- [Universal Dependencies Guidelines](https://universaldependencies.org/guidelines)
+

docs/language-model.md

@@ -8,7 +8,7 @@ doctrine and examples.
 ## Translation Path
 
 1. Preserve the source utterance.
-2. Decompose it into structured meaning.
+2. Decompose it into a Weksa interlingua packet.
 3. Apply an alien ontology that may split, collapse, or reweight concepts.
 4. Select grammatical commitments required by the target language.
 5. Build morpheme plans from roots, derivation, inflection, and compounds.
@@ -16,6 +16,9 @@ doctrine and examples.
 7. Apply diachronic history.
 8. Render surface text, glosses, and explanation.
 
+See [Interlingua Standard](./interlingua-standard.md) for the shared meaning
+contract.
+
 ## Model Use
 
 LLMs and embedding models are useful for:

docs/project-model.md

@@ -18,7 +18,7 @@ Weksa engine
 
 The engine owns generic pipeline contracts:
 
-- structured meaning input
+- interlingua packet input
 - ontology projection
 - grammar planning
 - morphology

docs/roadmap.md

@@ -3,15 +3,18 @@
 ## Now
 
 - Keep the persistent state spine small and readable.
-- Decide the first language-project state format.
+- Stabilize the interlingua packet standard before runtime code.
+- Decide the first language-project state format after the interlingua boundary
+  is clear.
 - Build a hand-authored toy language project before automating generation.
 - Use Rust to Dust as the first proving ground while keeping Weksa
   setting-neutral.
 
 ## First Prototype
 
+- Validate one minimal interlingua packet.
 - Parse or load one language project definition.
-- Accept a structured meaning packet.
+- Accept a Weksa interlingua packet.
 - Render glossed output through grammar, morphology, phonology, and diachrony.
 - Emit a trace explaining which stage made each decision.
 - Keep runtime LLM-free; model use belongs in authoring and critique.

docs/runtime-authoring-split.md

@@ -5,10 +5,10 @@ should be fast, deterministic, local, and free of required LLM calls.
 
 ## Runtime
 
-Runtime consumes structured meaning and compiled language-project data.
+Runtime consumes Weksa interlingua packets and compiled language-project data.
 
 ```text
-structured intent
+interlingua packet
   -> ontology projection
   -> grammar plan
   -> morphology
@@ -26,8 +26,9 @@ Runtime invariants:
 - renderer does not invent meaning
 - traces can explain which stage made each decision
 
-The game, tool, or host application should send structured intent, not prose
-that Weksa must guess at under pressure.
+The game, tool, or host application should send an interlingua packet, not prose
+that Weksa must guess at under pressure. See
+[Interlingua Standard](./interlingua-standard.md).
 
 ## Authoring
 
@@ -45,10 +46,10 @@ The model is a workshop tool, not a runtime authority.
 
 ## Parallel Renderers
 
-One structured intent may render into multiple surfaces:
+One interlingua packet may render into multiple surfaces:
 
 ```text
-structured intent
+interlingua packet
   -> projected meaning
   -> alien-language renderer
   -> subtitle or gloss renderer
@@ -58,4 +59,3 @@ structured intent
 For flavor-first settings, subtitles may render from projected meaning instead
 of neutral facts. The neutral facts still exist underneath for correctness and
 debugging.
-

schemas/README.md

@@ -14,6 +14,8 @@ steer the machine, describe its authority here.
 - [language-project-state.md](./language-project-state.md): future per-language
   state for ontology, grammar, morphology, phonology, diachrony, and renderer
   configuration.
+- [interlingua-packet.md](./interlingua-packet.md): shared meaning packet
+  contract between clients, authoring tools, and language projects.
 
 ## Source Of Truth
 

schemas/interlingua-packet.md

@@ -0,0 +1,63 @@
+# Interlingua Packet Contract
+
+This is the human-facing schema receipt for Weksa interlingua packets.
+
+Executable schema code does not exist yet. When it does, it must reconcile with
+this document and [Interlingua Standard](../docs/interlingua-standard.md) in the
+same pass.
+
+## Authority
+
+The interlingua packet is the boundary between clients and language projects.
+
+Clients submit structured meaning. Language projects consume that meaning,
+project it through ontology, and render it through grammar, morphology,
+phonology, diachrony, and renderer rules.
+
+## Required Fields
+
+- `interlingua_version`: version string.
+- `packet_id`: stable local identifier.
+- `kind`: broad use case.
+- at least one semantic payload family:
+  - `referents`
+  - `predications`
+  - `relations`
+
+## Optional Families
+
+- `provenance`: source and confidence.
+- `context`: world, scene, medium, participants, audience.
+- `discourse`: speech act, intent, tone, source-side register hint.
+- `constraints`: downstream requirements.
+- `extensions`: namespaced client or setting pressure.
+- `trace`: debug and authoring notes.
+
+## Extension Contract
+
+Extensions use explicit namespaces such as:
+
+- `zyphos.*`
+- `rtd.*`
+- `game.*`
+- `authoring.*`
+
+Extensions are not a junk drawer. They are provisional fields awaiting evidence.
+If a field becomes common across clients, promote it into the standard with a
+version bump.
+
+## Validation Goals
+
+The eventual executable schema should validate:
+
+- required top-level fields
+- referential integrity between roles and referents
+- known `kind` values
+- namespace syntax for extensions
+- deterministic JSON/YAML serialization
+- stable packet IDs inside a corpus or run
+- absence of target-language surface forms in source meaning fields
+
+It should warn, not fail, on unknown extension namespaces unless a runtime bundle
+declares a stricter policy.
+

settings/rust-to-dust/battle-royale.md

@@ -19,9 +19,9 @@ An in-universe alien TV channel commentates on what players are doing. The
 player hears or sees the alien-language broadcast with English subtitles.
 
 The correct runtime model is not English-to-alien translation. The game should
-emit structured commentary intent. Weksa should render alien broadcast output,
-and a subtitle renderer should render English from the same structured intent or
-from the alien-projected meaning.
+emit a Weksa interlingua packet for commentary intent. Weksa should render alien
+broadcast output, and a subtitle renderer should render English from the same
+packet or from the alien-projected meaning.
 
 ```text
 game telemetry

state/map.yaml

@@ -12,8 +12,8 @@ objective:
     Create a durable workspace where Weksa can develop from a persistent map
     before runtime architecture decisions are made.
   current: >
-    Reorient the first active language-design target toward Zyphos / Eusocial
-    Interbeing while preserving Weksa's language-neutral engine boundaries.
+    Define the Weksa interlingua standard as the shared meaning contract across
+    current and future setting clients.
 
 constraints:
   - Runtime implementation language is undecided.
@@ -21,15 +21,18 @@ constraints:
     architecture earns it.
   - Neural models may decompose, suggest, generate, and critique; they do not
     own the canonical language state.
-  - Runtime should accept structured meaning and compiled project data; required
-    hot-path rendering must not depend on arbitrary English interpretation or
-    live LLM calls.
+  - Runtime should accept interlingua packets and compiled project data;
+    required hot-path rendering must not depend on arbitrary English
+    interpretation or live LLM calls.
   - Setting-specific projects may pressure the engine, but their ontology must
     not become generic Weksa doctrine.
   - Zyphos / Eusocial Interbeing canon belongs to the Eusocial Interbeing vault;
     Weksa should consume it through explicit naming and language-design briefs.
   - Explicit project state must distinguish durable decisions from scratch.
   - Avoid direct English-to-alien word replacement as the core design.
+  - The interlingua must stay language-neutral. Setting-specific pressure starts
+    in namespaced extensions and only becomes standard when multiple clients or
+    language projects need it.
 
 invariants:
   - Ontology owns meaning.
@@ -46,11 +49,12 @@ invariants:
 data_flow:
   observe:
     - source utterance
+    - interlingua packet
     - translation context
     - world model
     - existing language project state
   process:
-    - decompose source into structured interlingua
+    - accept or decompose source into a Weksa interlingua packet
     - apply alien ontology and cultural salience
     - select grammatical commitments
     - derive morphology and lexical families
@@ -135,6 +139,9 @@ accepted_design:
   - The first model is concept-first translation through an explicit
     interlingua, ontology, grammar, morphology, phonology, diachrony, and
     renderer pipeline.
+  - The interlingua packet is the client-facing meaning contract. It owns
+    referents, predications, relations, discourse, context, provenance,
+    constraints, extensions, and trace data before ontology projection.
   - Weksa is the engine. A language project owns one constructed language.
     Setting docs own story, species, culture, and use cases.
   - Rust to Dust is an earlier proving ground, not engine doctrine.
@@ -169,6 +176,8 @@ open_questions:
     Sa'auei'a, or a narrow naming-brief interlingua?
   - What Weksa naming brief schema best serves nation-scale interbeings,
     ecological memory networks, and mobile family-unit civilizations?
+  - Which interlingua fields should be promoted from namespaced extensions after
+    the first real Zyphos and Rust to Dust packets?
 
 landed_baseline:
   - Language-neutral state spine.
@@ -178,3 +187,4 @@ landed_baseline:
   - Rust to Dust setting documentation skeleton.
   - Eusocial Interbeing naming surface at settings/eusocial-interbeing.
   - Zyphos language-design pressure note.
+  - Draft Weksa interlingua standard and packet schema receipt.