One of five failure strategies in the Workflow Loop's vocabulary. Stops the workflow immediately. No further steps execute. Already-completed steps are not automatically rolled back unless they declared compensation actions. The system emits WORKFLOW_ABORTED on the Data Bus.

An external service or library that the constellation depends on deliberately because building it would be impractical. Each adopted dependency is declared in the Constellation Spec with a justification, isolated behind exactly one loop type, and wrapped in a Dependency Gate. Examples: Supabase, Twilio.

The computational core of Loop 2.1. Performs addition, subtraction, AND, OR, XOR, NOT, and shift operations on 16-bit unsigned integers. Operates on two operands captured from the ALU Loop. The ALU is the hardware analog of the Loop MMT Compute Loop.

A circular retention log maintained by a bus when the Transit Gate's archive policy is active for a packet type. Stores copies of delivered packets up to a declared maximum count or time window. The oldest entries are overwritten when the buffer is full. Used by the Observatory to display recent traffic history, and by the Operator for post-incident diagnostics. The L21 analog is the session recording file — a replay log of everything that happened.

A specialized Filter Loop positioned between the Presentation Loop and the Working Loop. Every operator action passes through the Auth Gate before entering the system. Performs three functions: identity verification (validates session token via auth provider), role-based access control (checks the operator's role against the declared permission matrix), and session management (token refresh, expiration, forced logout). Enforces permissions structurally — the same way the closure wall enforces loop capabilities.

A Signal Loop that writes an immutable, append-only log of every state change in the constellation. Who did what, when, to which record. Listens on the Signal Bus. Never blocks the core pipeline.

A pattern for operating on multiple records atomically. L21 analog: Memory batch write sends all 16 slots sequentially; destructive read clears after reading. In MMT: a Workflow pipeline where the first step is a bulk pull request and subsequent steps operate on the entire result set. Includes the read-and-consume variant where records are fetched and claimed atomically to prevent duplicate processing.

The largest of Loop 2.1's four circular storage loops (48 words). Houses two pattern matchers and two threshold gates for in-loop signal processing. Data circulates past inspection points where it can be filtered, matched, clamped, or ejected.

The second of three modes in a Dependency Gate. Active when the external dependency is unreachable. Write operations are held in an ordered local buffer (IndexedDB). Read operations fall back to a local cache. The gate emits DEPENDENCY_OFFLINE on the Data Bus.

A buffering mechanism between a loop's output and the bus. L21 analog: the PM bridge holds one ejected word until drained via bus. In MMT: smooths the flow when a loop produces output faster than the bus can carry it. Three overflow strategies: overwrite (latest wins), queue (FIFO), backpressure (loop pauses until bridge drains). Strategy and depth declared in the loop spec.

Custom infrastructure that the constellation owns entirely. The bus system, workflow engine, loop factories, and all business logic. No external dependencies. Built components are fully understood, fully testable, and fully controlled by the Operator.

In L21: a 24-slot shift register pipeline that physically moves 17-bit words between loops. The operator configures source and destination, turns the bus on, and data flows. L21 has nine buses in four categories. In MMT: a typed, independent message channel with a priority queue and contract validation at both ends. A constellation declares multiple named buses, each carrying a category of traffic. Buses are independent — a failure on one does not affect any other.

The mechanism by which loop boundaries are enforced. Each loop factory receives exactly the capabilities its type permits (bus, database client, DOM reference, external service clients) as constructor arguments. Capabilities not in the argument list do not exist in the loop's scope. Enforced by the JavaScript closure, verified by the test suite.

Chaining Filter Loops on the bus. L21 analog: PM1 → PM2 → TG1 → TG2, a four-stage conditional pipeline on the Big Loop. In MMT: each filter is independent with its own contract; the sequence is defined in the routing table, not in the filters. Adding a filter means updating the routing table — no existing code changes. The most powerful composition mechanism in the architecture.

A Filter Loop that modifies specific fields within declared bounds. L21 analog: Threshold Gate clamp mode rewrites values to a configured bound without ejecting them. In MMT: bounds are declared in the Constellation Spec. onViolation: 'clamp' adjusts silently to nearest bound. onViolation: 'reject' treats as validation failure. Distinct from Compute Loops: a Clamp enforces bounds, not business logic.

A scheduled event emitter that injects packets into the Working Loop on declared schedules. Not a loop type — infrastructure, like the bus. Reads a schedule table from the Constellation Spec. Supports cron-style schedules (time-of-day events) and interval-based schedules (periodic heartbeats). Clock-emitted packets carry a system-level identity (operator: system:clock) so they are distinguishable from human actions in the audit trail.

The structural enforcement mechanism for loop boundaries. Each loop is constructed inside a factory function. The factory's closure scope contains only the capabilities passed as arguments. A Compute Loop cannot access the database because the database client was never passed to its factory — the variable does not exist in its scope. The JavaScript scope chain is absolute.

One of five failure strategies. When a workflow step fails after earlier steps succeeded, the Workflow Loop executes compensation actions that undo the effects of previous steps. Each step can declare a compensate block in its pipeline spec — a packet to emit that reverses its effect. Based on the Saga pattern from distributed systems.

One of seven loop types. The ALU analog. Takes data in via the bus, applies pure business logic, and emits a result. No side effects, no database writes, no UI updates. Same input produces the same output every time. Testable in complete isolation. Receives only bus as a capability.

A named collection of loops and buses that constitutes a complete Loop MMT application. The Constellation Spec declares all loops, all buses, the routing table, pipeline specs, and packet contracts. A constellation is to Loop MMT what a machine configuration is to Loop 2.1.

The code that constructs all buses, wraps dependencies in gates, creates each loop by calling its factory with the correct capabilities, and wires the routing table. The wiring diagram made executable. Readable as a declaration of the system topology.

The master specification document for a Loop MMT application. Declares all loops, buses, the routing table, pipeline specs, packet contracts, and dependency declarations. Loaded into every AI conversation at session start. The constitution of the build.

The declared policy for resolving simultaneous writes to the same record from different devices. Three options: last-write-wins (simplest — second write overwrites first), field-level merge (non-conflicting field changes both apply), optimistic locking (write fails if record version has changed since read). Declared per data type in the Constellation Spec. Both writes are always captured in the audit trail regardless of strategy.

A Vault Loop dedicated to storing and serving application configuration. Holds static config (price tables, role definitions — loaded at startup, accessed via pull requests) and runtime config (feature flags, temporary surcharges — pushed to subscribing loops via CONFIG_UPDATED events when changed). The single answer to "where do I change X?"

A generated visualization of a constellation's structure produced from the Constellation Spec. Loops as nodes, buses as edges, routing entries as connections. A design-time comprehension tool — not a live traffic monitor. Answers: what are all the loops, how are they connected, what packet types flow between them, and where does a new module plug in? Because it is generated from the spec, it is always consistent with the spec and never hand-drawn from memory. As a constellation grows from 8 loops to 30 or more, the routing table becomes too long to hold in one's head as a list — the map makes the topology visible. Belongs alongside the Progress Dashboard and Action Plan as a planning and comprehension aid. Does not require the application to be running. Added in Standard v7.

The mechanism for evolving packet contracts without breaking existing consumers. Every packet carries a version field. The contract registry holds multiple versions per type. Consuming loops declare which versions they accept and provide migration functions. Deprecated versions trigger warnings. Retired versions are rejected by the bus. Enables rolling updates across multi-device deployments.

One of five failure strategies. Skips the failed step and proceeds to the next one in the pipeline. Used for non-critical steps only — if the SMS fails, the order is still valid. The failure is logged and the step's own retry mechanism handles eventual delivery.

Configurable trigger-based counting within loops. L21 analog: five counters with operator-configurable triggers that increment on specific events. In MMT: every loop maintains counters feeding health packets. The L21 insight: triggers are configurable — not just "packets processed" but "orders above $300." Triggers are declared in the Config Vault, updateable at runtime. The infrastructure layer beneath the Sentinel pattern.

The declared shape of a packet type — field names, types, required vs. optional, value constraints. Defined once in the Packet Contract Registry and enforced by the bus infrastructure at both the outbound and inbound gates. A packet that does not match its contract is rejected, not delivered.

Validation checkpoints at both ends of every bus transfer. The outbound gate verifies that a packet matches the sender's declared output contract. The inbound gate verifies it matches the receiver's declared input contract. Enforced by bus infrastructure, not by loop code.

The architectural property that prevents a failure in one loop from propagating to other loops. Enforced by two independent mechanisms: the closure wall (loops cannot access each other's internals) and bus contracts (loops cannot exchange non-conforming data). A failure in the Pricing Engine cannot crash the Order Vault.

One of the named buses in a constellation. Carries core business pipeline traffic — loop-to-loop communication, workflow orchestration, and error events. The critical path. Highest priority maintenance.

In L21: a selective destruction point on each loop's circumference, between the Read and Write heads. When closed, any bit passing through is zeroed. The operator uses it to deliberately destroy consumed data. In MMT: a lifecycle policy declared on buses, Vaults, and workflows that governs when and how data is retired. Three variants exist: Transit Gate (buses), Retention Gate (Vaults), and Workflow Gate (transaction logs). The structural answer to "where does data go to die?"

The Loop MMT stance on external dependencies. Not zero-dependency — pragmatically averse. Every dependency is a transfer of control. If you can build it yourself in less time than you'd spend managing the dependency, build it. If not, adopt it deliberately, isolate it behind a loop, and wrap it in a Dependency Gate.

A standard infrastructure wrapper that sits between a loop and an adopted dependency. Manages three modes: Live (normal operation), Buffered (dependency unreachable, writes buffer locally, reads fall back to cache), and Draining (dependency recovered, buffer draining in order). The gate is generic — not custom per dependency. Every dependency-facing loop uses the same gate infrastructure.

Every external dependency is a transfer of control. Loop MMT classifies dependencies as Built (owned entirely), Adopted (justified and isolated), or Forbidden (would compromise architectural guarantees). Each adopted dependency is accessed through exactly one loop type, so replacement affects exactly one loop.

A planned transition process for when an adopted dependency reaches end-of-life. Each dependency in the Constellation Spec declares a sunset profile: which loops are affected, what the alternatives are, the scope of the migration, whether the bus interface changes, and the estimated effort. The profile makes replacement cost visible before it is needed. Reviewed periodically. Preventive maintenance — the same principle as checking a fire extinguisher's expiration date.

A designated queue for messages that could not be delivered after exhausting their retry strategy. When a routed message fails all retries (a Signal Loop's SMS delivery failure, a Workflow step's repeated abort), it goes to the dead letter queue rather than being silently discarded. The queue is durable — entries persist until explicitly reviewed and resolved. Prevents silent data loss. Gives the operator visibility into what failed, when, and why. L21 analog: failed operations are written to the log for the operator to inspect; they do not disappear. Pairs naturally with the Outbox pattern.

The third of three Dependency Gate modes. The dependency has recovered. The gate drains the local buffer in order at a controlled rate, confirming each write before sending the next. When the buffer is empty, the gate emits DEPENDENCY_ONLINE and returns to Live mode.

A Filter Loop technique that collapses a burst of rapid-fire events into a single processed event after a quiet period. When an event arrives, start a timer. If another event arrives before the timer expires, reset the timer. When the timer expires without interruption, emit once. L21 analog: the operator deliberately pauses before routing a rapid sequence of inputs, letting them settle. Use cases: search-as-you-type (emit only after typing pauses), form auto-save (save after edits stop), price recalculation (recalculate after a batch of quantity changes). Distinct from the Batch pattern, which collects a fixed count; Debounce collects until silence. Pairs with the Fanout pattern when a debounced event needs to trigger multiple downstream processes.

A loop never trusts that an operation succeeded until the responsible loop confirms it by emitting a completion packet. L21 analog: the operator observes the ALU result before routing it further. In MMT: the UI shows "Order Confirmed" when the Vault emits ORDER_CREATED, not when the user taps Submit. The echo can carry metadata (persisted: true vs. persisted: buffered). The Workflow Loop is built entirely on Echoes: emit a step request, wait for the echo, proceed.

One of five failure strategies. Pauses the workflow and hands the decision to the Operator. The Workflow Loop emits WORKFLOW_PAUSED on the Data Bus. The UI shows an actionable item. The Operator decides: resume, retry, or abort. The mechanism that preserves the principle that the human is always in the loop.

The five-word vocabulary for what happens when a workflow step fails: Abort, Retry, Skip, Compensate, Escalate. This is the complete set. There is no sixth option. Each step in a pipeline spec declares its failure strategy using one of these five words.

The decision framework for assigning one of the five failure strategies to each step in a pipeline spec. The mechanism (one of five words) is simple; the decision is not, especially for steps that could plausibly use more than one strategy. Decision rules: Escalate when the cost of an automatic wrong decision exceeds the cost of delay — irreversible transitions, high-value payments, situations where system context is insufficient. Retry when the failure is likely transient and the operation is safe to repeat — network timeouts, rate limit hits, brief service unavailability. Always declare a retry limit; unbounded retries are an infinite loop. Abort when continuing would produce corrupt or inconsistent state — validation failures, missing prerequisite data, business rule violations. Skip when the failed step is supplementary and the workflow's primary purpose survives — notification delivery, analytics events, non-critical enrichment. Compensate when earlier completed steps must be explicitly undone — use sparingly; prefer ordering pipeline steps so irreversible operations come last, reducing the need for compensation entirely. Added in Standard v7.

One of seven loop types. The Pattern Matcher / Threshold Gate analog. Inspects data in transit and makes pass/reject/tag decisions. Validation, authorization, deduplication, anomaly detection. Never modifies business data. Receives only bus as a capability.

Diagnostic metadata produced alongside a Compute Loop's primary result. L21 analog: the comparator produces six flags (GT, LT, EQ, GTE, LTE, NEQ) alongside the ALU result — they inform but do not trigger automatic action. In MMT: the Pricing Engine calculates $285 and sets flags: loyaltyDiscountApplied, priceExceedsAverage. Flags travel in the packet. Any downstream loop can read them. The producing loop doesn't know who does.

A deliberate one-to-many dispatch where a single event needs to trigger multiple independent downstream processes simultaneously. Implemented as a Compute or Workflow Loop that emits multiple distinct packet types — one per downstream consumer — in response to a single input event. L21 analog: the operator routes the same word to multiple buses simultaneously. Example: an ORDER_COMPLETED event fans out to three separate processes: emit INVOICE_REQUESTED, emit INVENTORY_DEDUCTED, emit CUSTOMER_LOYALTY_UPDATED. Each recipient is independent — failure in one branch does not affect others. Distinct from the Split-Merge pattern, which waits for all branches to complete before continuing. Fanout fires and does not collect results.

A dependency that Loop MMT does not permit because it would compromise the architectural guarantees. UI frameworks (React, Vue), CSS frameworks, state management libraries, build tools. These sit in the layer where the closure wall and Two-Place Rule operate. If React owns the component tree, the closure wall doesn't work.

Data that exists outside the two permitted locations (on a bus or in a Vault). State hidden in a closure, a cache that diverges from the database, a UI component holding the authoritative copy of a record. Ghost state is where bugs hide. The Two-Place Rule exists to eliminate it.

Alerting on missing expected events. L21 analog: if a loop stops circulating data, the operator notices because the read head stops displaying new values. In MMT: the Observatory maintains a table of expected periodic events and tolerance windows. If the daily reconciliation usually runs at 11pm and it's 11:05 with no packet, a MISSING_EVENT alert fires. Most monitoring alerts on presence; this alerts on absence.

A dedicated channel carried by every bus, used for health packets (heartbeats and telemetry). Always DEFERRED priority — never interferes with business traffic. The infrastructure hook that enables the Observatory without requiring any application-level code changes.

A lightweight, standardized status broadcast emitted by loops, buses, and dependency gates. Types include HEALTH_HEARTBEAT (loop status, queue depth, processing time), HEALTH_BUS (bus queue depth, throughput, rejected packet count), and dependency gate status events. The Observatory consumes health packets to render live system state. The health packet spec is standardized across all constellations.

A Filter Loop that receives a sparse packet (just an ID), pulls full data from a Vault, and attaches it before passing the enriched packet along. L21 analog: loading a value from memory into the ALU loop to enrich the workspace before computation. Always done by a Filter Loop (enriches, not transforms); the pull goes through the Vault Bus. Downstream loops get everything they need in one packet.

The design goal for a Loop MMT application built to the full standard. A constellation that can explain itself (through the spec and documentation), verify itself (startup and runtime integrity checks), evolve safely (contract versioning and schema migration), survive its dependencies (sunset protocols and dependency gates), clean up after itself (Data Gates), alert when it is sick (Operator Alerts), and be understood by a stranger — indefinitely. The structural answer to software rot.

Two separate Loop MMT constellations exchanging data through a dedicated inter-constellation bus. L21 analog: P2P buses F and G connect two machines over WebRTC; the CBX protocol coordinates multi-machine challenges. In MMT: each constellation has its own loops, buses, and spec. The shared bus carries a defined set of packet types — a shared protocol. Neither constellation accesses the other's internals. The scaling story for how Loop MMT goes from one app to an ecosystem.

The first of three Dependency Gate modes. The dependency is reachable and responsive. Requests go straight through. The gate monitors latency and emits DEPENDENCY_DEGRADED if response times approach the timeout threshold.

In L21: a circular storage track where data circulates continuously. Bits advance one position per clock tick. L21 has four loops: Working (18 words), ALU (24 words), Memory (24 words), Big (48 words). In MMT: an independent processing module with a single responsibility, a declared interface, and a bus-only communication model. MMT has seven loop types.

A software architecture and development methodology inspired by Loop 2.1. Treats software as a constellation of independent loops connected by typed buses. Designed for solo developers leading AI coding assistants. Characterized by structural boundary enforcement, multi-bus fault isolation, workflow-driven orchestration, and dependency-averse infrastructure.

A browser-based manual flow computer in which the human operator replaces the stored program entirely. No instruction pointer, no fetch-decode-execute cycle, no automatic control flow. Data circulates in four circular loops. Every routing decision is made by the operator in real time. Implemented as a single HTML/JavaScript file. The inspiration and conceptual foundation for Loop MMT.

The four-step mandatory protocol when any individual loop encounters an error: (1) Do not crash — catch the error. (2) Alert the bus — emit LOOP_ERROR. (3) Preserve state — do not modify state after an error. (4) Continue operating — return to ready state for the next message.

A liveness indicator on every packet. L21 analog: the marker bit (bit 16) distinguishes live words from empty space. In MMT: marker: 'live' is real data, marker: 'empty' is a deliberate null ("I looked and there's nothing here"), marker: 'tombstone' is a deletion notice. Eliminates ambiguity between "query failed" and "genuinely no data." Pull requests must always return a marked packet, never silence.

One of 16 addressed storage locations in the L21 Memory Loop. Each holds one 17-bit word independently of loop circulation. The hardware analog of the Loop MMT Vault Loop.

A standard, reusable monitoring constellation that attaches to any Loop MMT application via passive bus observation. Renders live system state: bus traffic, loop health, dependency gate status, workflow execution timelines, and historical performance traces. The Observatory is a separate constellation — it subscribes to the target's buses in read-only mode and never emits to them. Because it is itself a Loop MMT constellation, building it uses the same methodology. It is both a monitoring tool and a portability proof for the standard.

In L21: the human who is the program — makes every routing and control-flow decision in real time. In MMT: the human developer directing the build process and, in production, the person using the application. The Workflow Loop is the software analog. Escalate returns control to the human operator when the system cannot decide.

A Signal Loop that monitors system health events and delivers alerts to the system operator (distinct from customer-facing notifications). Subscribes to DEPENDENCY_OFFLINE, WORKFLOW_ABORTED, repeated LOOP_ERROR, INTEGRITY_FAILURE, and other critical events. Delivers via the operator's preferred channel (SMS, email, push). For when the operator is not looking at the Observatory dashboard.

A durable staging table for outbound messages that ensures delivery even when the external channel is temporarily unavailable. Rather than calling an external service directly, a loop writes to the outbox first (same transaction as the local state change). A background process reads the outbox and attempts delivery, marking each entry as delivered on success or retrying on failure. Guarantees at-least-once delivery by making the message durable before any network call is made. L21 analog: the operator stages data in a bus before committing to routing it further — the intermediate stop allows inspection and retry. Pairs naturally with the Dead Letter pattern, which handles messages that exhaust all retries.

A structured data object that travels on the bus. Every packet has a type (determines routing), bus (which channel carries it), source (producing loop), timestamp, payload (the data, whose shape is defined by the packet contract), and hash (integrity verification).

The complete definition of every packet type in the constellation: field names, types, required vs. optional, value constraints. Defined once, enforced by the bus. The authoritative reference for what "valid data" means at every interface boundary.

A read-only subscriber on a bus that receives a copy of all traffic without being registered as a routing destination. Passive observers do not affect delivery, priority, or contract validation. The Observatory uses passive observation to see every packet on every bus without interfering with the application. Implemented via the bus.observe() method, distinct from bus.on() which subscribes to specific packet types as a routing destination.

A signal processing component in the L21 Big Loop. Compares circulating data against a 16-bit mask and match pattern. Words that match are ejected and routed via bus. Supports cascade mode (PM2 operates on PM1's output). The hardware analog of the Loop MMT Filter Loop.

A declaration in the Constellation Spec identifying which fields in which packet types contain personally identifiable information. PII fields are encrypted at rest, never logged in full in the audit trail (hashed or truncated), and excluded from health packets and Observatory telemetry. The declaration is part of the packet contract alongside field types and validation rules.

A test double on the bus. During integration testing, a Phantom replaces a real loop — subscribes to the same packet types, emits the same response shapes, but with controlled deterministic behavior. Test a Workflow pipeline by replacing the Vault with a Phantom that always succeeds, always fails, or fails on the Nth call. Wired through the initializer by swapping the factory — routing table and contracts don't change. The bus architecture's native testing mechanism.

A data structure that defines a multi-step workflow operation. Contains the trigger condition, the ordered list of steps, and each step's emit/expect types, timeout, failure strategy, dependencies on earlier steps, and compensation actions. The Workflow Loop engine is generic — it reads pipeline specs and executes them. Adding a new workflow means writing a new spec, not modifying the engine.

One of seven loop types. The UI. Both an input source (user actions feed the Working Loop) and an output destination (renders state changes from the bus). Does not contain business logic. Does not have database access. Receives bus and document as capabilities.

A Compute Loop that subscribes to change events from multiple Vaults and maintains a derived, denormalized view. L21 analog: the operator reads from multiple sources to form a complete picture. In MMT: when the Order Vault emits ORDER_UPDATED, the Projection Loop pulls related data and emits PROJECTION_UPDATED. The Presentation Loop subscribes to the projection, not the individual Vaults. Explicitly a derived cache, not a source of truth — rebuildable from Vaults at any time.

One of two bus communication modes. A loop requests a capability by type, not by target. The bus consults the routing table, determines which loop handles that request type, routes the request, and returns the response. The requesting loop is decoupled from the provider.

One of two bus communication modes. A loop places a typed message on a bus. Any loop subscribed to that message type receives it. The producer does not know or care who receives the message. For "something happened" events.

A declared maximum ingest rate enforced by the Working Loop — packets per second per operator and packets per second globally. Prevents runaway UI bugs, malicious actors, or misconfigured Clocks from overwhelming the bus. Declared in the Constellation Spec. Tunable without code changes. Exceeding the rate produces a RATE_LIMITED error.

Cascade filter order is a routing concern, not a filter concern. L21 analog: the operator can switch whether Pattern Matchers run before Threshold Gates. In MMT: want authorization before validation? Change the routing table. Want to insert a new step? Update the routing. The filters themselves don't change. Only the routing table does.

Re-emitting archived packets for debugging or reprocessing. L21 analog: the .loop session recording captures every action for replay. In MMT: the Transit Gate's archive buffer stores recent traffic. Extract a packet sequence by time range, replay through a specific loop in isolation, compare output against the original. "The price was wrong at 3pm" → pull the buffer, find the COMPUTE_PRICE packet, replay it. No guessing — the exact packets are in the buffer.

The Data Gate variant for Vaults. Governs the lifecycle of persisted data through three stages: Active (in the working set, returned by default queries), Archived (soft-removed from active view, still searchable on explicit request), and Purged (permanently deleted). Transition conditions are declared per data type in the Constellation Spec. A background sweep evaluates records against the declared policies and transitions them between stages. Every transition is logged to the audit trail. The Retention Gate is what makes "soft delete" a structural property of every Vault.

One of five failure strategies. Attempts the failed step again, up to a declared limit, with configurable backoff (linear or exponential). If all retries exhaust, falls through to a secondary strategy (onRetryExhausted) which defaults to Abort but can be set to Escalate or Compensate.

A data structure in the Constellation Spec that declares which operator roles can perform which actions. The Auth Gate enforces it. Roles (owner, operator, viewer) are mapped to permitted action types. Actions not listed for a role are rejected. The matrix is the structural enforcement of "who can do what" — enforced by infrastructure, not by hiding UI buttons.

The declaration of every legal data path in the constellation. Specifies, for each packet type: which bus carries it, which loop(s) can produce it, which loop(s) receive it, whether it's push or pull, and its priority level. If a path is not in the routing table, the bus will not carry it.

Transient working state held within a loop during a single transaction. L21 analog: four Working Scratch registers hold intermediate values without bus transfer cost. In MMT: running totals during reconciliation, intermediate values during price calculation. Never persisted, never on the bus, cleared when the transaction completes. A declared exception to the Two-Place Rule. If the loop crashes, scratch state is gone, and that's fine — it would be recomputed from inputs.

The mechanism by which Vault Loops handle database schema evolution. Each migration is a named, ordered, idempotent transformation with an up (apply) and down (revert) function. The Vault knows its current schema version and runs pending migrations automatically on startup before accepting bus traffic. If a migration fails, the Vault refuses to start. No manual database scripts — migration is part of the code.

The ability of a constellation to check its own structural integrity against its spec. Two levels: startup verification (before accepting traffic — checks that all loops are instantiated, all routes have subscribers, all contracts are loaded) and runtime verification (periodic checks on a Clock schedule — detects drift, dropped subscriptions, crashed loops). Failures emit INTEGRITY_FAILURE on the Data Bus. The constellation carries its own blueprint and can compare its running state against it at any moment.

A packet that carries routing refinement information in its payload. L21 analog: Memory address-read mode where a word's top four bits encode the destination slot — the data routes itself. In MMT: an ORDER_UPDATED packet carries a region field; the bus routes to the correct regional Vault without separate packet types per region. For multi-tenant or multi-region deployments where the routing table declares the general path and the payload refines it.

Anomaly detection over a sliding time window. L21 analog: the operator monitors running match counts on Pattern Matchers and counter values to detect unusual patterns over time. In MMT: a Filter Loop subscribes to the archive buffer or live traffic and applies pattern detection. Is the cancellation rate unusual? More than five errors in an hour? Emits ANOMALY_DETECTED on the Signal Bus. A watchdog, not a gatekeeper — does not block traffic. Built on the Counter pattern's configurable trigger infrastructure.

A point-in-time capture of a Vault's state, stored as a complete materialized record set rather than a transaction log. Used for two purposes: recovery (restore to a known-good state without replaying every event since creation) and reporting (generate reports from a stable, frozen dataset without locking live tables). Snapshots are written by a dedicated Compute Loop on a Clock schedule or on-demand trigger. They are read-only artifacts — never modified after creation. L21 analog: the session recording is a full replay log; a snapshot is the equivalent of saving a mid-run machine state to disk so it can be restored without replaying the entire log. Pairs naturally with the Event Ledger, where the ledger is the log and the snapshot is the materialized view at a given point in time.

One of the named buses. Carries outbound notifications, audit events, and external service calls. Isolated because external services are the most likely failure point. A Signal Bus failure does not affect the Data Bus or Vault Bus.

One of seven loop types. The notification and external output channel. SMS, email, print jobs, audit entries, webhook calls. Listens for events on the Signal Bus and acts on them. A Signal Loop's failure never blocks the core pipeline. Receives bus and services as capabilities.

The mechanism by which a Workflow Loop recovers from a crash. On restart, it queries the Vault Bus for any workflows with status in_progress, reads each transaction log, identifies the last completed step, and resumes from the next step. Named after the Loop 2.1 concept of recovering state from the last known snapshot.

Parallel step groups within Workflow pipeline specs. L21 analog: multiple buses transferring data simultaneously between different loops. In MMT: the Workflow Loop dispatches all branches in a group simultaneously, waits for completion, proceeds with merged results. merge: 'all' waits for every branch. merge: 'any' proceeds on first response. onBranchFail controls group-level failure handling. All declared in the pipeline spec.

A Filter Loop that matches a condition and adds metadata to the packet without removing it from the pipeline. L21 analog: Pattern Matcher rewrite mode annotates data bits in-place as it circulates. In MMT: stamps are additive — "this order is above average weight," "this customer is VIP tier." They do not modify existing fields. Compute Loops can branch on stamps. The Presentation Loop can render differently. The Audit Trail gets richer context. Distinct from Hydration (which pulls external data).

One of the named buses. Carries multi-device real-time updates from the persistence layer (e.g., Supabase subscriptions). High frequency, low criticality. If the Sync Bus lags, tablets show slightly stale data but core operations are unaffected.

A lightweight, selective observer. L21 analog: the operator observes a single bus's shift register display without affecting operation. In MMT: where passive observation sees all traffic on a bus, a Tap filters to a single packet type or source. Useful for targeted debugging: "show me only PRICE_CALCULATED packets." Attachable and detachable at runtime without modifying any loop or route. The Observatory UI can offer a "tap this type" interaction that creates a temporary Tap on demand.

A noted future extension from Standard v7. Data-layer tenant isolation for multi-tenant constellations. Logic-layer controls are already specified: the Auth Gate stamps packets with tenantId, scoped subscriptions filter delivery by tenant, and RBAC predicates enforce record-level access. What is not yet formalized is how tenant isolation is enforced at the storage layer — ensuring Tenant A's records are physically or logically separated from Tenant B's in the database. For Postgres-based constellations, the mechanisms are well-understood (Row Level Security policies, schema-per-tenant, separate databases). Because all database access is concentrated in Vault Loops, a formal tenant scoping pattern would affect exactly one loop type. Will be specified when a real multi-tenant project requires it.

A signal processing component in the L21 Big Loop. Compares circulating data against a numeric threshold using configurable comparison modes (≥, ≤, =). Words meeting the condition are ejected or clamped. The hardware analog, alongside the Pattern Matcher, of the Loop MMT Filter Loop.

A persistent record maintained by the Workflow Loop for every workflow execution. Captures: pipeline name, trigger, operator, start time, current step, status, and the result of every completed step. Persisted to a Vault through the Vault Bus after each step. The foundation of State Reincarnation — if the app crashes, the transaction log tells the Workflow Loop exactly where to resume.

The Data Gate variant for buses. Determines what happens to a packet after it has been delivered to all declared subscribers. Three policies: consume (destroy after delivery — the default), archive (retain a copy in a circular Archive Buffer before destroying), and hold (keep on the bus until the receiver explicitly acknowledges receipt — for guaranteed delivery across crashes). The policy is declared per packet type in the routing table.

The data-scrubbing half of a loop that adopts an external dependency speaking a foreign data model — a payment processor webhook format, a legacy SOAP API, an OIDC provider's token structure. The Translator receives raw external data, validates it against the external provider's schema, maps it to the internal packet contract, and emits clean packets indistinguishable from any other packet on the bus. The translation logic is isolated inside the loop's closure — no other loop knows or cares that the data originated externally. The Translator formalizes two distinct responsibilities that share the same loop: the Translator handles what happens when the external system responds; the Dependency Gate handles what happens when it is unreachable. Both should be declared in the Constellation Spec, making the data-scrubbing responsibility a design-time decision visible in the spec rather than an implementation detail discovered during coding. Added in Standard v7.

Data exists in exactly two places: on a bus (in transit) or in a Vault (persisted). There is no third place. The Presentation Loop holds a rendered projection, not the source of truth. Compute Loops hold no state between transactions. The software equivalent of Loop 2.1's principle that data is either circulating in a loop or stored in a memory slot — there is no hidden register.

The Pull mode implementation where the requesting loop names a capability (e.g., FETCH_ORDERS), not a target loop. The bus consults the routing table, determines which loop handles that request type, and routes accordingly. The requester is decoupled from the provider. Providers can be swapped by changing the routing table without modifying requesting code.

One of the named buses. Carries all persistence traffic — reads and writes to and from Vault Loops, and pull request/response cycles. Separated from the Data Bus so a slow database query does not block the core business pipeline.

One of seven loop types. The Memory Slot analog. The only loop type that receives a reference to the persistence layer. Narrow interface: store, retrieve, update, delete, confirm. No other loop can touch the database because no other loop has been given the database client. Receives bus and db as capabilities.

The Data Gate variant for workflow transaction logs. Defines retention policies based on workflow outcome: completed workflows get a shorter active period (default 30 days) then archive; aborted and escalated workflows get a longer active period (default 90 days) because they are more likely to need investigation; in-progress workflows are never gated — their transaction logs are sacred until the workflow completes, fails, or is manually aborted.

One of seven loop types. The software analog of the Loop 2.1 operator. Orchestrates multi-step operations by reading pipeline specs (data structures defining step sequences), dispatching each step through the bus, collecting intermediate results, handling failures using the five-strategy failure vocabulary, and persisting a transaction log for crash recovery. Does not compute, persist, validate, or render — it coordinates. Receives only bus as a capability.

In L21: the smallest circular storage loop (18 words). The staging area where data is injected into the machine via the inject channel. In MMT: the first of seven loop types. The entry point for all external input. Tags incoming data with metadata (type, source, timestamp) and places it on the bus. Does not process or store data. Receives only bus as a capability.