From f8169c4d50f1ed38ce43514398b27dbe65c1b2d9 Mon Sep 17 00:00:00 2001 From: TheFlow Date: Fri, 17 Apr 2026 07:37:34 +1200 Subject: [PATCH] terminology: standardise SLL as "Situated Language Layer" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace all instances of "Sovereign Locally-trained Language Model" with "Situated Language Layer" across village-ai.html, all 3 architectural-alignment papers, and the EN locale file. Canonical definition: an architectural layer comprising a small language model that is sovereign (locally trained, locally deployed, community-controlled) and situated (shaped by the specific context, values, and vocabulary of the community it serves). Note: pre-existing inline-style CSP warnings in alignment paper licence sections (pandoc-generated) — not introduced by this commit. Co-Authored-By: Claude Opus 4.6 (1M context) --- public/architectural-alignment-community.html | 4 +- .../architectural-alignment-policymakers.html | 4 +- public/architectural-alignment.html | 4 +- public/locales/en/village-ai.json | 4 +- public/village-ai.html | 4 +- scripts/add-toc-glossary-taiuru.js | 156 ++++++++++++++++++ 6 files changed, 166 insertions(+), 10 deletions(-) create mode 100644 scripts/add-toc-glossary-taiuru.js diff --git a/public/architectural-alignment-community.html b/public/architectural-alignment-community.html index cc925649..050dfec1 100644 --- a/public/architectural-alignment-community.html +++ b/public/architectural-alignment-community.html @@ -107,7 +107,7 @@

This paper presents an alternative: constitutional governance for community-controlled AI. The Tractatus Framework implements explicit rules, defined by your community, that constrain what AI systems can do before any action is taken. This isn't about making AI less capable—it's about making AI accountable to the community it serves.

-

The framework is implemented in the Village platform and designed to support both cloud-based AI and locally-deployed systems. We introduce the concept of Sovereign Locally-trained Language Models (SLLs)—AI systems that run on community infrastructure, adapt to community norms, and operate under community-defined constitutions rather than vendor terms of service.

+

The framework is implemented in the Village platform and designed to support both cloud-based AI and locally-deployed systems. We introduce the concept of Situated Language Layers (SLLs)—AI systems that run on community infrastructure, adapt to community norms, and operate under community-defined constitutions rather than vendor terms of service.

@@ -211,7 +211,7 @@

3. Sovereign Local AI: The SLL Concept

3.1 What is an SLL?

-

We introduce the term Sovereign Locally-trained Language Model (SLL) to describe AI systems with specific properties:

+

We introduce the term Situated Language Layer (SLL) to describe an architectural layer with specific properties:

Local deployment: Runs on your infrastructure—a home server, community hardware, or local data centre—not a vendor's cloud

Local adaptation: Fine-tuned on your community's data and norms, not generic training

diff --git a/public/architectural-alignment-policymakers.html b/public/architectural-alignment-policymakers.html index 1fb964fe..eb763da4 100644 --- a/public/architectural-alignment-policymakers.html +++ b/public/architectural-alignment-policymakers.html @@ -105,7 +105,7 @@

This paper presents the Tractatus Framework, an architectural approach to AI governance through inference-time constitutional gating. Rather than relying solely on vendor training to ensure AI behaves appropriately, Tractatus requires AI systems to translate proposed actions into auditable forms and evaluate them against explicit constitutional rules before execution. This creates visible, enforceable governance at the point of deployment.

-

The framework is implemented in the Village platform and designed to accommodate both centralised cloud AI and distributed local deployments, including what we term Sovereign Locally-trained Language Models (SLLs)—AI systems whose training, deployment, and governance remain under community or individual sovereignty rather than vendor control.

+

The framework is implemented in the Village platform and designed to accommodate both centralised cloud AI and distributed local deployments, including what we term Situated Language Layers (SLLs)—AI systems whose training, deployment, and governance remain under community or individual sovereignty rather than vendor control.

@@ -227,7 +227,7 @@

3.1 Terminology

We distinguish two deployment paradigms that have different governance implications:

Small Language Model (SLM): A technical descriptor for language models with fewer parameters than frontier LLMs, designed for efficiency and domain-specific deployment. SLMs may be deployed via cloud subscription or locally.

-

Sovereign Locally-trained Language Model (SLL): An architectural descriptor we introduce for AI systems whose training, deployment, and governance remain under local sovereignty. Key properties:

+

Situated Language Layer (SLL): An architectural layer comprising a small language model that is sovereign (locally trained, locally deployed, community-controlled) and situated (shaped by the specific context, values, and vocabulary of the community it serves). Key properties:

Local deployment: Runs on home or community infrastructure

Local adaptation: Fine-tuned on community-specific data

diff --git a/public/architectural-alignment.html b/public/architectural-alignment.html index 281e78a3..5155449f 100644 --- a/public/architectural-alignment.html +++ b/public/architectural-alignment.html @@ -108,7 +108,7 @@

We present the Tractatus Framework as a formal specification for interrupted neural reasoning: proposals generated by AI systems must be translated into auditable forms and evaluated against constitutional constraints before execution. This shifts the trust model from "trust the vendor's training" to "trust the visible architecture." The framework is implemented within the Village multi-tenant community platform, providing an empirical testbed for governance research.

-

Critically, we address the faithful translation assumption—the vulnerability that systems may misrepresent their intended actions to constitutional gates—by bounding the framework's domain of applicability to pre-superintelligence systems and specifying explicit capability thresholds and escalation triggers. We introduce the concept of Sovereign Locally-trained Language Models (SLLs) as a deployment paradigm where constitutional gating becomes both feasible and necessary.

+

Critically, we address the faithful translation assumption—the vulnerability that systems may misrepresent their intended actions to constitutional gates—by bounding the framework's domain of applicability to pre-superintelligence systems and specifying explicit capability thresholds and escalation triggers. We introduce the concept of Situated Language Layers (SLLs) as a deployment paradigm where constitutional gating becomes both feasible and necessary.

The paper contributes: (1) a formal architecture for inference-time constitutional gating; (2) capability threshold specifications with escalation logic; (3) validation methodology for layered containment; (4) an argument connecting existential risk preparation to edge deployment; and (5) a call for sustained deliberation (kōrero) as the epistemically appropriate response to alignment uncertainty.

@@ -308,7 +308,7 @@

6.5 Extension to Sovereign Local Deployments

We distinguish:

Small Language Model (SLM). A technical descriptor for models with fewer parameters than frontier LLMs, designed for efficiency.

-

Sovereign Locally-trained Language Model (SLL). An architectural descriptor: a model whose training, deployment, and governance remain under local sovereignty. Key properties include local deployment, local adaptation, local governance, and portable sovereignty.

+

Situated Language Layer (SLL). An architectural layer comprising a small language model that is sovereign (locally trained, locally deployed, community-controlled) and situated (shaped by the specific context, values, and vocabulary of the community it serves). The term draws on situated knowledge theory: understanding that emerges from a particular context rather than claiming universality.

7. Capability Thresholds and Escalation

diff --git a/public/locales/en/village-ai.json b/public/locales/en/village-ai.json index b12501e4..97c84d14 100644 --- a/public/locales/en/village-ai.json +++ b/public/locales/en/village-ai.json @@ -11,7 +11,7 @@ }, "sll": { "heading": "What is an SLL?", - "intro": "An SLL (Sovereign Locally-trained Language Model) is distinct from both LLMs and SLMs. The distinction is not size — it is control.", + "intro": "An SLL (Situated Language Layer) is distinct from both LLMs and SLMs. The distinction is not size — it is sovereignty and situatedness.", "llm_title": "LLM", "llm_subtitle": "Large Language Model", "llm_item1": "Training: provider-controlled", @@ -25,7 +25,7 @@ "slm_item3": "Governance: partial (fine-tuning)", "slm_item4": "User control: limited", "sll_title": "SLL", - "sll_subtitle": "Sovereign Locally-trained", + "sll_subtitle": "Situated Language Layer", "sll_item1": "Training: community-controlled", "sll_item2": "Data: community-owned", "sll_item3": "Governance: architecturally enforced", diff --git a/public/village-ai.html b/public/village-ai.html index 8f20ed47..772a10e8 100644 --- a/public/village-ai.html +++ b/public/village-ai.html @@ -76,7 +76,7 @@

What is an SLL?

- An SLL (Sovereign Locally-trained Language Model) is distinct from both LLMs and SLMs. The distinction is not size — it is control. + An SLL (Situated Language Layer) is distinct from both LLMs and SLMs. The distinction is not size — it is sovereignty and situatedness.

@@ -103,7 +103,7 @@

SLL

-

Sovereign Locally-trained

+

Situated Language Layer

  • Training: community-controlled
  • Data: community-owned
    • diff --git a/scripts/add-toc-glossary-taiuru.js b/scripts/add-toc-glossary-taiuru.js new file mode 100644 index 00000000..e7935ea5 --- /dev/null +++ b/scripts/add-toc-glossary-taiuru.js @@ -0,0 +1,156 @@ +#!/usr/bin/env node + +/** + * Add Table of Contents and Glossary to the Taiuru mapping blog post + * + * Usage: + * node scripts/add-toc-glossary-taiuru.js # local dev DB + * node scripts/add-toc-glossary-taiuru.js mongodb://... # production DB + */ + +const mongoose = require('mongoose'); + +const MONGODB_URI = process.argv[2] || 'mongodb://localhost:27017/tractatus_dev'; +const SLUG = 'kaupapa-maori-ai-framework-tractatus-mapping'; + +const tableOfContents = ` + +`; + +const glossary = ` +
    +

    Glossary

    + +

    Te Reo Māori Terms

    +
    +
    Ātārangi
    Shadow or reflection. In Taiuru's framework, the third dimension of AI — AI is constituted entirely by human thought, language, and culture. The shadow carries something of the original.
    +
    Hapū
    Sub-tribe or clan. A political and social unit within an iwi, typically comprising several whānau.
    +
    He Tangata
    A person, a human being. In Taiuru's framework, the first dimension — AI presents as a person but meets none of the conditions of personhood in te ao Māori.
    +
    Hui
    A gathering, meeting, or assembly for discussion and decision-making.
    +
    Iwi
    Tribe or nation. The largest political unit in Māori society, comprising multiple hapū.
    +
    Kaitiakitanga
    Guardianship, stewardship. The obligation to care for and protect something for future generations.
    +
    Karetao
    Puppet or marionette. In Taiuru's framework, the second dimension — AI is animated by external forces (developers, operators, users) like a puppet by strings.
    +
    Kaupapa Māori
    A Māori approach or philosophy. A framework grounded in Māori worldview, values, and practices.
    +
    Kōrero
    Speech, discussion, conversation.
    +
    Mana Motuhake
    Autonomous authority, self-determination. The right of Māori to control their own affairs.
    +
    Marae
    A communal meeting ground and its buildings. The focal point of Māori community life.
    +
    Mātauranga Māori
    Māori knowledge, wisdom, and understanding. The body of knowledge originating from Māori ancestors.
    +
    Mauri
    Life force, vital essence. An essential quality of all things, both animate and inanimate.
    +
    Noa
    Free from tapu, ordinary, unrestricted.
    +
    Pūrākau
    Stories, narratives. Traditional and contemporary Māori storytelling.
    +
    Rōpū
    Group, organisation, or collective.
    +
    Taonga
    A treasured possession, something of value. Can be tangible (an artifact) or intangible (language, knowledge).
    +
    Tapu
    Sacred, restricted, set apart. Indicates spiritual restriction and the need for respectful handling.
    +
    Te Ao Māori
    The Māori world, worldview, and way of understanding reality.
    +
    Te Tiriti o Waitangi
    The Treaty of Waitangi (1840). The founding document of New Zealand, establishing the relationship between Māori and the Crown.
    +
    Tikanga
    Correct procedure, custom, protocol. The Māori way of doing things according to cultural values.
    +
    Tino Rangatiratanga
    Absolute sovereignty, self-determination, autonomy. The right of Māori to govern their own affairs.
    +
    Waka Hourua
    Double-hulled canoe. Used by Te Kāhui Raraunga as a governance model — two hulls (te ao Māori and Kāwanatanga) structurally independent, neither dominating, connected by a shared deck.
    +
    Wānanga
    A forum for discussion, learning, and deliberation. An extended meeting for deep consideration of issues.
    +
    Whakapapa
    Genealogy, lineage, identity. The network of relationships connecting people, ancestors, and the natural world.
    +
    Whānau
    Extended family group. The foundational social unit in Māori society.
    +
    + +

    Technical and Governance Terms

    +
    +
    CARE Principles
    Collective Benefit, Authority to Control, Responsibility, Ethics — principles for indigenous data governance developed by the Global Indigenous Data Alliance.
    +
    Constitutional AI
    An approach to AI safety where behaviour is governed by a set of principles (a constitution) rather than case-by-case rules.
    +
    Federation
    A system where independent communities form bilateral agreements to share specific capabilities while each retaining full sovereignty over their own data and governance.
    +
    Guardian Agents
    Deterministic (non-AI) code that evaluates AI outputs before they reach community members. Four-phase system: evidence gathering, baseline comparison, classification, risk assessment.
    +
    Koha
    A gift given with reciprocity. In the platform context, voluntary contributions without transaction fees.
    +
    Metagovernance
    Governance of the governance system itself — ensuring that the mechanisms controlling AI are themselves accountable and auditable.
    +
    OCAP Principles
    Ownership, Control, Access, Possession — First Nations (Canadian) principles asserting community-level authority over data.
    +
    Polycentric Governance
    A governance model with multiple independent centres of authority (drawn from Elinor Ostrom's work), as opposed to a single hierarchical structure.
    +
    Situated Language Layer (SLL)
    Product-type-specific AI model fine-tuning. Each community type gets an AI tuned to its domain knowledge and vocabulary.
    +
    Steering Vectors
    Mathematical adjustments applied to an AI model's internal representations during inference, shaping how it processes concepts at the embedding layer. Only possible with sovereign model hosting.
    +
    Steering Packs
    Versioned governance artefacts published by steering authorities. Can contain system prompt additions, cultural boundary sets, or activation vectors that shape AI behaviour.
    +
    Tractatus Framework
    An architectural framework for AI governance developed by My Digital Sovereignty Ltd. Enforces governance structurally through boundary enforcement, mathematical verification, and layered accountability. Published under Apache 2.0.
    +
    +`; + +// Section heading ID mapping +const headingIds = { + 'Two Frameworks, Two Traditions, One Problem': 'two-frameworks', + 'He Tangata: The Person': 'he-tangata', + 'He Karetao: The Puppet': 'he-karetao', + 'Guardian Agents: The Karetao\'s Accountability Mechanism': 'guardian-agents', + 'He Ātārangi: The Shadow': 'he-atarangi', + 'Steering Vectors, Polycentric Governance, and Cultural Weight': 'steering-vectors', + 'Federation: From Village to Network': 'federation', + 'Te Tiriti Principles and the Architecture': 'te-tiriti', + 'What Both Frameworks Reveal About Each Other': 'what-both-reveal', + 'Research Directions': 'research-directions', + 'The Legal Governance Layer: Kaitiakitanga Licence': 'legal-governance', + 'The Economics of Sovereign AI: Training, Inference, and Value': 'economics', + 'What Remains Genuinely Missing': 'gaps', + 'Gaps': 'gaps' +}; + +async function main() { + await mongoose.connect(MONGODB_URI); + console.log('Connected to:', MONGODB_URI); + + const db = mongoose.connection.db; + const post = await db.collection('blog_posts').findOne({ slug: SLUG }); + + if (!post) { + console.error('Blog post not found:', SLUG); + process.exit(1); + } + + console.log('Found:', post.title); + console.log('Content length:', (post.content || '').length); + + let content = post.content || ''; + + // Check if already applied + if (content.includes('id="table-of-contents"')) { + console.log('ToC already present. Skipping.'); + await mongoose.disconnect(); + return; + } + + // Add section IDs to headings + for (const [heading, id] of Object.entries(headingIds)) { + // Match

    heading text

    and add id attribute + const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); + const regex = new RegExp(`

    (${escaped})

    `, 'gi'); + content = content.replace(regex, `

    $1

    `); + } + + // Add ToC at start, glossary at end + content = tableOfContents + '\n' + content + '\n' + glossary; + + await db.collection('blog_posts').updateOne( + { _id: post._id }, + { $set: { content, updatedAt: new Date() } } + ); + + console.log('Updated. New content length:', content.length); + console.log('ToC: added'); + console.log('Glossary: added'); + console.log('Section IDs: added to headings'); + + await mongoose.disconnect(); + console.log('Done.'); +} + +main().catch(err => { console.error(err); process.exit(1); });