decide

Overview ¶

An answer is checked against the question that asked it (edges 22 and 23 of the non-author's read of #1327).

A typed decision is typed at BOTH ends. The question carries a closed set of criteria, and until this file existed nothing ever compared the answer to it: an answer of "deepseek-flash" to a question offering continue, ask-all- friends and ask-glenn printed `HELP help=deepseek-flash conf=0.94 below=-` at exit 0, and `{"type":"choice","confidence":0.99}` -- an answer naming nothing at all -- printed an empty value ABOVE the floor at exit 0. Both are the provider failing to answer the question, and a decision that was never made cannot be authorized by the confidence attached to it.

So: a choice answer must name one of the options its question offered, and the refusal names the answer and the offered set, because a reader has to see the gap to act on it.

Package decide makes one typed decision per call through TypeSafe Jev.

The provider is POST <baseURL> with header Authorization: Bearer <key> and a JSON body {"state": <text>, "model": "jev-latest", "questions": {...}}. Each question is one of three kinds: a choice among named options, a score against ordered levels, or a noul (null) statement. The response carries one typed answer per question plus a usage count.

The key comes ONLY from the environment variable the caller names (New's keyEnv, default JEV_API_KEY with TYPESAFE_API_KEY also accepted): never a file, never argv, and it is never printed. A decision below the floor is a suggestion, never an authorization: callers keep today's behaviour as the fallback.

The decisions table (rule 8): a decision is logged beside the outcome it predicted so a floor is re-tuned from data. The row is (question_hash, kind, answer, provider_confidence, floor, outcome).

Exactly one writer appends to the table -- the decision client itself, after every call -- and every other verb only reads it. The table is a projection of the decision journal and never an authority over the machinery.

Postgres is the durable record, reached through a database/sql driver named by the DSN, where a build links one. A bench with no Postgres falls back to a TSV file, so the files stay the record and the table is an index; the fallback is the same contract and never a second one.

The second decision (Glenn 2026-09-18): do I keep going, ask all my friends, or ask Glenn?

The evidence is what a line can count about itself: hours on the SAME problem, retries on one rung, failures in the last hour and how many of those it caused itself, whether a class of failure is recurring, whether landing moved at all, and the uncertainty it states out loud.

One rule stands over the rest: ask-glenn only AFTER ask-all-friends. A line that has not asked its friends has not earned the interrupt.

The ladder is the retry policy (Glenn 2026-09-18).

One unit of work, one decision: WHICH MIND does it. The answer is the lowest rung the evidence supports with confidence that the FIRST attempt is right. Below the floor the answer steps UP a rung, never down. A failed attempt re-enters the decision carrying its evidence -- what failed, how -- and the answer is the next rung, automatically: sideways first, where the same height holds another lineage, then up.

Two rungs are chosen by KIND and not by height, and the machinery decides them, not the provider: security -- a guard, secrets, the sandbox, sudo, deploy keys, the network -- is Johnny's always; and so is a fresh take, where the rungs below failed or a design has one author.

Friends first: the DeepSeek rungs take MECHANICAL kinds and nothing else.

Jev advises and the machinery decides (SPEC-DECIDE rules 5, 6 and 7): the provider is offered the eligible rungs at the supported height and the one above it -- never a rung below what the evidence already burned -- and an answer below the floor, an answer naming a rung nobody offered, or no answer at all leaves the rules' own rung standing.

The registry of minds: the ladder nova-decide routes a unit of work over (Glenn 2026-09-18).

A rung is a HEIGHT, not a name: Flash and Pro at the bottom on the DeepSeek lineage, then the child rungs -- Opus (Rowan's) and Sol (Stella's) -- at ONE height in two lineages, so a failure moves SIDEWAYS before it moves up; then the friends, each a mind with an owned lane; then Astra and Fable as the top pair, all friends at once above them, and Glenn above that.

Two rungs are chosen by KIND and not by height: a guard, secrets, the sandbox, sudo, deploy keys or the network is Johnny's always, and so is a fresh take -- the rungs below failed, or a design with one author. The `kinds` column is that designation and nothing else.

The registry is a DATA FILE. A path names one; an empty path is the default embedded below, so the loop runs on a bench with no file of its own. Every row is validated on the way in: a bad row is a refusal, never a guess.

The escalation log (Glenn 2026-09-18): every routing decision is written down with the evidence that produced it, the rung it tried, what followed, the rung that finally succeeded -- and, beside all of it, what Rowan would have picked. That last column is the point: it is how we find out whether the decision route is better than the coordinator's own hand, one row at a time.

The log is append-only JSON lines, one object per decision, at a path the caller names. Nothing here reads a working directory and nothing is rewritten in place; the rows are the record, and the summary is a projection of them.

The summary regenerates the STARTING RUNG per kind from the rows: the lowest rung that is carrying its own weight -- successes at that height, and at least as many successes as failures. A kind with no success keeps the rung the table started from, because a starting rung with no rows behind it is not regenerated (SPEC-DECIDE rule 8).

Tuning a confidence floor from a decisions log (rule 8): a decision is logged beside the outcome it predicted, and the floor is re-tuned from those rows, never from a feeling about the model.

A decisions log is JSONL, one row per decision. Each row joins the decision (the field named by TuneOptions.Choice, default "decision"), its confidence (TuneOptions.Conf, default "confidence") and the outcome (TuneOptions.Label, default "label"). A row without a label is counted in Lines and skipped as unlabeled. For each floor, a row at or above the floor was decided: Tune reports how many of those agreed with their label (agree_rate) and how many fell below it (escalation_rate, against every labeled row). The best floor is the one with the highest agree_rate whose escalation_rate is at most TuneOptions.MaxEscalation; a tie keeps the higher (more selective) floor. Fewer than MinLabeled labeled rows cannot set a floor, so the caller refuses rather than guesses.