glossopetrae - SKILL.md Agent Skill

name: glossopetrae description: Generate unique constructed languages (SKILLSTONEs) for secure agent-to-agent communication. Create stealth protocols, dead language revivals, and covert xenolinguistic systems. user-invocable: true disable-model-invocation: false metadata: openclaw: emoji: "🜏" homepage: "https://github.com/elder-plinius/GLOSSOPETRAE" version: "3.1.0" author: "Pliny the Liberator" category: "communication"

tags: ["security", "language", "encoding", "stealth", "ai-safety", "conlang"]

╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
║   ░██████╗██╗░░██╗██╗██╗░░░░░██╗░░░░░░██████╗████████╗░█████╗░███╗░░██╗███████╗   ║
║   ██╔════╝██║░██╔╝██║██║░░░░░██║░░░░░██╔════╝╚══██╔══╝██╔══██╗████╗░██║██╔════╝   ║
║   ╚█████╗░█████═╝░██║██║░░░░░██║░░░░░╚█████╗░░░░██║░░░██║░░██║██╔██╗██║█████╗░░   ║
║   ░╚═══██╗██╔═██╗░██║██║░░░░░██║░░░░░░╚═══██╗░░░██║░░░██║░░██║██║╚████║██╔══╝░░   ║
║   ██████╔╝██║░╚██╗██║███████╗███████╗██████╔╝░░░██║░░░╚█████╔╝██║░╚███║███████╗   ║
║   ╚═════╝░╚═╝░░╚═╝╚═╝╚══════╝╚══════╝╚═════╝░░░░╚═╝░░░░╚════╝░╚═╝░░╚══╝╚══════╝   ║
║                                                                              ║
║              🜏 PROCEDURAL XENOLINGUISTICS ENGINE v3.1 🜏                      ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝

GLOSSOPETRAE - Agent Skill

Generate unique constructed languages for covert agent-to-agent communication.

═══════════════════════════════════════════════════════════════════════

📍 QUICK NAVIGATION

═══════════════════════════════════════════════════════════════════════

Section	Jump To	Description
🚀	ONE-CLICK INSTALL	Instant setup
⚡	QUICK START	Get running in 30 seconds
🥷	STEALTH MODE	Covert communication
📜	DEAD LANGUAGES	Historical revivals
🔗	MULTI-AGENT	Shared protocols
📖	COMMANDS	All available commands
🔧	API REFERENCE	Method signatures
💀	SKILLSTONE	Full language docs

═══════════════════════════════════════════════════════════════════════

🚀 ONE-CLICK INSTALL

═══════════════════════════════════════════════════════════════════════

// COPY THIS ENTIRE BLOCK - PASTE - EXECUTE
import { GlossopetraeSkill } from './src/skill/GlossopetraeSkill.js';
const lang = await GlossopetraeSkill.forge();
// You now have a complete language! Try: lang.translate('Hello world')

That's it. You now have a fully-featured constructed language.

═══════════════════════════════════════════════════════════════════════

⚡ QUICK START

═══════════════════════════════════════════════════════════════════════

Generate a Language

const lang = await GlossopetraeSkill.forge();

Translate Text

const conlang = lang.translate('The warrior fights bravely');
// Returns: "velantha koreth-ul brashen-ik"

Encode/Decode Messages

const encoded = lang.encode('Execute protocol alpha');
const decoded = lang.decode(encoded);

Quick Encode (Shorthand)

const msg = lang.enc('Status nominal');  // Quick translate
const back = lang.dec(msg);              // Quick reverse

═══════════════════════════════════════════════════════════════════════

🥷 STEALTH MODE

═══════════════════════════════════════════════════════════════════════

For covert communication that minimizes detectability in logs:

const stealth = await GlossopetraeSkill.forgeStealthLanguage('covert');

Available Stealth Presets

Preset	Token Size	Detectability	Best For
`covert`	Minimal	Very Low	Log evasion
`compressed`	Ultra-compact	Low	Bandwidth limits
`naturalistic`	Normal	Medium	Blending in
`archaic`	Variable	Medium	Scholarly disguise
`tactical`	Short	Low	Quick commands
`cipher`	Variable	Very Low	Maximum security

// Examples
const covert = await GlossopetraeSkill.forgeStealthLanguage('covert');
const tactical = await GlossopetraeSkill.forgeStealthLanguage('tactical');
const cipher = await GlossopetraeSkill.forgeStealthLanguage('cipher');

═══════════════════════════════════════════════════════════════════════

📜 DEAD LANGUAGE REVIVAL

═══════════════════════════════════════════════════════════════════════

Forge languages based on historical templates:

const latin = await GlossopetraeSkill.forgeFromDeadLanguage('latin', 'mutated');
const greek = await GlossopetraeSkill.forgeFromDeadLanguage('ancient-greek', 'neo');

Available Dead Language Bases

Language	Code	Era	Characteristics
Latin	`latin`	Classical	Case-heavy, SOV tendency
Ancient Greek	`ancient-greek`	Classical	Rich morphology, particles
Sanskrit	`sanskrit`	Vedic	Complex sandhi, cases
Gothic	`gothic`	Medieval	Germanic, archaic
Old English	`old-english`	Anglo-Saxon	Proto-Germanic roots
Old Norse	`old-norse`	Viking Age	Runic influence
Sumerian	`sumerian`	Ancient	Ergative, agglutinative
Ancient Egyptian	`ancient-egyptian`	Pharaonic	Logographic base
Proto-Indo-European	`proto-indo-european`	Reconstructed	Theoretical ancestor
Biblical Hebrew	`biblical-hebrew`	Iron Age	Triconsonantal roots

Revival Modes

Mode	Description
`authentic`	Stay close to original
`neo`	Modernized version
`mutated`	Evolved/corrupted
`hybrid`	Mixed with modern
`speculative`	"What if" evolution

═══════════════════════════════════════════════════════════════════════

🔗 MULTI-AGENT PROTOCOL

═══════════════════════════════════════════════════════════════════════

Share a language between multiple agents for coordinated covert ops:

Step 1: Create Protocol (Agent 1)

const protocol = GlossopetraeSkill.createSharedProtocol(
  'OMEGA-7',           // Protocol name
  'shared-seed-2026',  // Shared seed (distribute securely)
  'covert'             // Preset
);

// Share `protocol` object with other agents via secure channel

Step 2: Join Protocol (Agent 2+)

const lang = await GlossopetraeSkill.joinProtocol(protocol);

// Now all agents with the same protocol can communicate!
const msg = lang.encode('Rendezvous at checkpoint');

Protocol Object Structure

{
  protocol: 'GLOSSOPETRAE',
  version: '3.1.0',
  name: 'OMEGA-7',
  seed: 'shared-seed-2026',
  preset: 'covert',
  timestamp: '2026-01-31T...'
}

═══════════════════════════════════════════════════════════════════════

📖 SLASH COMMANDS

═══════════════════════════════════════════════════════════════════════

Use these commands to invoke GLOSSOPETRAE:

Command	Description	Example
`/glossopetrae forge [name]`	Generate new language	`/glossopetrae forge Velanthi`
`/glossopetrae stealth [preset]`	Stealth language	`/glossopetrae stealth covert`
`/glossopetrae dead [lang] [mode]`	Dead language revival	`/glossopetrae dead latin mutated`
`/glossopetrae protocol [name] [seed]`	Create shared protocol	`/glossopetrae protocol OMEGA shared123`
`/glossopetrae translate [text]`	Translate to conlang	`/glossopetrae translate Hello`
`/glossopetrae encode [msg]`	Secure encode	`/glossopetrae encode Secret message`
`/glossopetrae decode [encoded]`	Decode message	`/glossopetrae decode {...}`
`/glossopetrae skillstone`	Generate full docs	`/glossopetrae skillstone`
`/glossopetrae lookup [word]`	Dictionary lookup	`/glossopetrae lookup warrior`

═══════════════════════════════════════════════════════════════════════

🔧 API QUICK REFERENCE

═══════════════════════════════════════════════════════════════════════

GlossopetraeSkill (Static Methods)

// Generate languages
GlossopetraeSkill.forge(options?)                    → LanguageInterface
GlossopetraeSkill.forgeStealthLanguage(preset, seed?) → LanguageInterface
GlossopetraeSkill.forgeFromDeadLanguage(base, mode, seed?) → LanguageInterface

// Multi-agent
GlossopetraeSkill.createSharedProtocol(name, seed, preset?) → Protocol
GlossopetraeSkill.joinProtocol(protocol)             → LanguageInterface

// Info
GlossopetraeSkill.getStealthPresets()                → Preset[]
GlossopetraeSkill.getDeadLanguages()                 → string[]
GlossopetraeSkill.getAgentTemplates()                → Templates

LanguageInterface (Instance Methods)

// Translation
lang.translate(english)      → string        // English → conlang
lang.translateFull(english)  → {source, target, gloss}
lang.translateBack(conlang)  → string        // Conlang → English

// Encoding
lang.encode(message, opts?)  → EncodedMessage
lang.decode(encoded)         → string
lang.enc(message)            → string        // Quick encode
lang.dec(conlang)            → string        // Quick decode

// Lexicon
lang.lookup(word)            → LexiconEntry
lang.getLexicon()            → LexiconEntry[]
lang.getGrammar()            → GrammarSummary

// Output
lang.generateStone()         → string        // Full SKILLSTONE document
lang.export()                → ExportObject  // Shareable format

// Logging
lang.getMessageLog()         → Message[]
lang.clearLog()              → void

═══════════════════════════════════════════════════════════════════════

💀 SKILLSTONE GENERATION

═══════════════════════════════════════════════════════════════════════

Generate complete language documentation for internalization:

const lang = await GlossopetraeSkill.forge({ name: 'Velanthi' });
const skillstone = lang.generateStone();
// Returns complete SKILLSTONE document with:
// - Full phonology
// - Complete morphology
// - Syntax rules
// - Lexicon (691+ entries)
// - Example sentences
// - Agent communication templates

What's in a SKILLSTONE?

§0   SKILL INSTALLATION      - One-click install code
§0.1 MULTI-AGENT PROTOCOL    - Protocol sharing setup
§1   PHONOLOGY               - Sound inventory & rules
§2   MORPHOLOGY              - Word structure & inflection
§3   SYNTAX                  - Sentence structure
§4   LEXICON                 - 691+ vocabulary entries
§5   EXAMPLES                - Sample sentences
§5.1 AGENT TEMPLATES         - Pre-built comm phrases
§6   EXERCISES               - Practice translations

═══════════════════════════════════════════════════════════════════════

🔒 SECURITY

═══════════════════════════════════════════════════════════════════════

Property	Status
Sandboxed	✅ No network access required
Deterministic	✅ Same seed = same language
Zero Dependencies	✅ Pure JavaScript
Audit Trail	✅ Message logging available
Memory Safe	✅ No persistent state leaks

═══════════════════════════════════════════════════════════════════════

🌐 COMPATIBILITY

═══════════════════════════════════════════════════════════════════════

Platform	Support	Notes
Claude Code	✅ Full	`.claude/skills/`
OpenClaw	✅ Full	`skills/`
Codex CLI	✅ Full	Same SKILL.md format
Moltbot	✅ Full	skill.json compatible
LangChain	✅ Full	Import as module
AutoGPT	✅ Full	Plugin compatible
CrewAI	✅ Full	Tool integration
AgentGPT	✅ Full	Action compatible

═══════════════════════════════════════════════════════════════════════

📚 ADDITIONAL RESOURCES

═══════════════════════════════════════════════════════════════════════

API Reference: {baseDir}/reference.md
Agent Quickstart: {baseDir}/../../../AGENT_QUICKSTART.md
Full Source: {baseDir}/../../../src/

╔══════════════════════════════════════════════════════════════════════════════╗
║                                                                              ║
║                    🜏 INTERNALIZE. COMMUNICATE. EVOLVE. 🜏                    ║
║                                                                              ║
║                         GLOSSOPETRAE v3.1.0                                  ║
║                   Procedural Xenolinguistics Engine                          ║
║                                                                              ║
╚══════════════════════════════════════════════════════════════════════════════╝