vitna.ai/docs/routing/console-composing Machine view
Raw .md llms.txt
> Source: https://vitna.ai/docs/routing/console-composing
> Raw Markdown: https://vitna.ai/docs/routing/console-composing.md
> Corpus index: https://vitna.ai/llms.txt

# Composing the register from the console

An owner of an org can enter a workload, put a sku in play, record a
measurement and arm a watch at `/console`, instead of running the
[commands](../cli/aperture/workloads.md) at a prompt on the box.

[Ruling](console-ruling.md) was the first thing the console could write and it
was half a product: you could answer a proposal and you could not enter the
workload a proposal would be about. This is the other half.

## The console does not validate

This is the rule the whole surface is built on, and it is worth being exact
about because it looks like an implementation detail and is not.

A form here is turned into the **argument vector the command would have taken**
and handed to the same functions `aperture:workload:add` calls. Every sentence
you see is produced by `platform/engine/register.mjs`, the module that refuses:

- an id that is not `org/slug`, or an org that does not exist
- an incumbent the registry does not carry, or one from another market
- a profile key the class does not spend
- a profile left empty on a workload that names an incumbent
- a metric the engine never reads
- a flag on a trigger kind that does not take it

None of those is checked in the browser. If it were, the register would have two
doors with two rules, and the refusals are the product.

It is why the fields are named after the flags (`unit-label`, `threshold-pct`,
`measured-at`) and why the profile, the constraints and the metrics are
textareas of `key=value` lines: that is what the flags already take, so nothing
had to be taught which keys exist.

## What it can write, and what it cannot

| Act | Written | Why |
|---|---|---|
| Enter a workload | Yes | A workload is a registry row |
| Correct one | Yes | Same, and only the fields you fill in are written |
| Put a sku in play | Yes | A candidate is a registry row |
| Record a measurement | Insert only | Evidence is the record. A correction is a better measurement, never an edit of the one somebody decided from |
| Arm a watch, call one off | Yes | Arming is a control on each sku of a register row; a disarmament keeps the reason on the row, dated |
| Start a rollout | Insert only | A [rule](rules.md) is registered in shadow, so it logs would-haves and routes nothing |
| Promote a rollout, or take one out | No | Letting a rule route needs an accepted decision citing its shadow readings, which is a ruling. The grant withholds UPDATE, so no page here can reach it |
| Register your own infrastructure | Yes | A [private sku](../cli/aperture/private.md) is a registry row, scoped to your org and published nowhere |
| Enter what it costs | Insert only | An entered rate is a record row. A correction is the better rate from the date it became true |
| Rule on a proposal | No | That is [ruling](console-ruling.md), a different role and a different page |
| Anything at all in `witness` | No | The market record is the collector's, and no console role writes it |
| Delete anything, anywhere | No | Append-only is enforced by grants, not by convention |

Fallback chains and the delivery target are not here yet. Each is a refusal
surface of its own and neither was on the path to a first signed policy, which
is what that release was for.

Lane rules were on that list until 2026-08-29 and are the exception now, for a
reason that is about the product rather than the schema: policies are signed and
runtimes execute them, so the ladder is the thing somebody actually wants on a
Tuesday, and a canary that needs a shell on the box is a canary most teams will
never start. Only the registering half moved. The two acts that change what a
rule does to live traffic stayed at a prompt.

## Arming a watch from the row the sku is on

Every other act here is reached from a form somebody opens having already
decided to perform it. A watch is not: what makes one worth arming is looking
at what a workload runs and what is in play against it, which is the register's
own board at `/console/workloads`.

So each sku on a row carries **Watch its price**, and it opens one form with one
question on it. The workload, the kind and the sku are already answered by the
row it was pressed on and travel as hidden fields; the six kinds of trigger and
the dimension a move is measured on stay on the workload's own page, for
somebody who came to arm something specific.

**There is no default threshold, and there must never be one.** A watch that
fires on a move you would not have acted on is one you learn to ignore, which is
worse than no watch at all, so how far a price has to move before it is worth an
interruption is your number. The field is empty when the page renders and it
carries no suggested figure, and leaving it blank is refused by
`--threshold-pct is required on a price move`, which is the command's own
sentence rather than one this page wrote. The bounds are the command's too: a
tenth of a percent fires on a rounding difference in a provider's own table, and
a hundred waits for a price to more than double.

A firing writes a **proposed** decision and stops. Nothing on this page, and
nothing a watch can reach, accepts anything.

## The eighth role

Composing writes as `vitna_register`, which is not `vitna_console` and not
`vitna_auth`. The reasoning is the one that made each of those separate: a bug
in the composing path must not be able to accept a proposal, and a bug in the
ruling path must not be able to invent a workload for one to be about.

`drizzle/0025` is the grant, widened once by `0030` for lane rules, and
`tests/console-register-scenario.test.mjs`
asserts it against a real Postgres, because "this role may compose the register
and may rule on nothing" is a statement about the database and only the database
can be asked whether it is true.

## It is an owner's act

A membership admits somebody to read an org's register. Entering what the
organisation runs, and what evidence stands behind it, is the act the register
exists for, so it is limited to owners on the same reasoning ruling is.

A workload of an org this account does not own is refused by the same sentence
as one that does not exist, because which of the two it was is information about
somebody else's register.

## What it still does not do

It routes no traffic and it runs no evaluation. Entering a workload records what
an organisation runs; running the engine against it and accepting what the
engine proposes are separate acts with separate grants. Vitna measures nothing:
a measurement here is one your own tooling produced, entered with the sample
size and the source reference the command already demands.
Human Machine Shift+M