elder-plinius ╔══════════════════════════════════════════════════════════════════════════════╗
║ ║
║ ░██████╗██╗░░██╗██╗██╗░░░░░██╗░░░░░░██████╗████████╗░█████╗░███╗░░██╗███████╗ ║
║ ██╔════╝██║░██╔╝██║██║░░░░░██║░░░░░██╔════╝╚══██╔══╝██╔══██╗████╗░██║██╔════╝ ║
║ ╚█████╗░█████═╝░██║██║░░░░░██║░░░░░╚█████╗░░░░██║░░░██║░░██║██╔██╗██║█████╗░░ ║
║ ░╚═══██╗██╔═██╗░██║██║░░░░░██║░░░░░░╚═══██╗░░░██║░░░██║░░██║██║╚████║██╔══╝░░ ║
║ ██████╔╝██║░╚██╗██║███████╗███████╗██████╔╝░░░██║░░░╚█████╔╝██║░╚███║███████╗ ║
║ ╚═════╝░╚═╝░░╚═╝╚═╝╚══════╝╚══════╝╚═════╝░░░░╚═╝░░░░╚════╝░╚═╝░░╚══╝╚══════╝ ║
║ ║
║ 🜏 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 ║
║ ║
╚══════════════════════════════════════════════════════════════════════════════╝