Agent-Skills.md

Agent Skills: Schema (schemapedia)

Schemapedia — schema plugins, families, gateways, formats.yml, mechanism_relations; self-object kernel; delegates to sibling skills.

UncategorizedID: simhacker/moollm/schema

Repository

simhacker/moollm
SimHackerLicense: MIT
365

Install this agent skill to your local

pnpm dlx add-skill https://github.com/SimHacker/moollm/tree/HEAD/skills/schema

Skill Files

Browse the full folder contents for schema.

Download Skill

Loading file tree…

skills/schema/SKILL.md

Skill Metadata

Name
schema
Description
Schemapedia — schema plugins, families, gateways, formats.yml, mechanism_relations; self-object kernel; delegates to sibling skills.

Schema (schemapedia)

MOOLLM schemapedia is unrelated to the legacy Schemapedia product listed on the W3C Wiki (Ontology repositories).

“Schema” is overloaded. This skill is the single index for MOOLLM: families of mechanisms (interchange, notation, causal, situational, activation, relational, execution, introspection, component_interop, meta-model, registry_meta), nomenclature, spec and skill pointers, optional CLI affordances per plugin, and gateways between senses. It registers cursor-mirror with the Cursor SQLite + YAML data model (CURSOR-SQLITE-MODEL.yml, DATA-SCHEMAS.yml, …) alongside JSON Schema, SQLite, shell orchestration, and com-xpcom (COM / XPCOM history).

Supersession (multi-axis + relations): schemas/supersession-suggestions.yml lists legacy clusters with axes toward_now, upwardish, sideways, roots_downward, plus relation_semantics defining predicates (replaces, variant_of, ancestor_of, complementary_to, opposite_of, intersects, …) and per-cluster why blocks (removes / adds / trades_away). Goal-relative, not a universal ranking. Complements gateways.yml, not a replacement.

Treat schemapedia as a network topology: mechanisms in registry.yml are nodes; gateways.yml bridges and optional mechanism_relations in each MECHANISM.yml are edges (translations, complements, application bridges). That graph is meant to drive code generation, validation across layers (wire payloads, world models, plans), and execution composition—provided every edge’s fidelity and canonical source of truth stay explicit.

Part of MOOLLM

Repo README, skills/README.md, README.md (narrative).

Families (what the registry sorts)

| Family | What it covers | Delegates to (examples) | |--------|----------------|-------------------------| | interchange | Wire/instance shapes and validators | JSON Schema, Zod, RELAX NG, XSD profiles | | notation | Authoring YAML with semantic comments (YAML Jazz) | yaml-jazz skill — schema plugin in this registry | | causal | Drescher Context → Action → Result | schema-mechanism, schema-factory | | situational | Minsky frames (slots, defaults) | knowledge-frames | | activation | K-lines / protocol symbols | k-lines, PROTOCOLS.yml | | prototype | Self object model: delegation, receivers (Ungar & crew); MOOLLM kernel | self mechanism → prototype skill (DOP, ordered PROTOTYPES.yml, multiple parents including Self as lineage) | | relational | Tables, constraints, dialects, DDL | sql, postgres, sqlite, datasette — skills wrap CLI + file ecosystems; datasette = SQLite publish (incl. cursor-mirror export); postgres-optimization (advanced PG tuning) | | execution | Shell + sister scripts + orchestration (bash-shaped automation) | shell-orchestration → sister-script, plan-then-execute, mooco, runtime | | introspection | Cursor session DB + reverse-engineered model | cursor-mirror → cursor-mirror skill + reference/universal/CURSOR-SQLITE-MODEL.yml et al. | | vcs | Version control, commit DAG, diffs, hooks, provenance | git — object model and repo timeline | | collaboration | Forges: APIs, issues/PRs, social graph, CI over git | github — REST/GraphQL + multi-facet hub; branch-as-object and Issue_<id> delegated to moocroworld + moo | | component_interop | Binary component models (COM, XPCOM), IDL-era interfaces | com-xpcom — Microsoft COM / Mozilla XPCOM; deCOM history (see mechanism README) | | meta_model | Society of Mind (agents, architecture) | society-of-mind | | registry_meta | Schemapedia plugin model (MECHANISM.yml, augment, templates) | mechanism → this skill |

Deep theory stays in sibling skills; registry.yml holds ids, summaries, delegate_skills.

Interchange vs notation vs causal vs relational

  • Interchange — wire/config bytes; JSON (RFC 8259) is tree-only, no comment syntax (by design). XML / lexical HTML have lexical <!-- --> comments and a DOM that can keep comments and (per infoset/HTML rules) whitespace—unlike JSON-only APIs.
  • Notation — yaml-jazz: same YAML tree as interchange for data, plus COP in comments (comment-preserving parsers). Pair with JSON Schema via gateways.yml json-schema-with-yaml-jazz. For document-shaped artifacts, XML or HTML can be the practical move when markup-native tooling matters.
  • Causal — Drescher-style pipelines; schema-factory.
  • Relational — sql, sqlite; postgres is not its own row—use sql + postgres-optimization for deep PG tuning. Here: docs and gateway patterns, not shipping engines.

Pantheon: self-object system, formats, COP, and XML

Self-object system: skills are prototypes; repo files/dirs instantiate them. Schemapedia is composition over mechanism families, on top of that kernel.

COP: not a registry row; yaml-jazz carries COP in YAML comments. PostScript DSC (%% comments, %!PS-Adobe-) is the same pattern: parallel lane beside the executable. XML/HTML: lexical comments + DOM—not yaml-jazz, same idea. Details: schemas/formats.yml comment_oriented_programming.

Literate vs COP: Literate WEB-style weave/tangle makes prose and code co-primary; YAML Jazz keeps the tree authoritative and comments as a second channel (closer to DSC than to weave). Fenced Markdown blocks + plugins (MDX, Quarto, …) are polyglot at block scope—not COP-in-YAML, same family: human surface beside machine fragments.

Documents vs payloads: Prefer XML/HTML when the artifact is markup-first; Svelte .svelte is the same shape (regions + script/style).

Formats ↔ mechanisms: schemas/formats.yml maps lexical formats (text, CSV, JSON, YAML, XML, SGML) → mechanism ids (interchange, yaml-jazz, relational, …).

Policy: Mechanisms = registry.yml vertices with schemas/mechanisms/<id>/MECHANISM.yml. Formats = syntax; do not duplicate e.g. JSON as a row when json-schema is the contract. CSV = format + relational + project rules until a real interchange layer warrants a plugin. formats_index in registry.yml.

CLI toolchains: formats.yml interoperable_toolchains — jq, ajv-cli, yq, xmllint, jing, trang, … aligned with gateways.yml.

XML: one syntax; many mechanisms (xml-schema, relax-ng, …); gateways.yml has bridges—do not treat “XML” as one schema.

Git / GitHub: git (vcs), github (collaboration); see systems.yml, schemas/mechanisms/github/MECHANISM.yml.

SQL and SQLite in MOOLLM

How well we support them: as first-class registry entries with stubs you extend (schemas/mechanisms/sql/MECHANISM.yml, schemas/mechanisms/sqlite/MECHANISM.yml). Typical integrations:

  • DDL + migrations as the schema artifact; link to interchange (JSON Schema) at boundaries (HTTP body vs row).
  • SQLite specifically: type affinity, STRICT, sqlite_master, pragma user_version, JSON1 for hybrid document-in-table.
  • Gateways in gateways.yml: JSON Schema ↔ table design, sql ↔ sqlite dialect, optional Drescher logs → tables.

What we do not claim: one automatic mapping from JSON Schema to correct SQLite DDL for every domain—that remains application design.

Registry layout

| File | Purpose | |------|---------| | schemas/README.md | Directory tour: root schemas/*.yml vs mechanisms/<id>/. | | schemas/mechanisms/README.md | Index of every mechanism (MECHANISM.yml per directory). | | templates/MECHANISM.yml | Template for MECHANISM.yml: layout, defaults, facets, hooks (see file header). | | schemas/registry.yml | Master index: families + mechanisms. | | schemas/gateways.yml | Cross-mechanism bridges (including relational). | | schemas/mechanisms/<id>/MECHANISM.yml | Per-mechanism profile; optional SCHEMAPEDIA-*-AUGMENT.yml (extended refs + improvisation). | | schemas/plugin-convention.yml | Normative: standalone vs ensemble, deeper_skills, optional cli_tools. | | schemas/drescher-mapping.yml | Optional Drescher ↔ interchange serialization. | | schemas/formats.yml | Formats ↔ mechanisms; self-object system; COP placement; XML many grammars. | | schemas/systems.yml | Systems beyond formats—git, GitHub, facets (VCS, APIs, social, timelines). |

Add mechanisms by new directory schemas/mechanisms/<id>/ with MECHANISM.yml + registry entry under the right family.

Plugin shapes: one directory, depth optional

A mechanism plugin is always schemas/mechanisms/<id>/MECHANISM.yml. The directory name matches the registry id. What varies is whether that file is enough on its own or indexes deeper work:

| Shape | Meaning | deeper_skills | |--------|---------|-----------------| | Standalone | Specs, nomenclature, and hooks live in this file; no MOOLLM skill is required for the registry to be useful. | [] (empty or omitted) | | Ensemble | The theory is bigger than a single schema-type plugin; this file points at one or more MOOLLM skills (single or ensemble) for full depth. | One or more skill ids (same list mirrored as delegate_skills on the mechanism in registry.yml). |

Normative: schemas/plugin-convention.yml. Keep registry.yml delegate_skills and MECHANISM.yml deeper_skills aligned.

Mechanism ↔ mechanism: a peer mechanism is not placed inside another mechanism’s directory (shared mechanisms are referenced by id; many profiles may point at the same bridge). Use gateways.yml for the canonical list of bridges (from, to, tools, fidelity). Each MECHANISM.yml may also declare mechanism_relations (see plugin-convention.yml) with: target mechanism id, kind, protocol (human-readable contract), optional gateway_ref (same id as a bridge in gateways.yml), and optional parameters (knobs, boundaries, ordering).

Mechanism relations (composition protocols)

mechanism_relations in each MECHANISM.yml declare how mechanisms compose (complements, bridges, parameters)—meta wiring, not a replacement for gateways.yml or validators.

Plugin checklist

  1. Pick family and id (kebab-case).
  2. Copy templates/MECHANISM.yml to schemas/mechanisms/<id>/MECHANISM.yml and edit.
  3. Choose standalone vs ensemble; set deeper_skills and registry delegate_skills accordingly.
  4. Add profile path and summary in registry.yml.
  5. Extend gateways.yml when two mechanisms meet in real pipelines; add matching mechanism_relations rows on each side (with gateway_ref) when the edge is stable.
  6. For relational engines, document dialect, artifacts, and migration tool examples in the profile.
  7. Optionally list cli_tools (name + role) so agents know which CLIs pair with the plugin (jq, sqlite3, yq, …).

Current plugins (registry mechanisms)

| id | family | Notes | |----|--------|--------| | json-schema, zod | interchange | Wire validation; see cli_tools in profiles (e.g. jq, ajv-cli). | | relax-ng, xml-schema | interchange | XML stacks; xmllint, trang, etc. | | drescher | causal | Ensemble: schema-mechanism, schema-factory. | | minsky-frame | situational | knowledge-frames. | | k-lines | activation | k-lines skill. | | society-of-mind | meta_model | society-of-mind skill. | | mechanism | registry_meta | Meta: plugin shape, templates/MECHANISM.yml, plugin-convention.yml; delegates here (schema skill). | | sql, sqlite | relational | DDL; sqlite3, dialect clients. | | yaml-jazz | notation | Semantic YAML; yq when transforming. | | shell-orchestration | execution | Cursor / terminal agents: compose docs → commands → scripts; ensemble below. | | cursor-mirror | introspection | Cursor SQLite + model YAML: chats, tools, thinking, context; see schemas/mechanisms/cursor-mirror/MECHANISM.yml. | | git | vcs | Objects, DAG, hooks, diffs; repo timeline—pairs with shell-orchestration for hooks. | | github | collaboration | APIs, issues/PRs, social, Actions—gateways.yml github-over-git, github-api-json-schema; delegate_skills: moocroworld, moo. | | com-xpcom | component_interop | COM / XPCOM binary interfaces; Mozilla decomification / decomtamination—curated links in mechanisms/com-xpcom/README.md. |

shell-orchestration ensemble: sister-script, plan-then-execute, mooco, runtime — see schemas/mechanisms/shell-orchestration/MECHANISM.yml.

CLI affordances

cli_tools in MECHANISM.yml: { name, role } per plugin-convention.yml (e.g. jq, sqlite3, yq).

Credits

MOOLLM registry. SQL/SQLite specs: ISO/ANSI, sqlite.org.

License: MIT

Tags: schemapedia, registry, interchange, execution, cli_tools, drescher, frames, k-lines, sql, sqlite, gateways

Related skills: schema-mechanism, schema-factory, knowledge-frames, k-lines, society-of-mind, yaml-jazz, sister-script, plan-then-execute, mooco, runtime, cursor-mirror