vitna.ai/docs/cli/aperture/decide Machine view
Raw .md llms.txt
> Source: https://vitna.ai/docs/cli/aperture/decide
> Raw Markdown: https://vitna.ai/docs/cli/aperture/decide.md
> Corpus index: https://vitna.ai/llms.txt

# Deciding

Running the engine, and ruling on what it proposes.

```bash
npm run aperture:decide -- --workload <id> --candidate <sku>
npm run aperture:accept -- <decision-id>
npm run aperture:reject -- <decision-id> --reason "..."
```

## Deciding writes a proposal and nothing else

`aperture:decide` runs against the live tape and the recorded evidence, prints
the brief, and writes a **proposed** decision.

Nothing is accepted and nothing is routed. A fired trigger is a question put to
a person, and this is the command that formulates the question.

## The engine is pure

`decide.mjs`, `brief.mjs` and `triggers.mjs` import nothing and read no clock, so
the Decision Lab on the site, this command, and the collector all run the same
code against the same inputs.

A brief you read on the site is the brief the CLI would print.

## Accepting

`aperture:accept` accepts a proposal and arms the next review, superseding the
decision it was taken against.

> [!WARNING]
> Accepting is refused if the record moved under the proposal. A brief argued
> against a tape that has since changed is a stale argument, and accepting one
> would put a decision into force on reasoning that no longer holds.

Accepting does **not** move the workload's incumbent, because whether traffic
actually moved is not something Vitna can see from here. That gap is what
[usage attribution](../../routing/usage-import.md) closes.

## Rejecting

Takes a reason, kept on the row. No acceptance is written.

A refused proposal stays in the register with why it was refused, so the next
person to ask the same question can see that it was already asked.

Refusing also puts back the watch that produced the proposal. A firing spends
its watch, so without that a refusal would quietly end the watching: a workload
watched for a price move that refused the resulting proposal would stop being
watched for price moves. Only the watch that fired comes back, because the ones
armed beside it never fired and are still armed. A review date comes back on a
new date rather than the one that has passed, which would otherwise fire again
on the next collector pass. The command prints what it re-armed, or that there
was nothing to put back when the proposal came from a hand-run rather than a
firing.

## Ruling from /console

An owner of the org can accept or refuse a proposal on
[/console](../../routing/console-ruling.md) instead of at a prompt. Both surfaces
rule on the same record through the same refusals, in
`platform/engine/ruling.mjs`, so a proposal the record moved under is refused
identically either way.

The console arms the defaults and offers no flags. `--review-on` and
`--price-move-pct` stay here, because a threshold typed into a web form without
the tape in front of you is a number chosen to fill a field.

A ruling made at this prompt records `ruled_at` and leaves `ruled_by` null,
because its attribution is who has shell access on the box rather than a signed
in account. Both are set for a ruling made at /console.

## Inputs are published

Every decision names the exact price period and evidence ids the run read, all
append-only, so a brief can be regenerated and checked at any distance. See
[`/api/v1/proposals`](../../api/v1/engine/proposals.md).
Human Machine Shift+M