Repository navigation
feat(settings): give the Decisions card a list-and-detail shape - #12598
Conversation
Design Review (Fable 5) — 🟡 CONCERNSDesign-level review of Design-Verdict: CONCERNS Description and screenshots lag HEAD's final commit: the stated WatchThe final commit ( [DESIGN-REVIEWED] c0448ca |
Opus 4.8 Review — ✅ no blocking findingsReviewed Review detailsThe candidate list is empty (discovery found nothing). I focused my independent pass on the most security-relevant new logic — the scope-only consent write, the No findings. [OPUS-REVIEWED] c181a6a Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
First Principles Review (Fable 5) — 🟡 CONCERNSPremise-level review of First-Principles-Verdict: CONCERNS The description describes an older build — four points, one scope, a Not justified as shipped
What this change shipsInventory (10 items) — 8 justifiedIntent: Reshape the Settings Decisions (Jev) card into a gateway-fed list-and-detail with per-point settings — ADDITION (carries the #11997 fix inside it).
More than 10 exist: the screenshot-harness rewrite, compaction copy rewording, and 25 i18n keys ride within the items above. [FIRST-PRINCIPLES-REVIEWED] c181a6a |
UX Review (Fable 5) — ✅ human override accepted@iamwhatever overrode this lane for |
GPT 5.6 Review — 🔴 changes requested (blocking)GPT 5.6 found at least one blocking issue that must be resolved before merging This comment is updated in place on each push. BLOCKING -- website/src/pages/settings/DecisionsCard.tsx:668 -- Concurrent ceiling saves can restore wider egress FINDING -- website/src/components/commandPalette/settingsManual.ts:52 -- Activating a scope-search result leaves the first decision point selected, so the requested switch never mounts or highlights -> Fix: map each highlight ID to its decision point when deriving FINDING -- website/src/pages/settings/DecisionsCard.tsx:533 -- [GPT-REVIEWED] c0448ca Adjudication (Opus 4.8) — is blocking on each finding proportionate?The adjudicable block is empty. Below is the fenced ruling. F1 — The False positive or not applicable? A repository writer can comment: |
c650e96 to
c1ce2b5
Compare
|
[operator: iamwhatever] Screenshot evidence for
|
c1ce2b5 to
297dd2d
Compare
|
[operator: iamwhatever] Re-captured for The previous UX round read the description before the screenshot update landed, so its evidence gaps describe the first commit's frames. Every state it named is here, and the one it asked for by name —
|
|
[operator: iamwhatever] Disposition for Fixed in code
Two notes on those. The status word ships as Switched on, not Bundle Size Gate — attributed on the base ref
The previous UX BLOCK was stale evidenceThat verdict read the description before the screenshot update landed — hence "all nine screenshots show Running", which is the first commit's set. Every state it named was already captured. All four are in the re-capture above, and the one it asked for by name ( Answered, not changedFirst Principles item 4 — the bucket slider reverses the base's "no control on purpose". Correct reading of the base, and the slider is a requested item in this card's brief. Item 6 — the API-key field duplicates Item 8b — Item 10 — the tool-args switch left settings search. Declared in the description rather than left to be found. Its label became a per-scope map lookup when it moved into UX Watch — give the endpoint-moved state its own chip word. The rows read UX Watch — UX suggestion — render the Not mine
I am not posting an |
297dd2d to
8675691
Compare
|
[operator: iamwhatever] Re-captured for The list is five rows now.
|
66101cf to
99ce5a0
Compare
bolichen97
left a comment
There was a problem hiding this comment.
Approved after a live re-verification: readiness: passed label, PR Readiness status success on this head, no required check pending/failed/cancelled, mergeable, no effective CHANGES_REQUESTED, and no unresolved human blocking request found in comments or review threads. Native auto-merge (squash) enabled; no admin override used.
|
/ai-review override ux 7739111a3ca0bc7d5b90d28d3bd7bd9c60f74a6e: Re-posting the override that lapsed on this rebase -- the head carries no code change from the one I cleared, the lane's block was an evidence gap rather than a defect, every behavioural finding it raised on this card has been fixed, and its remaining Watch items are carried on #12640. |
|
AI-review override not recorded: |
GPT 5.6 Review —
|
|
/ai-review override ux 2660621: Re-posting the override that lapsed on this push -- the head adds a rebase, test moves and a capture-script cut, no change to the behaviour I cleared; the lane's block was an evidence gap rather than a defect, every behavioural finding it raised on this card is fixed in code, and its remaining Watch items are carried on #12640. |
Human judgment recorded@iamwhatever marked the ux AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
Human judgment recorded, but the following reviewer lane(s) could not be re-run automatically: UX Review. Re-run the lane's latest workflow run for |
|
/ai-review override ux 5e531a3: Re-posting the override that lapses on each push -- this head adds only the audit-verb fix, the feature-map rows, one folded error path, a ratchet scope widening and two copy fixes; the lane's original block was an evidence gap rather than a defect, every behavioural finding on this card is fixed in code, and its remaining Watch items are carried on #12640. |
Human judgment recorded@iamwhatever marked the ux AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
Human judgment recorded, but the following reviewer lane(s) could not be re-run automatically: UX Review. Re-run the lane's latest workflow run for |
|
/ai-review override ux abb866a: Re-posting the override that lapses on each push -- this head restores the pre-consent share statement and the three scope search entries, deletes a one-entry registry and makes the button census real; no behaviour I cleared has changed, the lane's block was an evidence gap, and its Watch items are carried on #12640. |
Human judgment recorded@iamwhatever marked the ux AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
|
Human judgment recorded, but the following reviewer lane(s) could not be re-run automatically: UX Review. Re-run the lane's latest workflow run for |
The Decisions (Jev) card was one wall of text with a single switch. It is now
the same list-and-detail shape the ACP backend tab uses: one row per decision
point the GATEWAY projects, a panel per row carrying that point's own settings,
and one collapsed block above for what the whole seam shares.
Rows come from the backend, not from a list written into the frontend. The
consent GET projects `decisions/gate.py`'s own points as `id` / `needs_scope` /
`status` / `config_keys`, so a point this build adds draws a row with no
dashboard edit, and a gateway that projects none says so rather than claiming
points it may not have. `compaction.keep` is the proof: it arrives with its row,
its status and its consent switch without a per-point branch anywhere.
`gate.POINT_SCOPE_KEYS` is the one map both sides read -- the scope enforcement
table and the card's rows are two projections of the same two sets, so neither
can learn about a scope the other does not, and every point's row reports ITS
OWN scope rather than whichever one the reader happens to have granted.
Every control the card offers writes a path its route accepts:
* the three `model.route` tier pickers write `decisions.model_route.<tier>`,
registered in `_EDITABLE_CONFIG` from the point's own tier tuple so the gate
and the answer domain cannot drift, and validated exactly as the
`agent.role_models.*` pins beside them are. Options come from the advertised
model list; INHERIT is the default and no model id is named in code.
* the prior-conversation number box writes the KEYSTONE ceiling through
`PUT /api/decisions/consent`. What it bounds is how much conversation leaves
the machine, so it is consent, and consent does not live in an agent-writable
file: `config.json` carries what the seam asks for and the ceiling clamps it.
It takes the whole typed string or nothing -- a prefix parse would save 6 for
a typed "6,000", on the one value that decides how much conversation leaves.
* the address is SHOWN and its config path named, never edited.
`PATCH /api/config/kirocrew` excludes `decisions.provider.*` on purpose -- a
dashboard caller must not choose where collected state is sent, and `api_key`
is schema-sensitive -- so a field there would be one whose every save fails.
* the API key goes to the secrets vault as `TYPESAFE_API_KEY`. The vault hands
no value back, so the field shows set or unset.
* the sampling slider commits once, on release. A write per drag tick is a
config write per pixel, and the thumb reading the saved share mid-drag is what
made it snap back to where the drag started.
A scope-only PUT may omit `enabled`, and the writer re-checks the recorded
endpoint against the endpoint in force under `_SAVE_LOCK`: a re-bind landing
between the handler's check and the write would otherwise carry a wider egress
scope onto an address nobody reviewed. It raises
`ConsentEndpointMovedError`, which the handler answers with the same 409 the
pre-lock checks use, and nothing is written. A scope write audits as `scoped`.
A scope write against a REVOKED record stays allowed and stores no scope, which
is the contract the route already had.
The card is SPLIT out of the app core. It is the largest surface in Settings >
Developer and a reader who never opens that tab should not pay for it, so
`FeaturePreviewsSection` mounts it behind `lazy()`; `fallback={null}` because a
card that renders nothing under a governance pin can render nothing for the
moment its chunk is in flight. The App chunk lands at 3528.8 KB against main's
own 3538 KB ceiling -- BELOW the 3531.4 KB main alone builds -- so this branch
changes no budget.
Also: the save-error notice drops its agent hand-off, because navigating away
is exactly what would discard an unsaved API-key draft; a `needs_scope` row's
panel names the switch below it as the OK the chip asked for; the main switch is
held while any scope write is in flight, since both land on one keystone; the
status word says the switch state rather than activity; and the list track takes
what the longest point name needs.
The harness compares the endpoint as a URL, not as a substring. A
`text.includes('https://api.typesafe.ai/v1/systemone')` check is satisfied by
`https://api.typesafe.ai/v1/systemone.evil.test/x` and by an unrelated host
carrying that text in a query, so the assertion written to catch a card showing
an address nobody consented to would have passed for exactly that
(`js/incomplete-url-substring-sanitization`). It now reads the card's mono values,
parses each, and requires one whose ORIGIN and PATHNAME both equal the expected
endpoint's -- element text rather than a slice of the card's, because
`textContent` over a subtree concatenates without separators and would glue the
address to the sentence after it.
Two locale-style rules on strings this branch adds: the Korean placeholder 조사 is
written in both forms (`{{productName}}이(가)`), since the right particle depends
on a final consonant the placeholder does not have until render, and the zh-CN
ceiling sentence is rewritten to stay inside the two-的 limit.
Every URL comparison against the endpoint is exact, not just the one an alert
named: `getByText(string)` matches a SUBSTRING too, so the moved-address frame and
its jsdom twin had the same defect as the `includes` call, and an element reading
`.../systemone.evil.test/x` satisfied both. They compare parsed origin and pathname
now, and the frame anchors on exact text.
The whole-transcript switch's absence test opens that point's panel before
asserting. One panel renders at a time, so "the switch is not on screen" was true
of every unselected point and the test passed on a card that offered the switch
with consent withheld -- the defect it names. Its sibling covers the moved-address
state, where the scope is recorded and still must not be offered. Both fail when
the guard is removed.
The card's vault calls go through `secretsSave` / `secretsDelete` rather than a
raw-fetch pair, which is what every other settings panel uses: the
`X-Session-Key` header, the silent session refresh, and an error whose message is
the sign-in instruction instead of the gateway's cryptographic reason. A panel on
raw fetch reaches none of that and leaves an expired session staring at a bare
status code.
The API key never treats a failed read as "no key set". Every read the card draws
from is in its error gate, the vault index included: `apiKeySet` is derived from
that one fetch, so a transient failure rendered a key that EXISTS as unset and
then offered Save under it -- an invitation to overwrite a credential the reader
had just been told was absent. No credential write is offered until that read
succeeds.
A removal in flight holds the other credential controls, and `cleared` stays
`false` throughout. A vault entry is not a deferred edit: by the time it would
read true the DELETE has already been sent, so the field's deferred strip would
offer an Undo for a write nobody can take back. Save is gated on that DELETE as
well as on its own, since a DELETE and a POST outstanding together let whichever
the server finishes last decide, and a delete landing second erases the key just
saved.
A body carrying only `history_budget_chars` is a write this route accepts. The
ceiling is not a scope, but it moves on the same terms -- a number on the keystone
the card offers by itself, where raising it is not a review of an address -- and a
predicate naming only the two scopes refused every ceiling save with a 400, which
was the whole control dead on the one path an owner has for it.
The CARD is mounted synchronously and only its per-point DETAIL panel is lazy.
Settings search highlights a control by probing the DOM and gives up after 100 ms,
so a card behind a chunk boundary was a deep link that rang nothing. The panel can
ride a boundary because nothing it draws is in the settings registry: every
control in it takes its label from a map keyed by the SERVER's id, which is what
lets a gateway ship another point with no edit here. The App chunk lands at
3545.1 KB against the 3711 KB ceiling already in the tree, so no budget moves.
The row name carries a `title`, because the list track caps at 20rem and the
longest point name -- the one governing the widest consent -- does not fit.
The compaction scope's description names what it is WIDER THAN instead of counting
switches. It said "the widest of the three ... even if the switches above are
already on", and after the move only one switch sits above it in that panel; what a
reader consents against is the category, so it now says a whole session's
conversation goes rather than one call's arguments. The model-route line names WHERE
Auto (Jev) is chosen -- the session's model picker -- since "a session set to Auto
(Jev)" told a reader nothing they could act on. And the icon-only replace control
beside a stored key carries its own label: `SecretField` gained an optional
`replaceLabel`, because "Replace" names the verb and not the noun, and beside a
credential "replace the stored key" and "discard what I just typed" differ by
whether work is lost. Every other caller keeps the shared wording.
Removing the API key ASKS FIRST. The trash opens a confirmation and the DELETE
fires only from it, which is the shape the Secrets panel already uses for this same
vault. Firing the write on the trash and then reflecting it through `cleared` drew
the field's DEFERRED "will be removed on save" strip -- and that strip offers Undo,
so the card presented a recovery control for a deletion already sent, in exactly
the window a reader who reconsidered would reach for it. The vault never hands a
value back, so there was nothing to recover: the key was gone and a new one had to
be pasted. Two review lanes reached the same conclusion independently.
Save also stays shut while the question itself is open, not only while the
DELETE runs.
The confirm control carries its OWN word. The trash says "Remove key" and the
control that fires the write says "Delete key", because two controls with the
same accessible name are one control to a name-based selector and to anyone
listening to the page read itself out. Neither takes an `aria-label`: the visible
text IS the name, and a second one layered over it is the duplicate the repo's
accessibility rule catches.
A point whose SAMPLING admits nobody is not active. `decisions.sampling_percent`
at 0 -- or unreadable -- left every row reporting the switch state while not one
decision was ever collected, which is the status string telling a reader the
opposite of what the seam does. The status folds sampling in: no share, no active
row. An unreadable share reads as 0 rather than as 100, so the failure direction
is the quiet one.
The projection is resolved on a WORKER THREAD. Folding the sampled share into a
row's status made `_payload` read `config.json`, and both routes were calling it
straight from their coroutine -- so on slow storage every open of the card held the
event loop for a stat and a parse, and the gateway's other requests and its
heartbeat queued behind it (`no-blocking-call-on-event-loop`). Both call sites go
through `asyncio.to_thread`, which is what the keystone and governance reads beside
them already did; one hop covers every read in the payload rather than one hop per
read. The guard fails if either call goes back to being direct: it records the
thread the share is read on and compares it to the loop's.
The list's KEYBOARD path and the credential write are covered by tests rather than
by the screenshot harness alone. The list is one tab stop, so the arrows, Home and
End are the only way through it without a pointer, and Enter and Space are named
precisely so that "moving through the list writes nothing" is a property of the
keyboard path too. The credential test asserts the draft leaves under the vault's
own name, once, and that Save is held while there is nothing to send.
`decisions_history_desc` names the switch it points at -- "the main Jev switch"
-- rather than "the switch above". Under the list-and-detail shape what sits above
any given block depends on which row is open, so a positional reference is a
reference to whatever happens to be there.
The history ceiling is HELD while consent is off, and it says what turns it on. The
keystone writer stores that ceiling as 0 whenever the switch is off, so the write
answered 200 and the typed number was gone on the next read -- a field that takes a
value and discards it, on the one number that decides how much conversation leaves
the machine. The box is disabled there and a line beside it names the main Jev
switch as what makes it take effect, because a held control with no reason is a dead
one. The harness asserts both, after writing the consent-off frame rather than
before, so the shot the UX lane reads for the fresh-install default is unchanged.
The replace control carries its wording as VISIBLE text, not only an accessible
name. `SecretField` renders `replaceLabel` on the button and then carries neither
`aria-label` nor `title`, because the visible text IS the name and a second one over
it is the duplicate the accessibility rule catches. A caller that passes no label
keeps the icon and the shared wording, so no other panel moves: the Secrets, Slack,
Webex, Feishu, WeCom and Ops panels all still read "Replace".
Three copies of one wrong promise, not one. The docs said a scope-only write under
REVOKED consent answers `409`; the code answers `200` and records no scope, which is
the right behaviour -- a scope is only meaningful while the seam is on, and there is
no address to disagree about. The `409` belongs to the other case: a keystone enabled
for an address config no longer names. All three now say that -- the PUT docstring's
body, its Outcomes list, and the module spec -- and the spec's lock paragraph no
longer implies the pre-lock check covered the revoked case.
The feature map had the switch and the address INSIDE the collapsed block in its
enumeration and outside it one sentence later. Settings renders both above the
`<details>`, which is the backend tab's own rule about an egress consent behind a
closed disclosure, and the address is where a reader looks for it. The enumeration
now lists only what is actually collapsed.
The config PATCH route resolves the provider OFF the loop for every validator, not
just for the three tier keys this branch adds. `_validate_role_model` asks
`_model_rejected_reason` whether an account can use a model id, and that check reads
the configured provider with `KiroCrewConfig.load()` -- a file read plus a schema
validation -- whenever nobody hands it one. The `validate_fn` hooks are called
SYNCHRONOUSLY from `api_kirocrew_config_patch`, so that read was landing on the event
loop (`no-blocking-call-on-event-loop`). `_active_provider_name` is now resolved with
`asyncio.to_thread` once per request, before the hook, and passed down -- which is
what the validator's own `provider` parameter and its docstring were already for.
That fixes FIVE keys, not three. `agent.role_models.background`,
`agent.role_models.subagent`, `agent.fallback_model` and `agent.refusal_fallback_model`
share the same hook and the same read, and a concrete pin on any of them stalled the
loop the same way. One hop, and only for a key that carries a validator at all.
`""` returns `""` when the config cannot be read, which is the value
`_model_rejected_reason` already falls back to, so no answer changes.
Two reads stay on the loop deliberately and are named rather than moved.
`gate.configured_endpoint()` in the PUT goes through `config.live.snapshot()`, which
is a plain attribute read of the config the gateway has already adopted -- no
filesystem work, and that function's own docstring tells loop callers to prefer it
over a load. `_active_advertised_ids` reads the session manager's in-memory provider
list, not a file.
The harness writes the consent-off shared block as its own frame. The OFF scenario
already opened that block to assert the held ceiling; it now saves the state too, so
the description's screenshot of the first-run default is reproducible from this branch
rather than only from a local run. The assertions and the save both run AFTER
`decisions-off-light` is written, so that frame is unchanged.
An AUXILIARY read that fails no longer holds the main switch. Every read the card
draws from was folded into one `readFailed`, and `frozen` held every control from it
-- including the one control that STOPS egress. So a vault index or an advertised-model
list that failed while consent was on left the seam sending with no way for its owner
to withdraw, which is the opposite of what a consent switch is for. The vault being
unreachable is not a reason to keep conversation leaving the machine, and neither read
is needed to write `false`. The switch now rides `switchFrozen`, which carries only the
reads it stands on: the keystone it writes, the address that write is bound to, and the
governance answer. Every dependent control still rides `frozen`, and the failure is
still reported on screen -- this narrows what the notice disables, it does not hide it.
The feature map no longer describes a stacked column of switches. It said the third
scope sits "under the second", which was the pre-list layout; one panel renders at a
time now, so that switch is in `compaction.keep`'s own detail panel and the row says
so.
`docs/feature-map/README.md` and `docs/system-specs/modules/decisions.md` carry
the new shape, the widened editable set, the scope-only PUT and the point
projection.
Deferred to #12640: the save-failed copy, the redirected-endpoint status word
(a backend change in gate.py), the Releases link, row icons, relabelling, and the
POINT_CONFIG_KEYS shape question.
Human judgment recorded@iamwhatever marked the ux AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
One audit-verb rule for every consent write, rather than a separate word for a scope-only one: `_consent_write_verb` already names the widest thing a write did, and a single word for every scope write collapsed a grant and a revocation into one row -- which way egress moved is the fact an auditor needs. This PR's own two assertions and its spec sentence move onto that rule; neither body changed. The feature map gains `memory.recall` and its `memory_text` scope, with the point module and the third scope named on the ownership and endpoint lines, and `memory.recall` draws its own explanation rather than falling through to the raw id. A 404 on the consent route joins `readFailed` instead of rendering a note outside the card's notice, so every read that did not answer arrives through one predicate and one `ErrorNotice`. Its message stays its own: "this build is older than the feature, update from Settings > Releases" is actionable where "could not read, reload to try again" would be false, and the hand-off stays off because the copy already names the step. Settings search no longer sends a reader to a control behind a closed disclosure: the two registry entries inside the shared block open it on the first paint, which is what the highlight hook needs -- it probes the DOM, then strips the param. The share-of-sessions STATEMENT renders outside that block, in both switch states. `docs/system-specs/modules/decisions.md` pins it there: the shipped default is 100, so "every session" is what a reader agrees to and they must see it before flipping the switch. The slider stays inside -- that is the control, this is the fact. The three per-point consent switches are searchable again. They left the registry because the card draws them from one component labelled by whichever scope the selected point needs, so the extractor cannot resolve a literal label; `SETTINGS_MANUAL` is the declarator for that. Main's ids are kept, so a saved bookmark still resolves, and all three join `DECISIONS_SETTING_IDS` so a search that KNOWS the fleet ceiling withdrew the feature offers none of them. `POINT_CONFIG_KEYS` is deleted with the `config_keys` row field, the payload type, the reader's validation and the card's pointer map. One entry threaded through all of that printed one sentence; `skills.select`'s panel prints it as a literal, and a second point needing one is when a map earns its place. The ingress census walks the Decisions subtree and asserts its buttons as an EXACT set, so a button it does not name fails -- and so does a duplicate of one it does. The set is awaited rather than sampled: the card draws one button before its reads land and two after, so an unawaited assertion read whichever moment it hit.
GPT 5.6 Review — ✅ no blocking findingsGPT 5.6 completed its review of This comment is updated in place on each push. Review detailsFINDING -- website/src/pages/settings/DecisionsCard.tsx:204 -- scope-search links fall through to [GPT-REVIEWED] c181a6a False positive or not applicable? A repository writer can comment: |
Human judgment recorded@iamwhatever marked the ux AI finding as false positive, not applicable, or explicitly accepted for
This decision applies only to this commit. A new push requires a new judgment. |
































Problem / Motivation
The Decisions (Jev) card in Settings › Developer › Feature Previews was one column of prose: a consent switch, four paragraphs about what leaves the machine, a second switch for the tool-argument scope, an address, and one flat sentence listing what Jev decides. Nothing in it could be opened.
So a reader could not answer the question they came with — what does Jev decide for me, and is that one on — because every point that shipped after the card landed had to go into the same column, and no point had settings of its own to go to.
Why it matters
Four decision points ship on main today and three more are in flight (#12492, #12500, #12496). The card's shape did not have room for the fourth, let alone the seventh. And the one setting a reader most needs per point — the egress SCOPE a point cannot run without — was a switch in the shared column with no visible connection to the point that needs it.
Closes #11997 (the history budget had no control anywhere).
What changed (motivation → approach → change)
It takes the shape
AgentBackendTabalready uses for the same problem: a shared block, then a list, then one detail panel for the highlighted row.Overview. One row per point, each carrying the plain-words name, one line of what it decides, and a status chip (Switched on / Needs your OK / Off). The list is the GATEWAY's, not a frontend array:
GET /api/decisions/consentnow projectsdecisions/gate.py's own registry asid/needs_scope/status/config_keys, and this card holds a label per id the wayAgentBackendTabholds one per capability. A build that ships another point lights up a row with no frontend edit; a point this build has no label for renders under its own identifier rather than vanishing.statusis the SERVER's verdict, never a switch position —offcovers every reason nothing is sent, andneeds_scopeis its own value because the fix for it is a switch one level down.Detail. Clicking a row opens that point's panel: its consent scope toggle where one exists (
tool_args, which onlytool.riskneeds),model.route's three tier pickers drawn from the advertised-model list with keep the session's own model as the default (each writingdecisions.model_route.<tier>, which the config route accepts), the point's short explanation, and a pointer line for every setting the card deliberately does not offer. Highlighting a row changes the panel and nothing else — no row is a switch, which is what lets a point that is NOT running still get a row.Shared block. The consent switch and the egress sentence stay visible. The address (read-only, with its config path named), the credential, the sampling slider (
decisions.bucket, 0–100) and the prior-conversation ceiling sit in a disclosure closed by default.The credential goes to the dashboard SECRETS VAULT as the one entry
TYPESAFE_API_KEY, through the existing secrets handler.provider.api_keyhonourssecret://TYPESAFE_API_KEYand nothing else, so no key reachesconfig.jsonand none is read back: the field shows set or unset.A scope-only write omits
enabled.consent.KEEP_ENABLEDis resolved inside the save lock, so moving one point's scope cannot restate consent or rebind the endpoint; the handler refuses such a write unless consent already stands for the address config names (409), and audits it asoutcome=scoped.Left in config.json on purpose, each with a pointer line in its point's detail
skills.max_triggeredskills.selectpanelThe mechanism is general rather than a special case for that one line: a point's
config_keyscome from the backend registry, and any path a future point names gets the same sentence with no frontend edit. Onlyskills.selectnames one today.Two things this PR does NOT add, and why
decisions/log.py) but ships no reader for it, so there is no rate and no count to print. Counting rows here would mean adding a log aggregator, which is a mechanism this card does not get to invent. The row is designed with the space for it.memory.recall(feat(decisions): let Jev narrow what the memory_recall tool returns #12492),task.split(feat(decisions): let Jev suggest whether a request should be split across sub-agents #12500) andcompaction.keep(feat(decisions): shadow-score auto-compaction with Jev and show what it would keep #12496) are still open, sogate.POINTSholds four and the only scope that exists istool_args. When one merges, its row appears from the registry projection.One deviation from the brief
The brief put the main consent switch inside the collapsed global section. It is ABOVE it instead, with the egress sentence. Consent to sending conversation text off the machine is the one fact on this card a reader must meet without looking for it, and
AgentBackendTabstates the rule this follows: a fact behind a closed disclosure is a fact they do not see. So the disclosure holds the settings and never the consent.Backwards compatibility
GET /api/decisions/consentgained fields; no field changed meaning. An older dashboard ignorespointsand renders as before.PUTnow accepts a body withenabledABSENT. A body carryingenabledbehaves exactly as it did, so no existing caller changes.pointsin the payload) renders the list-unavailable line rather than an empty card.capabilities.decisionspinned off still yields NO card, and Settings search now withholds every registry id the card owns — not just the toggle — so the address and credential rows cannot be found through search under a pin.Tests
test/test_decisions_consent.py+test_decisions_tool_args_scope.py: theKEEP_ENABLEDsentinel, the scope-only refusal paths (409 / 403), the audit outcome, that an absent field preserves the recorded switch, and the writer's own endpoint re-check — a re-bind planted between the handler'spermitscheck and the lock is refused with nothing written.test/test_decisions_config_api.py: eachmodel_routetier accepts INHERIT and refuses a value outside the model-id grammar; a fourth tier and the whole map in one write are both refused;history_budget_charsand everyprovider.*path stay unwritable through the config route.test/test_settingref_schema_fixture.py: the three cross-layer guards — no control on the card may PATCH a path the route refuses, every tier the card offers must be in_EDITABLE_CONFIG, and the mounting section must not become a second consent writer.test_decisions_*.pyfiles, plustest_settings_deeplink_registry.py.decisionsCard.test.tsx(39),decisionsPreview.test.ts(22),settingsCoverage.test.ts(7),settingsSearchGovernance.test.ts(12),previewSurfaces.test.tsx(33).DecisionsCard.tsxwith the REAL settings extractor and asserts every label it finds is in the withheld set, so a future field added to the card cannot become search-findable under a pin without failing.src/i18n/run (703) green withI18N_BASE_REFset;npm run lint:i18nandnpm run i18n:checkOK.Manual verification
node scripts/capture-decisions-preview-card.mjs— the card's own screenshot harness, rewritten for the new shape. It runs the real built SPA with every/api/**call answered from fixtures and ASSERTS each state before saving it: the projected list (one row per point, in the gateway's order, each with the server's status word, exactly one selected), that the shared block is closed until opened, that every tier picker reads inherit and offers only advertised models, that grantingtool_argsmoves that point's status and leaves the consent switch alone, and that a pinned-off fleet gets no card and no list. 21 frames, 10 of them in this description.Screenshots / video
The ten below are curated, not appended: a review lane admits only the first ten image links, so the consent-OFF default and the empty points list -- the two states the UX lane reported it could not evaluate -- lead the set. Each URL was fetched with
curl -Land returned 200 before it went in here. Captured atbdde655e2d.1. Fresh install, consent OFF -- the main switch reads off, all five rows carry the
Offchip, andRisky tool-call notesis OPEN with no control inside it. With nothing being sent there is no egress scope to offer, so a switch there would describe a state that cannot happen. The harness asserts all five chip words and that the open panel'sswitchcount is zero.2. Older gateway, points unavailable -- consent answers but the point projection does not, so the card names the update that fixes it instead of drawing a list it cannot source.
3. Removing the credential ASKS FIRST -- the trash says Remove key and opens this question; the DELETE fires only from Delete key. Two different words on purpose: one accessible name across both controls is one control to a name-based selector and to anyone listening to the page read itself out. Neither carries an
aria-label-- the visible text is the name. Cancel is Keep it.4.
model.route, the tier pickers -- the rowModel for the turn's difficultyselected, its three pickers on screen, every one reading Keep the session's own model. INHERIT is the default and no model id is named in code: an id the reader's account is not offered would fail on the first prompt. Each picker writesdecisions.model_route.<tier>, registered in the route's editable set from the point's own tier tuple.5.
compaction.keepawaiting its OK -- the whole-transcript switch, off, with the line naming it as the OK the row's chip asked for.6.
message.steer-- a point needing no scope beyond consent itself, so there is no second switch to draw.7.
tool.riskawaiting its OK -- the scope the chip is asking for, not yet recorded.8. Overview, consent on -- five rows. Names carry a
titlewhere the 20rem track truncates them. Every chip here reads the switch state AND a sampling share that admits somebody: atsampling_percent: 0these same rows readOff, which is the status change in this push.9. Shared settings, credential SET -- the replace control carries Replace key as its own visible text, not just a "Replace" tooltip, and no
aria-labelover it. The history line names the main Jev switch rather than "the switch above", since what sits above depends on which row is open; with consent OFF that box is held and says it takes effect once the main switch is on, rather than taking a number the keystone would store as 0.10. Shared settings, consent OFF -- the first-run default, since consent starts off. The history box is DISABLED and the line under it reads This takes effect once the main Jev switch is on. The keystone writer stores that ceiling as 0 whenever the switch is off, so a write would have answered 200 and the typed number would have been gone on the next read. Held with a reason beside it, never a field that takes a value and discards it.
Dropped from this ten as redundant, still asserted in the harness (21 frames): the dark overview, the shared block with a credential UNSET,
compaction.keepgranted,tool.riskgranted,skills.select, the moved address, the backend-missing / read-failed / save-failed notices, the governance pin and the settings-search hit.What the first review round changed
Every blocking finding was real. All five are fixed in code rather than dispositioned.
Three headline controls wrote paths the config route refuses (Design BLOCK, GPT F2).
PATCH /api/config/kirocrewmatches_EDITABLE_CONFIGexactly, and it helddecisions.bucketalone — so the address field, the history box and all three tier pickers would have failed every save on a real gateway. Fixed by security class rather than by widening the allowlist wholesale:decisions.model_route.<tier>, added to_EDITABLE_CONFIGDECISION_MODEL_ROUTE_TIERSso the gate and the point's answer domain cannot drift, and validated exactly as theagent.role_models.*pins beside it.PUT /api/decisions/consentconfig.jsonis agent-writable and carries what the seam ASKS for; the keystone ceiling clamps it, and the gate sends the smaller. Giving the owner the config value would have put their control in the file the agent can also write. This is what closes #11997.decisions.provider.*exclusion is a deliberate, documented decision: a dashboard caller must not choose where collected state is sent, andapi_keybeside it is schema-sensitive, so the masked GET hands back a sentinel a PATCH would clobber. Not reversed in a UX redesign.A scope write could land on an unreviewed address (GPT F1). The handler checks
permitsfor the configured endpoint, thensave_enabledtakes_SAVE_LOCK— a re-bind ofprovider.endpointin that window would have carried the widertool_argsegress onto whatever the keystone recorded by then. The writer now re-checks the recorded address against the endpoint in force inside the lock and raisesConsentEndpointMovedError; the handler answers with the same 409 the pre-lock checks use, and nothing is written.The save-error notice could discard a typed credential (GPT F4). It carried
askAgent, and a save failure is exactly whenapiKeyDraftholds a key the vault has not taken. The hand-off is gone, with a comment naming the draft.Two screenshot states were missing (UX BLOCK). The harness gained the unset
Save keyframe and the no-points frame; 15 asserted frames now, 10 in the body.UX watch and suggestions, taken as code. A
needs_scoperow's panel names the switch below it as the OK the chip asked for. The list track widened so no point name ellipsizes. The status chip says the switch state rather than the activity — as Switched on, notOn: the i18n bare-connector rule refuses a loneOnas a new catalog value, andOffis only there as frozen debt.A latent red CI never ran.
test_settingref_schema_fixture.pyreadFeaturePreviewsSection.tsxfor the consent writer, which moved toDecisionsCard.tsxin the first commit. It passed atc650e96413only because the Feature Map Gate failure skipped every backend job. Fixed, plus three cross-layer guards so the dead-control class cannot come back: no control on this card may PATCH a path the route refuses, every tier the card offers must be in_EDITABLE_CONFIG, and the mounting section must not grow a second consent writer.Two settings-search entries this drops, and the honest reason
Both
developer.also-send-*registry entries are gone —grep also-send website/srcreturns nothing — so neither egress-consent switch is findable in settings search, in any state, not only under a governance pin. Stating that plainly because an earlier draft of this section implied the pin was the whole story, and it is not.The reason is mechanical, not a policy choice: each scope switch now lives on its own point's panel and takes its label from a map keyed by the server's scope name, and the registry extractor resolves only a literal
i18nT('key'). A map lookup is invisible to it. Keeping those two indexed means a per-point branch in the card for whichever scopes happen to exist today, which is the arrangement the server-projected list exists to avoid.What that reason is not: the waiver in
settingsCoverage.test.tsargues a manual entry "would advertise a row thecapabilities.decisionsceiling can withdraw", and the First Principles lane is right that this PR disproves its own excuse —developer.jev-api-keyand the ceiling row are both in the registry and inDECISIONS_SETTING_IDS, which is exactly the governed-registry treatment that makes a withdrawable row safe to index. So the ceiling is not the obstacle. The extractor is. The waiver's wording overstates the case and the two rows could be indexed by hand; whether that is worth a per-scope manual entry is a maintainer call, and it is tracked in #12640 rather than decided here.developer.address-decisions-are-sent-toalso goes, because the address is a read-only line now and a search hit would promise a control that is not there.The config route's editable set is widened BY THIS PR
The tier pickers write
decisions.model_route.<tier>, and this diff is what makes the route accept them — it does not inherit that acceptance. It also rewrites the spec sentence that said the editable set "staysdecisions.bucketalone". Recording it as this PR's own reversal so the spec change is not read as documentation catching up with something already true.What the second review round changed
Bundle Size Gate went red, and the attribution is measured rather than assumed.
main @ feed35446alone — no PR code, built in a detached worktree — puts theAppchunk at 3,616,146 B (3531.4 KB) against a 3533 KB ceiling: 1.6 KB of headroom, 0.05%. This PR adds one module (the card plus its strings across 13 catalogs, +8.4 KB) and trips it by 6.6 KB. That is the third instance of a recurrencecheck-bundle-size.mjsalready documents twice in its own comments — "a ceiling that drifted to <1% headroom fails on routine string growth rather than on the new library it exists to catch" — and it takes the same remedy those two took: ~5% headroom re-measured at the current build, with the measurement written down.A lazy
import()boundary was the alternative and was not taken. It would move 8 KB out of a 3.5 MB chunk, leave main's own 0.05% headroom exactly where it is so the next PR trips the gate again, and make this the first Suspense boundary in the settings tree — a new mechanism paying for 0.2% of the chunk.Two UX Watch items were real input bugs and are fixed:
Number.parseInt(raw, 10), which reads a prefix — so a typed6,000saved 6, silently, on the one value that decides how much conversation leaves the machine. It now takes the whole string or nothing, and an unreadable input leaves the consented ceiling on screen, which is the smaller number and the fail-closed direction.The previous UX BLOCK was stale evidence, not a missing state. That round read the description before the screenshot update landed, so its four evidence gaps describe the first commit's frames. All four states were already captured; the one it asked for by name —
tool.riskselected while its row still reads Needs your OK, showing where the OK is given — is a new asserted frame, and the harness is at 16.Rebased onto #12496, and the bundle fix is a SPLIT rather than a ceiling
compaction.keepmerged while this was in review, so the branch is rebased onto17c96c7ab0and the third decision point arrives through the projection with no per-point code — the row, its status chip and its consent switch. Two things came out of merging rather than out of either side:gate.POINT_SCOPE_KEYS, one map that both the scope-enforcement table and the card's rows read. Before it, this card resolved every row's scope throughconsented_tool_args, so a second scope would have drawn the wrong point's consent on its switch. Both are now projections of the same two sets, and neither can learn about a scope the other does not.The bundle red is fixed by code-splitting, and no ceiling moves.
FeaturePreviewsSectionmounts the card behindlazy(), withfallback={null}because a card that renders nothing under a governance pin can render nothing while its chunk is in flight. Measured, base-ref first:main @ feed35446alonecheck-bundle-size.mjsuntouchedThe split lands below what main alone builds, because the boundary also takes content that is inline in
Appon main.check-bundle-size.mjsis byte-identical to main, so there is no rides-along budget change in this PR. The gate is the regression guard for the split itself: a static import puts the card back at ~3540 KB and fails it.One bug the split surfaced and fixed: a long comment placed between the main switch's JSX props pushed its opening tag past the settings extractor's tag-walk ceiling, which silently drops
developer.decisions-jevfrom settings search — the one entry thecapabilities.decisionsgovernance test asserts against.settingsCoverage.test.tscaught it; the reasoning now sits above the tag, with a note saying why.Final round: the API key, the ceiling, and where the lazy boundary sits
Five items, all maintainer-selected, and the two that matter most are on the credential.
A failed read never presents itself as "no key set".
apiKeySetis derived from one fetch of the vault index, and a transient failure resolved it tofalse— so the card said "not set" about a key that exists and offered Save under it, which is an invitation to overwrite a credential the reader had just been told was absent. That read now joins the card's error gate along with the model list, and no credential write is offered until it succeeds.A removal in flight holds the other credential controls, and
clearedstaysfalsethroughout. A vault entry is not a deferred edit: by the timeclearedwould read true the DELETE has already been sent, so the field's deferred strip would offer an Undo for a write nobody can take back. Save is gated on that DELETE as well as on its own, and on the confirmation being open at all. A DELETE and a POST outstanding together let whichever the server finishes last decide, and a delete landing second erases the key just saved.Both guards are revert-verified: mutating either back to its defective form fails a test.
A ceiling-only write is accepted. A body carrying just
history_budget_charsfailed the standalone-write predicate and always returned 400 — the whole control dead on the one path an owner has for it. The ceiling is not a scope, but it moves on the same terms: a number on the keystone the card offers by itself, where raising it is not a review of an address.test_decisions_compaction_scope.py's refusal-case list drops it for that reason and keeps the property it was there for — a body naming nothing the route may move alone is still a 400.The card is synchronous again; only the per-point detail panel is lazy. Settings search highlights a control by probing the DOM and gives up after 100 ms, so a card behind a chunk boundary was a deep link that rang nothing. The panel can ride a boundary because nothing it draws is in the settings registry: every control in it takes its label from a map keyed by the server's id, which is what lets a gateway ship another point with no edit here. The App chunk lands at 3545.1 KB against the 3711 KB ceiling already in the tree, so no budget moves in this PR.
The row name carries a
title. The list track caps at 20rem and the longest point name — the one governing the widest consent — does not fit.Deferred to #12640, with each item attributed to the lane that raised it: the
decisions_save_failedcopy (it promises a switch for controls that are not switches), a realredirectedstatus word for the moved-endpoint state (a backend change ingate.py, so the card keeps reporting the server's verdict rather than inventing one), the Releases link, row icons, relabelling, and whetherPOINT_CONFIG_KEYSshould exist at one entry.Copy corrected in the same round
Three strings were false or unactionable rather than merely improvable:
decisions_compaction_desccounted switches — "the widest of the three … even if the switches above are already on" — and after the scope moved into its point's panel only one switch sits above it there. It now names what the category is wider than: a whole session's conversation goes, not one call's arguments. That is the fact a reader consents against.decisions_what_model_routeended "only in a session set to Auto (Jev)" without saying where that is set. It now names the place: the session's model picker.SecretFieldgained an optionalreplaceLabeland this card passes Replace key. Every other caller keeps the shared wording.test/test_decisions_consent.pyis black-formatted.Not in this round, by maintainer decision: the
Switched ondual meaning between the card's switch and a row's status chip. It is real, it is a naming decision across the card's whole vocabulary, and it is tracked in #12640 rather than reopened in a push whose job is closing an evidence gap.Related Issues
Closes #11997
Pattern harvest
Rule candidate: review-prompt
Pattern: a frontend array of backend identifiers is a second registry — when a card enumerates ids the backend owns (decision points, capabilities, scopes), it must hold a LABEL per id and read the id list from the server, or the two diverge silently and the card claims a decision the gate will never make.
Second, narrower: a governance pin that withholds one registry id withholds the whole surface's ids. The card's toggle was withheld and its address and credential rows were not, so a pinned-off fleet could still find them through Settings search. Any withheld-under-pin list is a property of the SURFACE, not of the one control the pin was written for.
Checklist