From 4ba46dfb0f84ae5197a911a4528edbdab32be4a3 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Tue, 19 May 2026 14:57:37 +0100 Subject: [PATCH] Draft Weksa interlingua standard --- README.md | 3 + docs/architecture.md | 10 +- docs/best-modern-approach.md | 48 +-- docs/interlingua-standard.md | 388 +++++++++++++++++++++++++ docs/language-model.md | 5 +- docs/project-model.md | 2 +- docs/roadmap.md | 7 +- docs/runtime-authoring-split.md | 14 +- schemas/README.md | 2 + schemas/interlingua-packet.md | 63 ++++ settings/rust-to-dust/battle-royale.md | 6 +- state/map.yaml | 22 +- 12 files changed, 529 insertions(+), 41 deletions(-) create mode 100644 docs/interlingua-standard.md create mode 100644 schemas/interlingua-packet.md diff --git a/README.md b/README.md index 6b5c3fc..cd81a33 100644 --- a/README.md +++ b/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 diff --git a/docs/architecture.md b/docs/architecture.md index e1bdc2d..f2066bf 100644 --- a/docs/architecture.md +++ b/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. diff --git a/docs/best-modern-approach.md b/docs/best-modern-approach.md index ac74687..cb4df36 100644 --- a/docs/best-modern-approach.md +++ b/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 diff --git a/docs/interlingua-standard.md b/docs/interlingua-standard.md new file mode 100644 index 0000000..965e9b0 --- /dev/null +++ b/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) + diff --git a/docs/language-model.md b/docs/language-model.md index b0a8738..e099392 100644 --- a/docs/language-model.md +++ b/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: diff --git a/docs/project-model.md b/docs/project-model.md index 65ac54a..0b48dc0 100644 --- a/docs/project-model.md +++ b/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 diff --git a/docs/roadmap.md b/docs/roadmap.md index 049aa95..9e0b5c1 100644 --- a/docs/roadmap.md +++ b/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. diff --git a/docs/runtime-authoring-split.md b/docs/runtime-authoring-split.md index 043f8ea..ff6e52e 100644 --- a/docs/runtime-authoring-split.md +++ b/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. - diff --git a/schemas/README.md b/schemas/README.md index 730c96a..f004578 100644 --- a/schemas/README.md +++ b/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 diff --git a/schemas/interlingua-packet.md b/schemas/interlingua-packet.md new file mode 100644 index 0000000..b92df21 --- /dev/null +++ b/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. + diff --git a/settings/rust-to-dust/battle-royale.md b/settings/rust-to-dust/battle-royale.md index 2c582e9..73e365b 100644 --- a/settings/rust-to-dust/battle-royale.md +++ b/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 diff --git a/state/map.yaml b/state/map.yaml index 45f480a..0c6b61e 100644 --- a/state/map.yaml +++ b/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.