Special elements: what a project declares, and when its names freeze¶
Audience: quality managers setting a project up; authors who wonder where a suggested key comes from.
Every trace item — a requirement, a risk, a risk control, a user need, a validation case, a design
element, a regulatory reference — carries a key: the stable identifier that links point at, that
coverage views count, and that printed PDFs and audit packs cite (see
trace items §1). The convention that shapes those keys is a prefix such as REQ-,
STK-, RISK-, RC-, UN-, VAL-, DE-, GSPR-.
0. The catalog, and what a project decides about it¶
The product ships a catalog of element kinds — eight of them today. A kind is not a name the project invents: it is a thing the system knows the meaning of. It knows that a risk control mitigates a risk, that a user need is satisfied through a system requirement, that a validation case validates a need — which is exactly why it can derive a traceability matrix, flag a gap, and print a chain nobody maintained by hand.
What a project decides is three things, and they are decided together on one row of the setup wizard's Special elements section:
- Whether it uses the kind at all. Declaring a kind is what reserves its key prefix and what makes it offerable to document types. A project that traces no risks simply does not declare them.
- What it calls the kind. Naming conventions differ between organisations, so the catalog's name (Risk control) is a starting point, not a vocabulary imposed on your people. The system keeps its own internal identity for the kind — renaming never changes what a risk means or which matrix it appears in.
- Which document types may define it. Only a type that carries this right can mint items of the kind, and the selection sits on the same row as the name and the prefix — because a prefix for a kind no document may write is a convention for nothing.
Some kinds need others. A risk control exists to reduce a risk, so the two come as a pair: turn either on and the other comes with it, turn either off and both go. A validation case needs a user need, which needs a system requirement; a stakeholder requirement needs one too, since a stakeholder requirement is resolved by being satisfied by one. Declaring one therefore declares what it depends on, and the section says so on the row it just switched on rather than growing quietly. What you write stays free: a risk accepted without reduction needs no control item at all — it is the declaration that must be coherent, not the content.
(Custom, project-local kinds — an assumptions register, a SOUP inventory — are a planned later step. They will be keyed and citable but deliberately outside derived traceability, and marked as such. Today the catalog is the whole vocabulary.)
1. What a key prefix actually does¶
It feeds the Suggest button in the authoring dialog. With a REQ- rule in the project, suggesting
a requirement key yields REQ-001, REQ-002, and so on — the numbered part is appended by the
suggestion, the prefix is the literal head.
Two honest limits:
- A rule is a convention, not a validator. It shapes what is suggested; it does not reject a key an author types by hand. The value of setting one at birth is that the project's keyspace is shaped by a decision instead of by whatever the first author happened to type.
- Keys are one keyspace per project, and the prefix only scopes the convention per kind. Setting a requirement prefix never touches the risk prefixes. One kind may nevertheless carry several conventions side by side — see §1a.
1a. When one kind is written in several conventions: key categories¶
Real corpora are not written in one convention. A stakeholder-requirement corpus may be split into
sections that each number themselves — general requirements as GA-, must-requirements as MA-,
usage requirements as NA-, target-price requirements as ZP-. They are all stakeholder
requirements: one kind, one chain, one matrix. What differs is the section, and the counter.
A kind therefore carries key categories. A category is a name plus its own prefix, and each has
its own counter: Suggest under MA- proposes the next free MA- number, which is the whole point —
otherwise the next free number in each section is something a person has to track by hand, in their
head or in a spreadsheet beside the tool.
Three things are worth knowing about them:
- The kind's own prefix is its first category. A project that configures nothing has exactly one, behaves exactly as it always did, and sees no picker anywhere. Categories are something you add when your corpus needs them, never something the tool imposes.
- An item's category is derived from its key, never stored. The category is simply the configured
prefix that matches the key most specifically (so with both
G-andGA-configured,GA-08is aGA-). Nothing is written on the item and nothing has to be maintained — which is why adding a category groups items that already exist: an imported corpus of 72 stakeholder requirements is sorted into its four sections the moment the four categories are configured, without touching one byte of content. A key that matches no category belongs to the kind's own. - Where you see them. The authoring dialog's Suggest offers a category picker once a kind has more than one, and the requirements registry gains a category column and filter. Both appear only where there is a choice to make.
Categories freeze individually, by the same rule as §2: a category whose prefix is in use can be renamed or removed only as a stated, audited exception, while its unused siblings stay freely editable. Adding one is always free — including when it immediately matches existing keys, which is not a change to anything but a name for what was already there.
The project's setup check reports the three ways this can be left half-done, each in its own words:
- a document type may define a kind the project has not declared — so the kind has no name and no prefix of its own, and key suggestions fall back to the built-in one;
- a kind is declared but no type may define it — its prefix is reserved and no item of it can ever be written;
- a kind is in use while something it depends on is not. Here the check is deliberately asymmetric, because reality is: risk controls without risks is loud ("nothing can ever be mitigated"), while risks without controls is only a note — accepting a risk without reducing it is a legitimate posture, and the note exists so an auditor asking "how was this reduced?" gets an answer rather than a silence.
2. Free while unused, frozen at first use — name and prefix together¶
This is the governance, in two sentences:
- Free. As long as no item of that kind carries a key in this project, its name and its prefix can be set or changed freely.
- Frozen. Once the first key of that kind exists here, both are refused — the message names the project, the kind, how many items already carry keys, and the invariant behind the refusal: existing keys are never renamed.
One rule, one freeze. The display name freezes with the prefix and for the same reason: a released document's vocabulary must not be renamed underneath the records that cite it. In the wizard a frozen kind shows both values read-only, with the count as the reason and one door out of it (§5). A kind's key categories (§1a) freeze the same way, one at a time, counted by the keys under each prefix.
The refusal is enforced at the act, not merely hidden on a screen. And the count is per kind: your project's risks do not freeze its requirement prefix.
Re-writing the same values (same name, same prefix, same note) is a no-op — nothing changes, nothing is written, nothing is audited. That is what makes re-running the setup wizard against a mature project safe: it does not trip the freeze on what it declared itself.
Why the freeze exists¶
A key is cited identity. It appears in trace links, in coverage views, in audit packs, in exported
PDFs — documents that have left the system and cannot be updated. Renaming existing keys is therefore
never on the table, which means a rule change under minted keys would bifurcate the project's
naming: half SSRS_API_, half REQ-, with nothing recording why. Freezing is the cheaper answer.
3. What a valid prefix looks like¶
Checked at the act, each with its own message:
- not blank, and at most 40 characters;
- no spaces — it is the literal head of every generated key;
- must not end in a digit — the suggestion splits a key into "head + trailing number", so a
trailing digit would be swallowed into the counter. Digits inside a prefix are fine (
ISO13485-).
4. Where this is decided today¶
- At project birth, by the setup wizard's Special elements section. Every kind the product knows is listed there — the ones your lane proposes already ticked, the others waiting — each with its name, its prefix and the document types that may define it. Declaring them happens in the same run that activates types and roles, so day-one projects never touch this afterwards. The QMS / process lane declares none, deliberately — a process scope documents the organisation, it does not trace a product (see the wizard's lanes).
- Through the governed provisioning surface, by a caller holding the installation-shaping permission (see the birth path). The act is audited, and so is every prerequisite it pulls in with it.
- By the seed or an import, when a project is stood up that way.
There is no element editor in scope configuration today. The project configuration reads the declarations but does not write them, which is why the setup check's fix link for an undeclared kind points at the Document types tab (where the may-define right lives) and the one for an unmet dependency points back at the setup wizard. Getting the declarations right at birth is therefore worth a minute of attention.
Two authorities, not one. Declaring a kind and naming it is an installation-shaping act; saying which of this project's document types may define it is project governance. A quality manager who holds the second but not the first still edits the defining types on the same row — the name and the prefix are simply shown rather than editable, beside a note saying whose act that is.
5. Past the freeze: the deliberate, audited exception¶
A frozen kind refuses an ordinary change, and the refusal itself tells you the way past it: the change can be made as a deliberate exception, by stating why. In the wizard the frozen row offers "Change them anyway…", which only unlocks the fields — the exception itself is decided where the refusal appears, on the apply step, and it needs a written reason; a blank reason is no reason and keeps the refusal. The act is recorded distinctly in the audit trail — old and new prefixes, your reason verbatim, and how many items already carried keys when you did it — so the rare act is findable, never silent.
The consequence is exactly what the confirmation states: existing keys keep their names, forever
(they are cited identity — trace links, audit packs, printed PDFs); only future suggestions follow the
new rule. A project that minted REQ-001…004 and switches to SSRS_ will suggest SSRS_001 next while
the old keys stand — one keyspace, two eras, which is precisely why the freeze asks you to say why.
One stated reason covers the whole act, including any prerequisite kind it pulls in with it.
6. Choosing prefixes: the house default¶
Because of §2, the prefixes are effectively a once-per-project decision, and the moment to make it is before the first document defines an item — not when someone notices the keys look wrong.
The house default is simply the catalog's own prefixes, which the lane presets propose unchanged; a project not born through the wizard should copy them rather than invent its own:
| Item kind | Prefix |
|---|---|
| Stakeholder requirement | STK- |
| System requirement | REQ- |
| Design element | DE- |
| Risk | RISK- |
| Risk control | RC- |
| User need | UN- |
| Validation case | VAL- |
| Regulatory reference | GSPR- |
The supplier lane declares four of them (system requirement, design element and the risk pair) — it verifies against requirements it is handed, so it declares no stakeholder level; the manufacturer lane declares all eight; the QMS / process lane declares none (§4).
Three rules of thumb behind them, for the kinds a lane does not cover:
- Short and uppercase, with a trailing dash. The prefix is the literal head of every generated key and it appears in trace links, coverage tables and printed PDFs; three to five characters read well in all of them. (It must not end in a digit — §3.)
- Stable, because it is permanent. Assume you will never change it, because today you cannot.
- Never encode something you might reorganize. No team names, no year, no product line, no department, no phase. Those change; keys do not, and a key that outlives the thing it names is worse than a plain one. The prefix says what kind of item this is and nothing else.
Governing decisions: ADR-0112 (the element-kind catalog — kinds, their dependencies and the per-project declaration that carries the name beside the prefix), ADR-0095 (the governance — free until first use, then frozen; existing keys are never renamed), ADR-0077 §4 (scope-configured key conventions and the key suggestion), ADR-0079 (risk items and their keys), ADR-0097 (the governed write path, and its audit).