Events
Write down the moments your product will report, in bulk, while you are still planning them. Agree the names once, in front of the people who will use them. Note the handler that will report each one and the message it ought to accompany, then watch the naming work move through planning, to do and production like any other work you track.
Events, close up
Where a name is argued
The named moment
Where the word turns up
What is travelling those lines
This is the same map as the one on the front of Solutions, zoomed into one surface. Nothing arrives here at runtime and nothing leaves on its own: the names travel because you or your agent carry them. That is the design, and it is why this workspace can never be in the way of your running product.
What it does
A module, a past-tense name, the dotted word your code will use, the kind of change it is, who it originates from, a status and a description. The shape of the record is what forces the argument to finish, because every one of those fields is a decision somebody was going to make later anyway.
Point a moment at the backend handlers on the hook for reporting it. Many to many in both directions, so one handler can owe several moments and one moment can come from several handlers. Both ends are checked as belonging to the same brand before a link is written.
Note the writing a moment should be accompanied by, from the moment or from the message. In three months, the answer to why this message exists is one click away instead of a conversation. It is an obligation on record, and the sending stays yours.
A small block describing what the moment should carry. The editor checks it parses as you type and stores it exactly as you wrote it, so the person writing the reporting code and the person consuming it settle the shape while it is still free. Nothing in the workspace reads inside it, and the page would rather say so than let you find out.
One pointer at the part of the product the moment is about. The registry carries the feature and the solution above it, each with its own status colour, so a name hanging off something you parked is visibly parked.
Filter by module, status, kind of change and origin. Sort on any column. Read the message count per row. The editor warns on unsaved work, shows you what changed before it saves, and needs a confirm to delete. Workspace search finds any of it by name, module or description.
A moment dragged onto a board is a reference to the real record, not a picture of it. The board re-reads the row every time it opens, so a name that moved from planning to production repaints itself, and last month's wall tells you what actually shipped.
A target date, a live date and an owner put the definitions you owe next sprint on the same calendar as your drafts and your messages, and into the morning briefing. Drag one to a new day and the date moves.
The life of one name
This is the whole surface, in order. Read it as a working week rather than as a diagram: it starts with people disagreeing about what to call something and ends with a word you can hold the shipped product against. Three of the steps stop at a person, and those are marked, because a step that quietly runs itself is a step you cannot trust.
Run the session on a whiteboard with your real records dropped on beside the fresh notes, so the argument runs against what already exists rather than against memory. The notes that survive become records in place.
The promotion is a small form a person fills in, one note at a time. A name born on a board still wants its module and its final wording set by hand afterwards.
Past tense, because you are naming something that has already happened rather than a button somebody pressed. A module, a readable name, and the dotted word your code will use. Names are unique inside a brand, so two brands in one workspace can both own a registration moment without colliding.
The handler on the hook for reporting it. The message it ought to be accompanied by. The shape of the data it should carry. All of it while the record is still in planning, which is the only stretch where every one of those is free to change for nothing.
Whoever writes the reporting code reads the agreed word and the agreed shape off the record instead of inventing both at the keyboard. Your agent can read the same rows out with a key you issued and create the matching tracked event in the tool you already measure with.
Nothing leaves this workspace on its own. Names travel because you or your agent carry them, which is also why nothing here can break your product.
A record starts in planning and stays there. No schedule, no scan and no automatic promotion moves it. You move it on from the registry, from the product tree, from the calendar panel or through an agent call.
That is deliberate. A status nothing can fake is a status you can hold the shipped product against.
Filter to one module. Look for the definitions still sitting in planning past their date, the ones with no handler attached, and the ones whose part of the product has been deprecated underneath them. A moment nobody owns is the exact thing the session was supposed to prevent.
Nothing in that sequence runs on a schedule, and nothing in it reacts to your product. Every arrow is a person or an agent you pointed at it.
One moment, part by part
A registration moment, filled in. The values are an example. The note under each part is not: it says what that field earns you, and where a field is an agreement between people rather than something the product acts on, it says that too.
The part of the product this belongs to, in your own word. The registry filters, sorts and counts by it, which is what keeps a long vocabulary readable.
Past tense, always. You are writing down something that happened, not an action somebody takes. The whole practice rests on that one habit.
The agreed string. Settled here, in front of everyone, so nobody invents a second name for the same moment three files away.
Create, read, update or delete. It sorts a growing vocabulary into a shape people can scan, and the registry filters on it.
A person, a visitor, the system or an administrator. Who or what the moment came from, which is usually the first thing an argument about naming turns on.
The agreement about the shape, written while it is still cheap. The editor checks it parses as you type and stores it exactly as you wrote it. Nothing in the workspace reads inside it. The workspace will tell you how many of your definitions still have this blank, and that is the whole of its involvement.
The handler on the hook for reporting it. Many to many in both directions, and both sides are checked as belonging to the same brand before a link is written.
The writing this moment ought to be accompanied by, noted from either end. It is an obligation recorded next to the name so the writing gets prioritised early. It is not a send, and nothing in the workspace treats it as one.
One pointer into the product tree. The registry carries the feature and the solution above it with each of their statuses, so a moment attached to a shelved part of the product reads as shelved at a glance.
Where the naming work itself has got to, in the same words the rest of the workspace uses, including the honest ones: icebox, idle, deprecated.
Optional, and worth filling in. The naming work then shows up on the shared calendar next to your drafts and your messages, and in the morning briefing as something due.
Every field above is written by a person or by an agent carrying your key. There is no field anywhere on this record, and no other table behind it, that stores a moment having happened.
Where this sits
A named moment is the middle of a sentence that starts in the product and ends in something you send or something you measure. Each of the places it touches has a page you can read.
The tree a moment reports into, and the handlers on the hook for reporting it. Open a handler and it lists every moment it owes, with the messages each of those owes nested inside, which is the closest thing here to reading the chain in one place.
Read Product recordsWhere the names get argued. Notes that survive become records in place, and they stay on the board as live nodes that repaint their current status, so the session ends with a vocabulary rather than a photograph.
Read WhiteboardsThe writing a moment ought to accompany, noted from either end so it reads the same from both. Written down early means it gets prioritised and designed ahead of the code, and the sending path stays the one you already run.
Read EmailLists, reads, creates and updates definitions and wires both links in the same call, under your permissions and your brand limits. It also reads the agreed words back out, which is how they reach the tool you measure with.
Read Your agentThe naming work is work. Attach a task, a note or a decision to a moment so the argument about the wording is filed next to the wording, with an owner and a date on it.
Read Tasks and notesYours to keep
Every one of these we would choose again.
There is no counter, no place a reading arrives, and no record anywhere of a moment having happened. This surface holds the plan and the vocabulary. It is deliberately not in the path of your running product, and it cannot slow it down or break it.
The tool you measure with and the path you send on stay exactly as they are. m18t holds the names, the plan, the priority and the status, and hands the agreed word to both. Nothing is replaced and nothing is intercepted.
A name is unique inside a brand, never across them, so two brands in one workspace can each own a registration moment and mean different things. A moment belonging to every brand at once is refused outright.
Nothing advances a definition on your behalf. That is what makes the registry worth checking the shipped product against, rather than another board that drifts.
Your agent can work these records all day. There is no delete for it to call, and a name that collides comes back as a refusal instead of a quiet near-duplicate with a number on the end.
The message link and the data shape are agreements between people, and this page says so in as many words. You will not discover in month three that a line of copy was doing work the code never did.
Questions
Keep reading
The tree these names report into, and the handlers that will report them.
Where the argument happens, and where the wall survives it.
The writing each moment ought to be accompanied by.
The naming work itself, filed as work with an owner and a date.
Open the workspace, do one real piece of work in it, and the joins will show you the rest.