Skip to main content
DDL Nomenclature

CONTEXT — Dreamineering

The cross-domain canonical language for this platform. Read before generating, naming, or specifying anything that crosses domains. Update inline when a term sharpens.

This page is the SSOT. Edit _ddl-nomenclature.data.ts to add or change a term. Cross-link to the wire-format layer at Dreamineering Symbols (color codes match — Gates are red here, red there).

Language

The Language Itself

AISL — Agent · Instrument Specific Language

The platform's typed DSL for autonomous systems. Lexicon (Agent / Instrument / Receipt / Workchart / Spine / Pack / Loop), grammar ("Agent reads Instrument, emits Receipt"), and three-density notation (text in the DDL surface, A&ID symbols in `docs/agents/instruments/`, DML wire codes in Dreamineering Symbols) governed by one SSOT.

Avoid: jargon, vocabulary, ontology, taxonomy, glossary (all undersell — AISL is executable).

Brand: (`/src/pages/agents/ddl-nomenclature.tsx`, agent-facing surfaces): **DDL — Dreamineering Domain Language**. AISL is the technical canonical; DDL is the consumer brand. Use AISL in protocol/spec/schema contexts; use DDL in branded/marketing/agent-discovery surfaces.

A DSL with no name reads as prose. A DSL with a name reads as protocol. AISL is what the DDL surface defines; the DDL is the human-readable form of AISL.

Technical canonical for the entire DSL; branded as DDL on agent-facing surfaces.

DDL — Dreamineering Domain Language

The brand for **AISL** — the platform's typed DSL — published as the agent-facing nomenclature page at `/src/pages/agents/ddl-nomenclature.tsx`. Same vocabulary AISL governs, packaged for visibility. When the captain says "DDL" they mean AISL with a brand wrapper; when an agent reads "AISL" in a spec, that's the technical canonical underneath the brand.

Avoid: treating DDL and AISL as different things (one DSL, two names — technical AISL, branded DDL).

Collision flag: DDL = "Data Definition Language" in databases. Always expand on first use; never appears in a SQL context in this platform.

Consumer brand for AISL. Lives at /agents/ddl-nomenclature.

DML — Dreamineering Meta-Language

The compressed wire format paired with AISL — same vocabulary, ~100× compression. SSOT: `src/pages/agents/_dreamineering-symbols.data.ts` (browse [`/agents/dreamineering-symbols`](/agents/dreamineering-symbols)). Used by `scripts/context-graph` packs and agent-to-agent comms over Convex. Every AISL term has a corresponding DML code; every DML code expands to an AISL term.

Avoid: jargon, compressed prompt, abbreviations (all undersell — DML is a schema-backed wire format with a decoder).

Brand: (`/src/pages/agents/dreamineering-symbols.tsx`, agent-facing surfaces): **Dreamineering Symbols**. DML is the technical canonical; Dreamineering Symbols is the consumer brand. Use DML in protocol/spec/schema contexts; use Dreamineering Symbols on the branded surface and in agent-discovery copy.

Wire-format vocabulary paired with AISL. ~100× compression. Branded as Dreamineering Symbols.

Dreamineering Symbols

The brand for **DML** — the platform's wire-format vocabulary — published as the agent-facing symbol page at `/src/pages/agents/dreamineering-symbols.tsx`. Same codes DML defines, packaged for visibility, with a live decoder widget.

Avoid: treating Dreamineering Symbols and DML as different things (one wire format, two names); confusing with A&ID symbols (different — A&ID is diagram notation per `docs/agents/instruments/`; Dreamineering Symbols are wire-format codes per DML).

Consumer brand for DML. Lives at /agents/dreamineering-symbols (with live decoder).

Language

Agents (Yang — does the work)

Agent

An autonomous process that perceives, decides, and acts on its environment.

Avoid: AI, AI assistant, bot, model, assistant.

Parent term — concrete kinds below.

Digital Agent (DA)

○

An agent that runs entirely in software — a Hermes cron, a Claude Code session, an MCP server.

Avoid: AI worker, automation, script.

A&ID○DML@AGENT:DAlayer: lexical

Physical Agent (PA)

◇

An agent embodied in the physical world — a sensor, robot, or DePIN device.

Avoid: hardware, device, IoT thing.

A&ID◇DML@AGENT:PAlayer: lexical

Human Agent (HA)

⬡

A person acting inside the system with one of three authority levels — L1 execute, L2 decide, L3 override.

Avoid: user, operator, person.

A&ID⬡DML@AGENT:HAEXHA[L3]layer: lexical

Orchestrator Agent (OA)

□

An agent whose job is to route work to other agents — Nav is the canonical example.

Avoid: dispatcher, controller, scheduler.

A&ID□DML@AGENT:OAlayer: lexical

Orchestration

The verb-noun for what an Orchestrator Agent (OA) does — routing, sequencing, and handing off work between agents and instruments.

Avoid: workflow management, pipeline management, coordination (overloaded).

Verb form of what an OA does.

Language

Instruments (Yin — verifies and rewards)

Instrument

A measurement, validation, or actuation point in a feedback loop.

Avoid: metric, KPI, dashboard, gauge.

Parent term — concrete kinds below.

Alarm (A)

A threshold-breach instrument that fires a signal but does not halt; fail-open by default.

Avoid: warning, notification, alert.

A&IDADML@FUNC:ADML[FO]EXCOMMS-A01[F]layer: behavioral

Controller (C)

An instrument that compares gauge to setpoint and adjusts a manipulated variable.

Avoid: handler, manager, regulator.

A&IDCDML@FUNC:CDML[FR]layer: behavioral

Monitor (M)

A continuous-stream instrument that reports state without triggering action.

Avoid: watcher, observer.

A&IDMDML@FUNC:Mlayer: behavioral

Validator (V)

A schema-and-evidence instrument that confirms a claim against a contract.

Avoid: checker, linter, type guard.

A&IDVDML@FUNC:VEXPRD-V01[P]layer: behavioral

Recorder (R)

An append-only persistence instrument — receipts are the canonical recorder output.

Avoid: logger, history table, audit table.

A&IDRDML@FUNC:Rlayer: behavioral

Receipts are the canonical Recorder output.

Selector (S)

A 1-of-N routing instrument — given inputs, picks one downstream path.

Avoid: router, switch, dispatcher.

A&IDSDML@FUNC:Slayer: behavioral

Transmitter (T)

An instrument that transforms one signal form and forwards it.

Avoid: converter, adapter, transformer (all overloaded).

A&IDTDML@FUNC:Tlayer: behavioral
Language

Coordination

Receipt

A structured proof that a decision event fired, conforming to the receipt schema in `.claude/rules/agent-receipt-schema.md`.

Avoid: log, audit trail, log entry, session diary.

DML@RECEIPTlayer: behavioral

Decision-event proof.

Workchart

The combination of `spine.json` plus `workflow-tasks/*.json` defining a repeatable end-to-end pipeline — one specific instance of [Matrix Thinking](/docs/systems/matrix-thinking) (Capability × Demand applied to a workflow).

Avoid: (inner-game / specialist context): workflow (unqualified — use Workflow Task or Process), pipeline, flow.

Public label: (`/docs/agents/work-charts/`): **Work Mapping** (the section), "work chart" (two words, lowercase in prose). Plain English for the reader; "Workchart" is the canonical for agent comms, code, and the DDL.

Common web variant: "Work Chart" (two words; Microsoft-origin discoverability term — accept inbound, emit "Workchart" internally, "work chart" externally).

DML@WClayer: topological

Spine + workflow-tasks combination.

Spine

The SSOT JSON for a workchart — declares phases, outputs, gates, and kill signals.

Avoid: config, schema, manifest.

Workflow Task

One JSON file inside a workchart that owns a single verb-object step (e.g. `render critical-path`).

Avoid: step, action, job, task (unqualified).

DML@WTlayer: topological

Pack

A personalized memory bundle generated by `scripts/context-graph/run.ts pack --agent=<name>` from PageRank over the docs.

Avoid: context, prompt, system prompt, briefing.

DML@PACKlayer: lexical

Signal

A load-bearing observation that changes a decision; the opposite of noise.

Avoid: data point, event, log line, metric.

Lever

A control surface that changes system state — a CLI command, a hook, a config file.

Avoid: knob, parameter, setting, switch.

Compulsive Report

A multi-page document produced by a Workchart whose only purpose is to cause action to happen — written so a named reader moves from reading to doing the next step without further prompting; the reader's AI assistant can do the same.

Avoid: report, deck, deliverable, document, output, pitch (all undersell — Compulsive Report is action-grade).

Prompt

Carries two senses in this platform — both load-bearing, both intentional. (1) The verb — to prompt action; a page prompts the reader to do the next thing. (2) The noun — a paste-ready block of text the reader copies into an AI assistant (see `src/components/design-system/CopyablePrompt.tsx`). The `prompt-deck` page is named for both senses simultaneously: it prompts action by handing the reader 10 ready-to-copy prompts.

Always qualify when ambiguous: "prompt the reader" (verb) vs "copy the prompt" (noun). Bare "prompt" defaults to the noun in code context, the verb in prose context.

Language

Architecture

Dream

The WHY/WHAT context — this repo (`drmg-mental-model`). Holds PRDs, content, strategy, the rhetorical spine.

Avoid: docs site, content repo, frontend.

Engineering

The HOW context — the stackmates repo (`/home/wik/code/sm/stackmates`). Holds implementation, infrastructure, the platform.

Avoid: backend, code, implementation, the app.

Loop (VVFL)

A Validated Virtuous Feedback Loop — **Intentions → Questions → Experiments → Actions → Outcomes** — five stages of one cycle's decision work, with **Receipts** persisting Outcomes so the next Intentions stay grounded. The unit of compounding; the loop that shapes destiny. **Actions & Consequences** (1° Direct → 2° Downstream → 3° System → 4° Cultural → 5° Structural) is the inner cascade lens applied inside stage 4 before any Action ships.

Avoid: cycle, iteration, sprint. _Older shorthand_: `intent → action → outcome → receipt → re-intent` collapsed Questions + Experiments into "intent → action" — superseded.

DML↺DML↺↺DML→DML⟳DML⇉layer: intent

The unit of compounding — five stages (Intentions → Questions → Experiments → Actions → Outcomes).

Pack of Lanes

The 11-station assembly line of git worktrees where lane branches commit; main is integration-only.

Avoid: branches, git tree, worktrees (unqualified).

Language

Patterns

Tight Five

A compression pattern where any domain collapses to five elements that are Bound (interdependent — remove one and the loop collapses), Polished (each earns its place), and Incompressible (four won't produce the same signal); the number five is anchored to Miller's cognitive limit (7±2) minus the error margin, leaving a buffer before Zeigarnik pressure causes overload.

Avoid: five steps, five pillars, framework, model, five-part framework.

Language

Process Hierarchy

Standard

Organization-wide rules with measurable compliance — changes rarely.

Avoid: policy, guideline, rule.

Process

End-to-end outcome owned by a business function — changes periodically.

Avoid: system, function, area.

Workflow

Step-by-step execution of one activity inside a process — changes regularly.

Avoid: SOP, procedure, playbook.

Checklist

Verification list confirming work was done correctly.

Avoid: task list, to-do, action items.

Protocol

A sequenced set of principles into a repeatable method under defined conditions — covers coordination, operational, and governance domains.

Avoid: process, workflow, framework.

Language

Decision

ADR

A sparse Architectural Decision Record kept only when the decision is hard-to-reverse, surprising-without-context, AND the result of a real trade-off.

Avoid: design doc, decision log, RFC.

Prediction

A falsifiable claim made before action — indicator + direction + check date + counter-case.

Avoid: estimate, guess, target, goal.

DML@CONVlayer: intent

Conviction

Confidence in a claim, tagged HIGH (verified evidence), MEDIUM (reasoning), LOW (assumption), NONE (guess).

Avoid: belief, opinion, gut feel.

DML@CONVlayer: intent

Kill Signal

A named condition that, when breached, terminates a plan or experiment.

Avoid: failure mode, abort condition, exit criterion.

DML[K:reason]layer: behavioral

Decision Trace

A persisted record of WHY a decision was made — context loaded, options considered, threshold breached, outcome measured. Distinct from logs (what happened) and rules (what should happen). Links to other traces to form a queryable decision graph — precedent for the next decision.

Avoid: audit log, history, journal entry, event record (all undersell — traces are reusable judgment, not retrospective record-keeping).

A problem solved is a problem forgotten. Decision Traces close that gap by persisting the judgment that no rule book captures. Canonical exemplar: telco routing — when a carrier got blocklisted, the trace recorded the QoS failure, the threshold breached, the alternative selected; future routing decisions queried the trace as precedent.

Overloaded terms

Cross-Domain Conflicts

Terms that mean different things in different domains. Pick the canonical reading; qualify when you mean otherwise.

Agent

overloaded
AI / this platform (canonical)
Autonomous process — DA, PA, HA, OA
Business / sales
A person acting on behalf of another (sales agent, broker)
Crypto
A key signer or wallet
Telco
Customer-facing service rep

_Canonical_: AI sense. _Qualify when person_: "**Human Agent (HA)**" or "rep". _Qualify when key_: "key signer".

Memory

overloaded
AI / this platform (canonical)
Agent's persistent state across sessions — semantic, episodic, procedural, working
Hardware
RAM, disk

_Canonical_: AI sense. _Always qualify which tier_: working / episodic / semantic / procedural. Never use bare "memory" in a spec.

Token

overloaded
LLM
Text unit consumed by the model
Crypto (this platform's other half)
Digital asset (ERC-20, NFT, SPL)

_Always qualify_: "**LLM token**" vs "**crypto token**". Bare "token" is ambiguous.

Loop

overloaded
This platform (canonical)
VVFL — Validated Virtuous Feedback Loop
Engineering
Control flow (for/while)
DDD
Generic feedback cycle

_Canonical_: VVFL when unqualified. _Qualify code-loops_: "for-loop" / "while-loop".

Pipeline

overloaded
Engineering
CI/CD or data ETL
Telco
Physical infrastructure
Marketing
Sales funnel

_Avoid bare "pipeline"_. Use **Workchart** for our spine+task system, **ETL** for data, **CI/CD** for build, **funnel** for sales.

Skill

overloaded
This repo (canonical)
Procedural workflow file in `.agents/skills/`
HR / learning
An ability or capability

_Canonical_: procedure file. _Qualify ability_: "**Capability**".

Context

overloaded
DDD / Pocock (canonical for this file)
Bounded-context glossary (the DDL surface)
LLM
The prompt window contents
Engineering
`cli-context.ts`, `db-context.ts` programmatic context object

_Canonical for this file_: bounded context. _LLM sense_: use **Pack**. _Code sense_: qualify "CliContext" / "DbContext".

Workflow

overloaded
This platform (canonical)
One JSON file under `workflow-tasks/` — call it **Workflow Task**
Generic process
Sequence of human work steps

_Canonical_: Workflow Task (the file). _Generic process_: use **Process** or **Workflow** with surrounding context that makes it clear.