Skip to content

feat(autonudge): screen nudge ticks with a typed wake judge - #12787

Merged
iamwhatever merged 2 commits into
mainfrom
feat/wake-judge-core
Sep 24, 2026
Merged

iamwhatever merged 2 commits into
mainfrom
feat/wake-judge-core

Conversation

@chenmingwei23

@chenmingwei23 chenmingwei23 commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

What is the problem?

An auto-nudge loop fires a full model turn on its owning session every interval.
For a pull request named by URL, PrWatchProbe already turns an unchanged tick
into a free re-arm. For everything else it cannot: a conductor patrolling worker
transcripts, a babysitter reading bot comment bodies, a loop watching a log. The
probe reads typed facts, a check conclusion or a merge state, and the evidence
that would justify staying quiet in those loops is prose.

So every tick costs a turn on the main session whether or not the new evidence
needs one. Measured on this repository: a conductor watching three workers at 45
minutes spends about 48 turns over two days to act on roughly five events.

Why this matters to the user

Those turns are the expensive kind. Each one carries the owning session's whole
context, so the cost is the context rather than the model, and a cheaper tier
does not help. The waste is also invisible: a loop that woke, found nothing and
went back to sleep leaves nothing on screen to say so, which is why ten patrol
loops once died together on a gateway restart and nobody noticed for hours.

How our fix solves it

On each tick, wake a judge instead of the session: a fast typed decision that
reads the new evidence and answers whether the owner needs to act now. Only a yes
spends a turn.

  • src/kiro_crew/decisions/points/nudge_wake.py is the point. It builds a
    bounded state from the evidence, asks three questions -- does the owner need to
    act, what is the outcome, how urgent -- and maps the answers to one verdict.
    It is a pure adapter, so a test drives it with literals.
  • src/kiro_crew/autonudge_judge.py is where the evidence comes from. A watched
    session contributes its new assistant rows. A watched pull request contributes
    NOTHING on any loop this judge screens, because the canonical observation its
    reader wants has one writer and that writer is on the structured path; the reader
    and its renderer are wired and tested against that shape and produce one line by
    render_pr_summary once a gated tick publishes one, from the twelve canonical
    keys such a record carries -- state,
    draft, mergeability, review decision, blocking review, unresolved thread count,
    per-bucket check tallies with the failed and pending lanes named, the two
    completeness flags, the head revision -- plus the PR-level comment-body
    fingerprint when one is present. Never comment body TEXT: the reader that sees
    those bodies reduces each to a fixed width and retains none, so no producer for
    body text exists and none is claimed. The rendering lives in this module because
    this module is its only consumer, and the monitor's canonical object is pinned by
    full-dict equality tests and hashed into the wake fingerprint, so a field added
    there for one reader would change what every provider must emit. Every read
    arrives as a callable, so this module imports no dashboard module and every
    function is testable without a gateway.
  • AutoNudgeService._judge_tick_is_quiet is consulted only where the typed probe
    reports quiet, and returns None when no judge applies, which is what leaves an
    UNGATED loop, an explicitly opted-out one, and every loop on a machine that has
    not granted the scope behaving exactly as they do today. A gated loop is screened
    whether or not its owner wrote a brief.

Four properties are worth naming, because each one closes a way this feature
could have gone wrong.

It cannot read what its owner could not. A session target is read through
session_control.read_messages, which authorizes with authorize_target before
returning a row: deny-by-default and SEL-audited. A target that refuses is
dropped and counted by the same code path that refuses it, so nothing here
re-implements an authorization rule.

It cannot end a loop. finished and broken wake at every confidence with the
verdict attached to the fired turn; only a typed probe may terminate one. A
judge-minted terminal would let a single hostile comment buy permanent silence, so
the judge does not have one. A parametrised sweep over every outcome, both owner
options and eight probabilities asserts no answer can produce it.

An unread pull request is a DROPPED target, not a calm one. The PR reader answers
None for a loop carrying no monitor -- which is every loop armed through
POST /api/autonudge -- for a brief naming a pull request the loop does not watch,
and before a monitor's first observation. That None used to reach pr_evidence,
which returns an empty list, so the tick held no evidence and no drop: the exact
shape the rule below reads as "every target was read and was calm". The collector
counts it as a drop before the call.

A verdict whose brief was replaced mid-tick is discarded. The reads and the decision
both happen outside the service lock, and an update that replaces the brief clears the
streak, the cursors and the verdict record because all three describe the brief that
is gone. A tick already in flight re-read the brief after its awaits and commits
nothing when it changed: it restores the empty cursor map that update installed and
fires, so the rows it consumed are judged by the next tick under the brief that now
applies.

The monitor path asks the judge BEFORE charging its quiet counters. A judge that
answers wake or fallback makes the tick a delivered one, so charging first booked it
as free -- overstating the saving the feature exists to report -- and walked a
delivering loop toward a forced floor tick it never earned.

An empty delta is calm only when the read succeeded. Three different things make a
tick's delta empty and only one of them is "nothing happened": a target the
collector could not read leaves the tick blind, and evidence the scrub or the budget
shed entirely leaves it holding something it may not send. Those two fire, because
"we could not look" must never read as "we looked and it was calm". Every target
read with nothing new on any of them answers QUIET, which is the common steady state
of a patrol and the case the feature exists for; it lands in the same streak the
floor bounds, so a subject that simply stays silent still buys a delivered turn at
the floor rather than silence. The point decides this on the collector's own count
of unread targets, which the tick forwards.

It cannot go quiet indefinitely. Consecutive QUIET verdicts are floored, and the
floor's default is the probe path's own _MAX_QUIET_STREAK rather than a second
number. decisions.nudge_wake.quiet_streak_floor overrides it, clamped to a hard
ceiling on every read because config.json is writable by an auto-approved agent
shell; without that clamp an injected floor could keep a watch silent for good.

It cannot feed itself. A verdict writes one notice row on the loop's OWN session
-- the session the loop is armed on and would have woken, not the sessions it
watches -- through append_and_surface, the same durable no-turn surface a refused
arm uses, carrying probabilities and counts but never evidence text. Notice rows are
excluded from evidence structurally, because the session collector admits
assistant rows only.

The lane rule lives in ONE place, and it is the seam's: the tick screens with a
single decisions.is_enabled(nudge.wake), which routes this point through
gate._judge_authority and answers both which lane would serve and whether that
lane is armed. Nothing here re-derives it. That matters because a second resolver
can only differ from the first: one arming Jev on endpoint consent alone picks the
Jev lane on a machine that consented without granting the scope, the gate refuses
that lane, and the tick is skipped where the gate itself picks the lane that needs
neither. The rule it enforces: llm takes the model-provider
lane and needs no keystone -- its destination is the provider the session already
uses and its data class is the owner's own sessions, it decides only quiet versus
fire, and it is fail-open, so it adds neither a destination nor a category to the
keystone's scopes, which are categories of Jev egress. jev needs the Decisions
switch and the nudge_evidence scope. auto resolves to Jev when Jev is ARMED --
consent AND that scope -- and to the LLM lane otherwise. With the scope off a
stored brief is ignored and the loop runs as a plain timer, so granting the scope
later arms every loop already carrying one. A test asserts the service exposes no
lane resolver of its own, because the fault is a second rule existing at all and a
call-level test passes either way.

decisions.nudge_wake is registered on DecisionsConfig, so both knobs are
settable and appear in Settings. The floor is stored as a sentinel 0 meaning
inherit rather than as a copy of the engine's number: autonudge imports
config.loader at module scope, so the config module cannot import the constant
back, and a copied literal would be a second thing to keep in step. The engine
resolves the sentinel and owns the ceiling.

Both arming surfaces carry a brief, and both validate it. monitor_start and
monitor_update are the tool path; POST /api/autonudge is the dashboard's
plain-HTTP path, and it accepts judge, runs the same validate_judge_spec, and
refuses a bad one with a 400 naming the field. That validation belongs at the
surface rather than at authorize_and_add_nudge, which takes the brief through
unchanged and documents why: a refusal has to name a field the owner can fix, and
only the surface they typed it at can do that. Silently dropping a brief would be
the one outcome that leaves a caller believing a judge is armed when none is.

judge is also advertised in both monitor tools' model-facing inputSchema, as an
object with wake_when, quiet_when and an optional targets list. Without that
the field was unreachable: the handler read it and the applier stored it, so every
Python-level test passed, while no agent could send one -- QA found a real turn
arming a loop with judge == {} and the criteria pasted into message as prose.
The regression guard is asserted against the schema rather than against a call,
because a call-level test goes green while the field is invisible.

On the Decisions card, nudge.wake is registered in the point-name and disclosure
maps, so the row reads in plain words instead of rendering its internal identifier
to every visitor, and its nudge_evidence switch draws from the row's own
needs_scope with a label, a description and a granted position all present. The
card's egress note now counts four categories rather than three and names the new
one, because that note is what tells a reader what can leave the machine and a
stale count understates it.

What the loop projection may publish is settled per field. judge_cursors is
dropped on EVERY projection, not just the structured-monitor filter: a read
position is bookkeeping no reader can act on, and it names each watched target.
That drop had to go in _serialize, because _serialize is asdict and a plain
loop never reaches the structured filter -- which is exactly how the cursors
reached those reads, by the field existing rather than by any decision.
judge_quiet_streak and judge_last_verdict are published: they are the
automation's own accounting, the same class as cycle_count, and the verdict is
text-free by construction -- an outcome, an item COUNT and a timestamp -- so it
cannot carry a transcript line the judge read.

The monitor popover renders that, under the schedule line it modifies: Judge: wake when <criterion> - last: quiet - 3 items - 12:30Z. The row is the OWNER'S own
sentence or nothing: a loop screened under the default brief gains no row, because
the default is never written onto the record and the row would otherwise report
shipped text back as though the owner had written it. Where a default-brief verdict
IS reported is the per-tick transcript notice, which names the brief it used. A judge that has not answered yet reads "no verdict yet" rather than quiet,
because those are different statements and reading one as the other would report a
tick skipped that never happened. The line carries no probability: the record holds
none, and the per-answer numbers live in the decisions log, which is where the RFC
puts threshold tuning. The reading is a pure function in autoNudgeLoop.ts beside
nextCycle, for the same reason that one is -- each surface words it for its own
layout -- and that is where its 12 tests live.

That line renders through the session's automation record rather than straight from
the REST row, so the judge is carried at both hops in between. A session slot holds an
AutomationRecord, and the popover rebuilds its own loop shape from it field by
field. Both of those name every field they carry, so a judge published by the
projection and declared on the popover's loop type still reaches the owner only by
being named in the record and in the adapter as well; a value missing at either hop
reads on screen as a loop armed with no judge, which is the honest reading for most
loops and correctly draws nothing. The normalizer coerces the brief and the verdict
through the same fail-inert helpers as every sibling field, so a malformed judge also
reads as no judge instead of throwing inside the render of a loop that is otherwise
fine.

What tests we did

test/test_autonudge_wake_judge.py, 112 tests, run with -n0 and a stubbed
oracle at decisions.decide, so no provider key is spent and the real state
builder, mapping and tick all execute.

  • The mapping table, every branch: no answer, a missing question and an
    out-of-domain outcome all reach FALLBACK; low confidence wakes; both action
    outcomes wake even when the judge said quiet; a sweep asserts no outcome outside
    the quiet allowlist can produce silence at any probability; and a second sweep
    asserts no answer at all can produce TERMINAL.
  • The terminal family: finished and broken wake at every confidence with the
    outcome named in the body, a repeated finished keeps waking rather than being
    suppressed, and the loop stays armed.
  • State bounds: the request fits its ceiling with the oldest items dropped first,
    per-item and instruction clips hold, the previous verdict is carried, and an
    item carrying a credential is dropped by the seam's own scrub.
  • Collectors: assistant rows only with tool and user rows excluded, a refused
    target dropped with its read cursor held rather than advanced, a cursor advanced
    only on a read that returned, target shapes screened, and ISO-8601 row
    timestamps parsed into ages -- verified against a live history row, because a
    numbers-only parser read every session row as age zero and made the
    drop-at-cap order arbitrary.
  • The tick: an ungated loop, an explicit judge: false, no provider lane and a
    missing scope each leave the tick untouched with the brief still stored, and in
    each case the evidence reader is a function that raises if called, so nothing is
    read. A gated loop with no criteria of its own is judged under the default, which
    is asserted by the criteria the judge was ASKED under rather than by the outcome. QUIET spends no turn; WAKE
    and a refused provider each spend one; the streak floor delivers and resets; a
    collector failure spends a turn.
  • The unread pull request: a None observation is a drop and contributes no
    evidence, with a read observation as the control so the drop is not unconditional.
  • The replaced brief: a collector that swaps the brief mid-tick leaves the streak
    uncredited and the cursors empty and fires, with an unchanged brief as the control.
  • The monitor metering: a quiet probe whose judge fires spends the turn and charges
    neither the free-tick counter nor the streak.
  • The empty delta, 7 tests: every target read with nothing new answers QUIET and
    reports zero items with no answers; one unread target answers FALLBACK; evidence
    the scrub shed answers FALLBACK; each is told apart by its verdict body, not only
    its outcome. Through the service: a calm read spends no turn and counts toward the
    floor, an unread target fires and resets the streak, and a subject that stays calm
    still fires at the floor. The provider returns None in those three, which is the
    shape that would FALL BACK if the tick reached it, so a QUIET there can only have
    come from the delta. One source-level test pins that the tick forwards the
    collector's count, since a caller that kept it would make a blind tick read as calm.
  • The notice: a QUIET verdict writes one, and a notice row can never be collected
    back as evidence.
  • The arm path: a brief survives arming, revision (which resets the streak and
    cursors, since those describe the old brief), clearing, an unrelated update, and
    a store reload; a corrupted store row normalises to the inert shape. A stored
    brief is also bounded on load -- 50 targets reduce to 8, an oversized target and
    criterion are clipped, unknown keys and bad cursor values are dropped.
  • Schema: validate_judge_spec accepts and de-duplicates, treats absent and empty
    as legal, and refuses nine malformed shapes including an unknown key.
  • The HTTP arming route: a body carrying a brief arms a loop whose record holds it,
    an invalid brief is a 400 naming the field with nothing armed, a non-object brief
    is a 400 rather than a traceback, and a body with no brief arms a loop with none
    -- the last one a negative control, so the route cannot invent an empty judge for
    every loop the goal popover arms.
  • The tool surface: both monitor tools advertise judge with all three fields
    described, a sent brief reaches the directive payload, a malformed one is refused
    naming the field with no directive emitted, false normalises to the reserved
    opt-out marker while true is refused and a hand-spelled marker is an unknown
    key, an empty object survives as "no criteria of my own", and a call without one
    emits no judge key.
  • What the projection publishes: read cursors never appear, the verdict carries an
    outcome and an item count and no evidence text, the two readings the popover needs
    do survive, and no judge field carries a nested sequence -- a shape check, because
    a verdict that later carried its evidence for context would pass a substring test
    against this test's own literal while publishing every line it read.
  • The render path from the wire, 4 tests: a GET /api/autonudge row in the wire's
    own spelling goes through the real normalizer into the session popover, and the
    judge line is asserted on screen carrying its criterion and its verdict -- then in
    the no-verdict state, then absent for a cleared brief, then absent rather than
    throwing for a malformed one. Mounted from the wire because the chain holds three
    shapes that each name their own fields, so a test handing the popover a loop object
    agrees with the reader about every name and passes while a middle hop carries none
    of them. Verified discriminating by dropping the judge at each hop in turn, which
    fails exactly the two lines-on-screen tests.
  • The Decisions card, 92 render tests: the nudge_evidence switch draws on the
    nudge.wake panel and reads its granted position, the row is named in plain words
    rather than as nudge.wake, and the switch is withheld entirely while Decisions
    consent is off.
  • The config section: the shipped lane default, the stored floor sentinel, the engine resolving that sentinel to _MAX_QUIET_STREAK, an over-large floor
    clamped by the engine, lane normalisation in seven shapes, floor coercion in six
    (negative and malformed both read as inherit, never as unbounded), a non-object
    section in five shapes, and the sibling decisions keys still parsing.

Also green locally: 114 frontend tests over the Decisions card and its preview
projection with tsc clean, 89 config-ratchet tests including the regenerated
config-baseline.json, mypy over 1687 files, and the fast static gates relevant
to this diff -- check_feature_map, docs_lint, check_brand_name,
check_comment_history, check_changelog_history, check_black_formatting and
check_sync_io_in_async. The backend surface suite is left to CI.

Writing these found three real defects in earlier revisions of this branch. The
tick called gate.is_enabled directly and that function does a synchronous
keystone file read, on what is the gateway's event loop; both keystone reads now
go through asyncio.to_thread. A judge brief with criteria but no explicit
targets watched nothing while looking armed, because target inference read
pull-request URLs out of the loop message but not chat-* keys. And a
repeated-terminal branch zeroed the quiet streak and then incremented it, so the
floor sat at 1 forever and could never fire -- a judge wrong about finished
would have silenced the loop permanently, which is the one thing the floor exists
to prevent. That branch is gone entirely now, because the no-terminal rule
removed the state it guarded.

Every new UI string is translated in all 12 catalogs rather than left as English
passthrough. The repo's own gate settles that: a value NEW or EDITED on a branch and
still reading as English is "not inherited debt and there is no ceiling to raise".
The per-language style gates then had their own say -- French wants U+202F before
double punctuation, Bengali addresses the reader as informal, Hindi forbids the
formal pronoun, and Chinese allows at most two stacked possessives -- so those are
honoured per language rather than worked around.

decisions_egress is edited, not replaced. Its category count moved from three to
four, so each locale keeps its existing translation with only the count word changed
and the fourth category appended in that language. Replacing the paragraph with
English would have told ten languages' readers less about what leaves their machine
than the English reader is told, which is the fault this note exists to prevent.

The translations chunk's budget rises from 905 to 951 KB, the measured 905.6 KB plus
the 5% the entry's own note documents as its convention. The growth is 7 keys across
13 catalogs, one of them a consent disclosure that must exist in every language and
cannot lose a fact to fit. No dependency is added, and no lazy boundary can move a
catalog string out of that chunk.

Rendered surfaces

Captured from a pod at 1280x800 with the feature preview on and the scope granted.

Settings, Developer, Decisions: the nudge.wake row named "Quiet check-ins: wake or skip", its nudge_evidence scope switch, and the egress note counting four categories

This frame is the CONSENT surface: the point's row and description, the
nudge_evidence switch an owner has to turn on for the Jev lane, and the egress note
whose category count this change raises to four. Those are the strings a reader has to
weigh before granting anything, so they are the ones worth a frame first.

The popover's own judge line is a second surface and is not in this frame. It renders
Judge: wake when <criterion>, and beneath it either no verdict yet or a verdict row
carrying the outcome word, the screened item count and the time, separated the way the
line above it separates its own parts. It needs a loop armed with a brief and then
actually judged before a verdict exists to show, which is why it needs its own capture.
Its strings and their pluralization are covered by tests, and a reviewer reading this
revision should treat the popover line as unillustrated rather than approved.

Any other suggestions on the work

Four things a reviewer may want to weigh.

urgency is asked and recorded but changes no verdict. The design specifies all
three questions and says the thresholds are to be tuned from the logged answers,
so it is calibration input; a rule consuming it before there is a curve to read
would be a guess wearing a constant's name. Worth revisiting once the log has a
fortnight of data.

A needs_owner answer of wake below the 0.5 bar maps to QUIET, because the
threshold is applied literally. It is unreachable from a conforming two-option
provider, where the chosen option is the argmax and so carries at least half the
mass; it exists only to bound a provider that returns a non-argmax choice. Left
as specified rather than quietly widened.

Filling the provider's per-option criteria map properly is a genuine improvement
over carrying both sentences in the prompt, and it is a separate change to the
shared request builder rather than part of this one.

A judge brief on a loop that ALSO watches a pull request currently takes
precedence over the typed probe for that tick, so monitor.last_observation is not
refreshed on a tick the judge answered. Reviewers flagged this and it is real. The
consequence was the one that mattered: a merged or closed pull request never
deactivated such a loop, because the judge emits no terminal of its own and the typed
probe that would have was skipped. FIXED HERE, not deferred to a follow-up. The typed
probe now observes first on any monitor-backed loop and a typed verdict wins outright;
the judge screens exactly one tick, the one the probe looked at and found nothing in.
No typed signal can be suppressed there, because every outcome that means something --
terminal, wake, fallback, an interrupted poll, a drifted target -- has already returned
by that line. What the judge still adds on such a loop is the evidence the probe cannot
read, a review left in prose. Four tests pin it: a merged pull request deactivates a
JUDGED loop, an actionable observation fires without asking the judge, a quiet
observation is the one tick the judge screens, and a quiet tick with no judge keeps the
probe's own verdict.

One further finding was raised against the quiet path and adjudicated DOWNGRADE
(disproportionate-remedy), so it is deliberately not changed here. The reasoning is
worth restating because it is the reason for inaction: the quiet branch schedules its
write through _persist_soon, the detached pattern used at roughly fifteen call sites,
whose own docstring pins the accepted degradation -- a lost write costs a fresh
countdown after restart, never a premature or dropped fire. The streak floor is a hard
backstop, so a reloaded streak postpones the floor by one quiet tick and then
re-accrues. Installing a blocking persist with rollback on this one path would
contradict the surrounding pattern to buy a one-tick, self-correcting delay.

Still in flight, and named here rather than left for a reader to discover. The
work-ledger and self collectors are not in. Both need a design answer rather than
more code. A work-ledger collector needs an evidence kind the point does not
declare, and the declared set is deliberately closed. A self collector -- a loop
reading its own session -- introduces a feedback path the other collectors do not
have, because a loop's own fired turn is an assistant row in its own slot, so every
wake would plant evidence the next tick reads. That is the same
silence-amplification hazard the no-terminal rule exists to close.

The pull-request half of the collector now has a producer, which is the one thing
it lacked. pr_evidence previously read summary and comments off
MonitorState.last_observation, and canonical_pull_request_facts emits neither:
it carries twelve typed keys plus an optional pr_comment_body_digest, and the one
reader that sees PR-level comment bodies reduces each to a fixed-width fingerprint
by design. So a pull-request target yielded an empty list, judge_tick answered
FALLBACK, and FALLBACK fires -- which made arming a judge on a pull-request watch
strictly worse than not arming one, because the probe had already answered quiet.
render_pr_summary closes it by rendering those twelve keys into the one line a
judge reads. The rendering sits in the judge's own collector because that is its
only consumer: the canonical object's exact shape is pinned by full-dict equality
tests and hashed into the wake fingerprint, so a field added there to serve one
reader changes what every provider must emit, while a reading assembled from keys
the probe already published costs nothing and adds no egress class -- the
fingerprint is carried as a fingerprint, and no comment body text is read anywhere.
Comment-body screening is no longer claimed in the tool schema, the docs, this
description, or the point's own module header, and KIND_PR_COMMENT is gone rather
than left declared with no producer. What the judge adds over the probe on a pull
request is the owner's up-to-500-character criterion evaluated against typed state,
which is the thing a typed probe has no way to do. Two tests drive the renderer
from a real canonical_pull_request_facts projection rather than a hand-written
dict, which is the assertion this code lacked: a hand-written observation can agree
with its reader while the actual producer emits different keys, and that is exactly
how a collector reading absent fields passed every test it had. The design RFC
(rfc-wake-judge.md) is already merged and still describes comment-body evidence
in its collector section; that divergence is deliberate and belongs to a follow-up
rather than an edit to a merged design record from this PR.

Three findings on the previous revision were real and are fixed here, and one of
them reverses a call recorded above. A quiet verdict now AWAITS its durable write
and fires when the write does not land. The earlier revision scheduled that write
fire-and-forget on the reasoning that a lost write costs only a recounted quiet
streak; the adjudicator's later reading is the correct one, because suppressing a
turn is the irreversible direction and nothing afterwards says the turn was owed,
so the state a suppression rests on has to be on disk first. The read cursors, the
streak and the verdict record are all published in memory before that write, which
is exactly the shape the rule names. Every path on the judge tick now writes
durably; only the suppressing one changes its answer when the write fails.

The session read is bounded to what the collector retains. read_messages
defaults to twenty rows and reports next_since from the window it returned, while
session_evidence keeps only the last twelve -- so an unbounded page advanced the
cursor across eight rows that were then discarded and never read again, which is
where an actionable line sits when a worker posted several since the last tick.
Passing limit=MAX_ROWS_PER_TARGET makes the page and the retention the same
number, so a burst larger than twelve costs a later tick instead of losing its
oldest rows.

A pull-request reader now verifies its subject before answering. A loop holds ONE
monitor, so the reader returns that monitor's single observation whatever target it
is asked for, and the brief's targets are the owner's own strings: a brief naming
a second pull request was answered with the watched subject's state, labelled with
the name it asked for. A judge could then rule quiet on facts about a different
pull request. pr_observation_is_about accepts an identical string, or both sides
put through the same inference parse_targets already admits a target by, with the
host part of the identity since one slug on two servers is two pull requests. The
observation's own target and kind labels are checked too when it carries them.
Every doubtful case refuses, which drops the target, and a tick with no evidence
answers FALLBACK, which fires. Ten tests cover the matcher, including the
same-number-different-repository and same-slug-different-host cases.

A judge brief is credential-scrubbed at every entrance. The criterion is free text
somebody writes at arm time, and it lands in two places a secret must not reach: the
loop store on disk, and the loop serialization the dashboard reads. The brief already
passed a bound -- an allowlist of keys with a length limit per value -- and a bound is
not a scrub: it reads every value as opaque, so a criterion naming a bearer token was
kept whole and merely shorter. scrubbed_judge_spec puts the criterion strings and the
targets through the same credential scrubber the loop's message uses, and it is
called at all three entrances rather than once at the store, because a brief that
arrives on a tool call is published to the dashboard without ever passing the decode
path. The scrub runs BEFORE the clip: a redaction marker can be longer than the secret
it replaces, so clipping first would let a scrubbed value land over its own bound. A
clean forge URL and ordinary prose pass the scrubber unchanged, so no legitimate watch
can be broken by this; a target it does alter is one carrying the credential. Six tests
cover it, and the three that pin the criterion entrances fail when the scrub is replaced
by a passthrough.

Declined on this revision: a finding asked that the staged read cursors be persisted
with the verdict before being published in memory. Its adjudicator downgraded it as a
disproportionate remedy and that reasoning holds. The cursors serve only the judge's
own per-tick evidence; the transcript keeps the rows, each verdict is point-in-time and
a later tick re-judges on fresh rows, the quiet-streak floor forces a delivery so no
loop can be pinned quiet by it, and the event that cancels the tick is user input, which
fires a turn anyway. The remedy threads staged cursors through the closure and the tick
method as a new cross-module ordering contract, which reintroduces the re-read and
double-judge hazard the current ordering deliberately avoids. The residual is one
re-read of at most the retained window under a cancelled tick.

Findings addressed on the previous revision, with one declined. The evidence cap
lands AFTER the recency sort and counts what it sheds, because the collector's
input is target-grouped and chronological within each group, so a cap on the front
dropped the newest rows of the last target on exactly the busy ticks the point
exists for. The verdict count published to the notice and the verdict record is the
SCREENED count on every return path, including the FALLBACK ones, so neither
reports the pre-scrub input length. A read cursor refused as unaddressable is
cleared rather than held, so a rewound or trimmed transcript costs one tick instead
of blinding the judge to that target for as long as the loop is armed. A
pull-request row is aged from the monitor's last_observed_at, which is a sibling
field rather than a key inside the observation, so the reader hands it over
explicitly -- without it every such row ages 0.0 and silently defeats the
drop-oldest-first bound. The popover maps each verdict outcome to a localized word
and pluralizes its item count through i18next's own categories per language, so no
owner reads an English identifier or 1 items inside an otherwise localized line,
and it renders its time with the same formatter as the line above it, so two adjacent
times no longer read on different clocks. The two dropped counts -- unreadable
targets, and items the scrub shed -- have distinct names instead of one clobbering the
other in the calibration log. Declined: a review finding asked that the notice row be
written after the durable state rather than before. Its adjudicator downgraded it and
that reasoning holds -- the notice is emitted before the branch so it cannot be skipped
by an early return, the in-memory mutations never reach disk when the write fails, and
the residual is one visible contradictory transcript line under a rare I/O failure.

Rebased onto the merged #12776, which changes what this PR contains. That change
shipped the wake judge's LLM lane, so decisions/impl_llm.py now exists on the base
and owns decisions.nudge_wake.provider, llm_model, the Decisions card's
nudge.wake label and its judge provider/model selector, DECISIONS_NUDGE_WAKE_POINT,
and the translations-chunk budget. Every duplicate of those is dropped here and the
base's kept; this PR keeps what the base does not have -- the point module
(decisions/points/nudge_wake.py), the evidence collectors (autonudge_judge.py), the
tick hook, quiet_streak_floor, the nudge_evidence consent scope, the popover judge
line and its strings, and validation.py's brief bounds. The premise-level review's
blocker was this key's absent lane, and its own "clears when" names impl_llm
existing, so the rebase is what answers it rather than a deletion.

One of the base's own tests needed a narrow amendment, and it is not a weakening.
test_status_is_the_effective_answer_and_a_missing_scope_says_so compares the set of
points reporting needs_scope against the gate's scope table, and the judge's default
auto lane resolves to the small model when Jev is unarmed, so it is active rather than
held back: including it would assert a status the handler does not report. That
subtraction describes the projection rather than exempting the point from it.

test_every_scoped_point_is_inert_on_a_keystone_recording_no_scope asserts over EVERY
scoped point with no exception. The judge reaches it by pinning the lane whose authority
is the scope: that point carries two, and the small-model one needs no scope, so under
the default auto an unexempted assertion would be asserting the wrong question. With
jev pinned the point answers the question the sweep exists to ask -- a keystone that
recorded no scope leaves it inert -- and the sweep stays universal, which is the only
form in which it is a ratchet. A review finding named the earlier exemption and it was
right to: an exemption in a table-driven sweep is invisible to the next point added.

The card's own fixture merges the two behaviours rather than picking one: the row
declares the nudge_evidence scope this change registers, and the lane is derived the
way the gate's resolver derives it, from Jev being ARMED -- consent plus that grant.

The egress note counts FOUR categories again. Merging the base's catalog reverted it to
three, which is the understatement the card's own count ratchet exists to catch: the
note tells a reader what leaves their machine, and this change adds a category to it.
Restored in the English source with each of the eleven translations keeping its own
wording.

The restyle-ratchet record this branch carried is gone from it. #13008 landed the
identical record on main, so the gate passes on main's own baseline: 347 restyle sites in
50 files against a baseline recording 347 in 50, every file matching. Rebasing onto that
main reported the commit as already applied and skipped it, which is the same fact from
git's side. Dropping it also means the fix reaches every frontend branch instead of this
one alone.

Two module constants leave autonudge.py. A review finding named _JUDGE_SPEC_KEYS as
unread; its sibling _JUDGE_VERDICT_KEYS has the same single self-reference, so both go.
_bounded_judge_spec and _bounded_judge_verdict each spell their allowlist inline, which
is why neither constant had a reader. The numeric bounds beside them stay: each has a live
call site.

The design record specifies comment-body evidence that this point does not carry, and the
difference is deliberate. docs/request-for-change/rfc-wake-judge.md keeps pr_comment in
the closed kind set and a pr collector promising "new review/issue comment bodies since
the last tick", because it describes the full design. The shipped point registers
transcript_tail and pr_checks only, and pr_evidence carries the probe observation
alone: each PR-level comment body is reduced to a fixed-width pr_comment_body_digest and
none of the prose is retained, which is what the nudge_evidence disclosure promises the
owner. Adding comment text would widen egress past the category this scope was reviewed
under, so it needs its own scope and disclosure first. That subset is recorded in the RFC's
own preamble as of #13082, so this PR edits no design record to state it.

decisions.nudge_wake.quiet_streak_floor stays, against a review finding that reads it as
a knob with no named consumer and proposes deleting it. The RFC specifies it in section 5
-- the quiet streak "is compared against decisions.nudge_wake.quiet_streak_floor
(clamped, never off)", and "Owners watching public repositories should set a lower floor."
-- and its rollout section assigns the decisions.nudge_wake.* keys to this PR. The
consumer the finding calls missing is named there, so deleting the key would take the
change out of conformance with the design it implements. Cited by section rather than by
line, because #13082 reflowed the document.

pluralKeys.json carries its two new entries and nothing else. A regeneration had
re-sorted the whole file, pulling about twenty entries that belong to other branches into
this diff; the registry is read as a Set, so the ordering buys nothing. The fr.json
nesting_depth value is likewise back to the base's escaped spelling -- that line is not
this change's to re-encode.

The popover's judge line has a render test at the widest criterion the arming surface
admits (500 chars), which is the shape half of a review finding. No clamp is added: the
popover clamps nothing anywhere, so the row carries its siblings' type contract, and a
clamp on this row alone would be a visual change no reviewer has seen. A capture of the
line in its verdict and no-verdict states is the other half, and it is not in this PR.

A brief is not what arms the judge. Once nudge_evidence is granted every GATED
loop is screened on every tick, and one naming no criteria of its own runs under a
default brief: wake when "the subject needs its owner: a blocker, a question or
ruling addressed to it, a terminal state, or the loop message's own exit
condition", quiet when "nothing new for the owner since the last tick". The loop's
instruction was already the tick's context, so that default reads the loop's own
exit condition without restating it. Requiring a brief per loop made the saving
opt-in, and the loops that need it most are armed by agents mid-task with no reason
to spend the argument.

An explicit brief overrides the default, and one naming only targets keeps them
while taking the default's sentences -- which is why the branch keys on the
CRITERIA being absent rather than on the brief being empty: targets says which
subjects to watch and nothing about when to wake. The default is never written back
onto the loop, so the stored field stays a record of what the owner asked for, and
granting them a criterion later is still an empty-to-set change rather than an edit
of shipped text.

That last property is load-bearing rather than tidy. The mid-tick guard that
discards a verdict when the brief was REPLACED under it compares a re-read against
what was STORED, never against the spec the tick ran under: those differ on every
default-brief tick, so comparing the merged form would report a replacement nobody
made and throw away a good verdict every time.

Two bypasses, and they mean different things. A gate=false loop is never
screened, because its duty is to act WHILE its subject is quiet -- a heartbeat, a
reviewer chase -- so suppressing a quiet tick would remove the work rather than the
waste. judge: false is an owner who wants observation gating and no judge; it
normalises to a reserved marker that is deliberately absent from the accepted key
set, so the boolean is the only spelling a caller has and {"off": true} by hand is
refused as unknown. An empty object is neither of those: it drops the owner's own
criteria and the default applies, so both monitor tool descriptions were corrected
where they said an empty object removes the judge.

The transcript notice names which brief a verdict was reached under, default or
custom, because a quiet reached under shipped text is not evidence that the
owner's own sentence works and a wake under it is not their sentence misfiring.

Default screening asks a NARROWER authorization question than an armed brief does,
and the difference is the point of it. is_enabled answers "could any lane serve
this tick", which the LLM lane satisfies on the provider key alone --
gate._judge_authority documents provider = llm plus a judge spec on the loop
as that lane's whole authorization, so the owner's brief is HALF of it. A loop whose
owner armed nothing supplies no such half. So the default path calls
gate.judge_evidence_scope_granted instead: the endpoint consent read AND this
point's own nudge_evidence scope, composed from the same two primitives
_judge_authority uses rather than a second rule. With that scope off, a loop
carrying no brief is left exactly as an ungated timer, which is what makes "scope
off changes nothing" true rather than aspirational. An explicitly armed brief is
unaffected and still runs on either lane.

This revision edits NO design record, which is worth stating plainly because an
earlier revision did. docs/request-for-change/rfc-wake-judge.md is untouched by
this branch. Default screening is ratified there by #13082, merged
2026-09-23T22:54Z, which takes the document past draft and states the shape this PR
ships, including the untrusted-evidence clause, why nudge_evidence stands in for a
brief a loop never wrote, and where the judge sits relative to the typed probe. This
branch's own RFC prose was withdrawn in favour of that text, so the design record is
single-sourced and the open maintainer question earlier flagged here is closed.

A structured monitor now REFUSES a judge brief instead of dropping one. The schema
offers judge on every monitor_update, so arming a structured monitor with
monitor_watch and then sending a brief is two ordinary steps -- and
_structured_monitor_update neither stored the field nor refused it, so the owner
got a success acknowledgement for a criterion that was never armed while every tick
kept firing on the typed probe alone. Nothing in the acknowledgement would have told
them. judge joins banner in that path's refusal set, which exists for this exact
shape: a message-loop-only field that a structured monitor has nowhere to put. Two
source-level tests pin it, and removing judge from the set fails the first of them
by name.

One review finding is recorded as declined rather than fixed, on the adjudicator's
reasoning rather than mine. The judge notice and the in-memory cursors are published
before the durable write, so a QUIET verdict whose write fails emits a notice that
contradicts what was stored, and a cancellation mid-judging can leave an advanced
cursor live for one tick. The adjudicator confirmed every condition and then measured
the remedy: _persist_locked serializes the live loop, so staging and persisting
atomically needs either a rollback snapshot of three fields plus a new cross-module
return contract for the injected collector, or shielding a multi-second model call
from the cancellation that exists precisely so a nudge never races a human turn. The
degradation it buys against is bounded and self-correcting -- no transcript rows are
lost, only the judge's read window skips them, a failed QUIET write fires anyway with
a warning, the quiet-streak floor forces delivery so nothing can be silenced
indefinitely, and a restart reloads the un-advanced persisted cursors.

One unread target now fires the tick whatever the readable ones produced, and the
earlier shape of that rule was wrong. The blind-tick check sat INSIDE the empty-delta
branch, so it was only consulted when no target had produced anything. A tick with
one refused target and one talkative one has a nonempty delta, never reached that
branch, and could answer a confident QUIET about the target that WAS read --
suppressing the turn the unread one might have needed, under exactly the condition
the feature map says fires. The check is hoisted above the delta, which is what the
rule always meant: FALLBACK is for a collector or provider failure, and a target the
collector could not read is one however much the others said. A test pins the
mixed case, and removing the hoisted guard fails it by name alongside the
empty-delta one.

A stale comment on the update path went with it: it said an empty object takes the
judge off a live loop, which is the pre-default meaning. It now says what the code
does -- {} clears the owner's own criteria and a gated loop then runs under the
default, while judge: false is the opt-out.

The target cap now counts what it omits. collect_evidence slices the target list at
MAX_JUDGE_TARGETS, and dropped started at zero, so a message naming one target
more than the cap allows read as a COMPLETE reading: a confident quiet about the
targets that fit could suppress a turn the omitted one might have needed. That is the
same fault as an unreadable target, reached through a bound instead of a failure, so
it now seeds the drop count and the hoisted guard fires on it. A test pins it and
fails when the initialiser goes back to zero.

The judge notice is now published AFTER the write it describes, and the tick takes one
exit instead of four. The notice went out first so that no early return could skip it,
which is a real requirement and the reason the reorder needed the exits collapsed: the
verdict is rendered where it was, the four branches carry their answer in a variable,
and one publish at the bottom serves every path -- including the one that fires
BECAUSE the write failed, where the reader most needs to know why.

Two faults close with it. A notice emitted before the persist is a claim about state
that may never land. And the emit is an await, so a brief replaced during it was
committed against afterwards: the streak and the verdict record would belong to
criteria nobody armed. There is now a final look at the stored brief immediately
before anything is committed, so a brief revised at any point up to that line
discards the verdict and fires. Four tests pin the ordering on the quiet, wake and
failed-write paths and the discard on the replacement path; putting the publish back
above the commit fails three of them with the trail reversed.

Rendered states, and which ones have no capture

Written out rather than left to a reviewer's inference, because two review lanes ask
for frames this revision cannot produce. The attached image above is current and
covers the consent surface; every popover and transcript state below is described
from the shipped strings, and the ones with no frame say so.

COVERED by the attachment: Settings -> Developer -> Decisions, showing the
nudge.wake row, the nudge_evidence switch, and the egress note counting four
categories. That frame still matches this revision's card copy, with one difference
worth naming: the switch description no longer ends in a state sentence, so the frame
shows one trailing sentence the current build omits.

NOT COVERED, popover judge row (data-testid="judge-line", AutoNudgePopover.tsx),
six states:

State Renders
wake-sense brief Judge: wake when {criterion}
quiet-sense brief Judge: stay quiet while {criterion}
no verdict yet criterion, then no verdict yet
timed verdict criterion, then last: {outcome} / {count} items / {time}
untimed verdict criterion, then last: {outcome} / {count} items
no row at all a loop with no criteria of its own, or judge: false

The separator between those segments is a middle dot, and {outcome} is one of
quiet, waking, finished, could not judge, unknown. The row carries its
siblings' text-muted text-[11px] contract with no clamp, so a criterion at the
arming bound of 500 characters wraps rather than truncating; a test pins that it is
carried whole, which is the shape half of the question and not the rendered half.

NOT COVERED, transcript notice row: one line per verdict, reading
Wake judge / {outcome} ({default|custom} brief) / {question} {answer} {p} ... / {n} evidence item(s), again middle-dot separated. The (default brief) and
(custom brief) variants are new in this revision and have never been captured.

NOT COVERED, the two bypasses, neither of which draws anything: a gate=false loop
and a judge: false loop are never screened, so they show no judge row and emit no
notice. Their absence of UI is the correct rendering and is asserted by tests rather
than shown.

WHY there is no capture: a capture needs a pod whose backend and bundle both carry
this revision. The pod that produced the attached frame booted hours earlier and its
served bundle does not contain this revision's popover code at all. A fresh pod was
provisioned and booted correctly at this head, but no token could be minted for it
from the agent sandbox -- the gateway requires unix-socket admission on
/api/token/local and no socket is exposed in its run directory, so the pod answers
/api/health and refuses every authenticated call. That is tracked as #12958. The
pod has since been released rather than left holding a port.

A reviewer should read every row above as UNILLUSTRATED rather than approved.

An owed judge wake now survives the fire not happening. The judge advances DURABLE
read cursors before it decides, so a verdict that says fire and a process that stops
before the fire leave the next tick reading nothing new: it answers quiet and
suppresses the very turn that was owed, until the streak floor several intervals
later. judge_wake_pending is set with the verdict's own write, so the flag and the
advanced cursors land together, and the next tick delivers the turn WITHOUT asking the
judge again -- asking would re-read the same emptiness and reach the same wrong
answer. It is cleared at the single point delivery is confirmed.

The flag lives on the loop rather than on MonitorState, and that is the substance
rather than a detail. The probe path already carries this doubt across a fire as
poll_in_flight, and a refused fire already re-owes its claim and grants a
followup_ticks bypass -- but every one of those sits behind monitor is not None,
and a judge-only loop (a conductor watching sibling sessions) has no monitor record at
all. So the loops the judge exists for were the exact loops none of it covered, and a
REFUSED fire lost the turn the same way a crash did. Keeping the flag on the loop
covers both, and leaving it set until delivery settles is what makes a refusal re-owe
rather than drop.

The new field is WITHHELD from a structured monitor's legacy REST row. That route's
key set is pinned in both directions -- withheld plus published must cover every loop
field -- precisely so a new field has to answer the entitlement question rather than
joining the route by existing. judge_wake_pending is a bare boolean naming nothing,
so it could have been published; it is withheld for the reason judge_quiet_streak
is, that this route holds a structured monitor to the stricter line. A plain loop,
which is the one with a popover to render, still gets it from _serialize.

A lost clear costs one extra fire, which is the direction to be wrong in, and the
loader resolves a non-boolean value to "delivered" for the same reason: a corrupt row
in an agent-writable store must not make a loop fire forever without consulting its
judge. Five tests cover the set on wake and fallback, the absence on quiet, the owed
turn delivering with no evidence re-read, and the load default; removing the set fails
two of them.

Two faults share one cause: the judge's TARGETS come from loop.message, while its
criteria come from the spec, so a message-only retarget changes what is being judged
without touching the spec at all.

Cursor retention is now bounded where it is written. The collector only ever adds a
key, so a retarget left the departed target's cursor in the map and asdict persisted
it on every write. The load cap was not a bound on that: it keeps an arbitrary 16, so
it could discard the cursor of a target still being read, and a lost cursor replays
rows the judge already screened. Pruning to the targets each tick actually reads makes
the population exactly the current targets, so the two bounds that disagreed -- 16
cursors against 8 targets -- collapse into the smaller one and the cap never binds.

Both mid-tick fences now compare the message as well as the spec. They existed to
discard a verdict whose brief was replaced mid-tick, but comparing the spec alone let a
retarget through with the spec byte-identical, committing a QUIET verdict reached
against the previous target and suppressing the new target's due turn on a streak it
never earned. The test drives the real tick and retargets during the await; removing
the message half of either fence fails it.

Also corrected the quiet_streak_floor help text, which promised that many skipped
turns. The Nth consecutive QUIET tick fires regardless of its own verdict, so the
number yields one fewer skip than it read as. Baseline regenerated.

quiet_streak_floor is now downward-only, which is what the RFC always meant. Its
section 5 pins the knob as "clamped, never off" and tells owners watching public
repositories to "set a lower floor", but the engine clamped
at 50 against a shipped floor of 10, so it could be configured five times UPWARD --
37.5h of silence at a 45-minute interval against the RFC's 7.5h worst case. The threat
that makes this matter is the one the code's own docstring names: config.json is
agent-writable, so a raised floor silences a watch with no new code, only a number. No
user of the 11-to-50 range was named in the RFC, the help text or this description.

The shipped floor is now itself the ceiling, so a larger value is clamped back down to
it and the knob can only ever shorten the silence window. _JUDGE_QUIET_STREAK_FLOOR_MAX
is deleted rather than lowered, because a second constant invited the two to drift. The
help text said "a value above the engine's ceiling"; it now states the downward-only
rule, and the baseline is regenerated. Restoring the 50 fails the clamp test at
assert 50 == 10.

Naming targets now narrows the watch even when nothing in the list survives filtering.
Previously an owner who named one target and mistyped it fell through to the
message-inference default and got the message's subjects instead -- a WIDER watch than
the one they asked for, reading transcript evidence from a session they never named. The
fallback's own comment said "nothing explicit", but something was: the list simply
emptied during filtering.

Answering no targets is the safe direction and is why this is a small change rather than
a risky one: a spec naming no usable target fires the tick rather than suppressing it, so
a dropped list costs a turn every interval and never silence. An absent targets key is
still distinct from an empty one and still infers from the message, which is the default
the design asks for. Reverting the condition fails two of the five new tests.

Rendered evidence: the popover judge row, all seven states

Popover judge row in seven states, rendered against this revision built stylesheet

Attached rather than committed: .gitignore records the repository's rule that review evidence is uploaded with gh pr edit --attach and never committed, and the design and UX lanes read attachments through .github/scripts/pr-attachment-evidence.sh as well as the committed diff.

The popover judge row in all seven states, rendered in Chromium against THIS revision's
built stylesheet. Pod-based capture stayed blocked (#12958 -- the gateway wants
unix-socket admission on /api/token/local and the sandbox has no socket), so this is a
component-level capture instead, which needs no pod and no token. The row's markup is the
judge-line JSX from AutoNudgePopover.tsx; the styles are dist/assets/src-NpXWYNsL.css
built from this head; the column is the popover's 340px. The harness reads the computed
style back before shooting and it reports font-size: 11px and color: rgb(127,127,136),
which are the bundle's .text-[11px] and --muted: #7f7f88 resolving -- so the frame is
evidence of the real utilities, not of the harness's own CSS. That check earned its keep:
the first attempt linked the stylesheet by file://, which silently did not load, and the
probe caught a 16px unstyled frame that would have looked like a render.

The capture found a real defect, now fixed. A criterion at the arming bound with no
space in it -- a URL, a sha, a pasted blob -- did not wrap. It ran off the popover
horizontally, because the row carried no break rule. break-words is added, and the
seventh frame shows a 500-character unbroken token wrapping inside the column. The
frontend test that covers this row already used 'w'.repeat(500), the exact input that
overflows, but asserted only text and font size; it now pins the break rule too, and
removing the class fails it with expected 'text-muted text-[11px]' to contain 'break-words'.

Wrapping rather than clamping, deliberately: the row shows the whole criterion so an owner
can confirm what they armed, and a clamp would hide the tail of a brief they are trying to
read. The sixth frame shows 487 characters of ordinary prose wrapping to nine lines, which
is what an owner actually meets.

The quiet-streak floor now owes its turn too. That branch FIRES, so it needed the same
owed-wake marker the wake branch carries, and it was the one firing path the marker
missed. The loss there is the silent kind: the branch persists a streak reset, so a
refused delivery or a process that stops leaves the next tick re-judging against durable
cursors, finding nothing new, answering quiet, and pushing the forced turn out another
whole floor with nothing recording that one was due. The monitor path's re-owe and its
gate-free retry both require a monitor record, and a judge-only loop has none, so this
flag is the only thing covering that case. Removing the line fails the new test at "and
the turn it owes survives a refusal".

Read positions now move only with a verdict. The collector used to assign
loop.judge_cursors as soon as it had read, which is before anything is judged, and the
judge await that follows is cancellable -- a user typing cancels exactly that task. So a
tick could consume rows for a verdict that never committed: the next tick read nothing
new, answered quiet, and the wake those rows had earned was gone until the streak floor,
with nothing recording it. No disk failure needed, which is why this one is reachable in
ordinary use.

The collector returns the advanced map as a third value instead of publishing it, and the
tick holds it until the single commit point, beside judge_last_verdict. Every path that
leaves earlier -- a cancelled await, a brief replaced mid-tick, a retargeted message --
now leaves the stored cursors exactly as they were, which is right: a tick that reached no
verdict consumed nothing. Two tests, and publishing right after collection again fails the
cancelled-await one.

This was a callback contract change, so the nine collector stubs in the judge suite moved
to three values. The four session-reader stubs did NOT: their contract is still
(rows, next_cursor), and an earlier sweep that widened them by mistake made one test pass
for the wrong reason -- the bad unpack counted the target as dropped, which was what that
test asserted -- so the readers are pinned back to two values deliberately.

Design: docs/request-for-change/rfc-wake-judge.md (#12735). The LLM lane and
impl_llm.py shipped in #12776, which is merged, so this PR now sits on top of it.
Feature preview, default off.

Two findings on the rebased head, both real and both fixed

The feature map's Developer row contradicted its own Monitor loops row. The Monitor
loops row states the judge is active; the Developer row still read "A seventh point,
nudge.wake, is REGISTERED here but fired by nothing yet ... this build ships the lanes and
the two settings while no tick is gated". That sentence described the build before this one.
It now says the point FIRES on the tick and names what arms it, which differs by loop: a
loop whose owner wrote a brief is screened on the lane's own authority, while a gated loop
that wrote none is screened only once nudge_evidence is granted, so an install with
neither still gates no tick.

Three more gaps in the same row, found by sweeping it rather than by fixing only the
sentence quoted: nudge_evidence appeared nowhere in it, so the row enumerated the
consent endpoint's scopes as tool_args, compaction and memory_text while this PR adds
a fourth to the same keystone. It now carries that scope's own paragraph on the terms the
row already uses for its siblings -- what category it sends, its keystone key, its reader,
absent-reads-as-no, the map and the refusal -- plus its switch, and says why compaction
does not imply it: that yes was reviewed as a transcript of the session its owner was
present for, while this one carries a different session's tail and a comment body written
by a bot on a forge. The endpoint column names it, and the backend column names
decisions/points/nudge_wake.py with autonudge_judge.py beside the sibling points it
already listed.

A judged pull-request watch armed from a loop message never received its evidence.
pr_observation_is_about decided whether the loop's single observation is about the target
being asked for, and when the two strings differed it inferred BOTH sides and compared the
identities. But infer_monitor stores the CANONICAL subject (owner/name#123) with the
inferred kind (gh-pr), and that shorthand carries no host by design, so inference declines
it. The watched side therefore inferred to nothing, the comparison could not succeed, the
target was dropped, the drop was counted, and the tick answered FALLBACK -- which fires. So
every gated loop whose subject is a pull request named in its own instruction paid a full
turn on every interval, which is exactly the waste the point exists to remove, and it failed
silently because firing is the safe direction.

Two stored shapes exist and both now work. monitor_watch stores the caller's own canonical
URL, which the existing string and inferred-identity comparisons already cover;
infer_monitor stores the shorthand, which a third comparison covers by testing the
inferred kind and subject against the pair the monitor is bound to. That third
comparison needs no host of its own: the inference pins exactly one host and refuses any
other, so for a subject it admits at all, kind and subject are the whole identity.

The reason the tests did not catch it is worth recording, because it is the same failure
this description already notes for the observation dict. The existing class hand-wrote the
watched side as the full URL and the kind as github_pull_request, so every case ran on two
values neither producer emits and passed on the exact-string shortcut. The new class takes
both fields from a real MonitorState built by infer_monitor, asserts the premise that
the stored subject is the shorthand and that inference declines it, and then drives the
check with the targets parse_targets actually yields for that message. Removing the third
comparison fails test_the_target_the_message_yields_is_accepted by name.

Rendered evidence: the transcript notice row, both brief variants

Transcript notice row in four states including both brief variants

Attached rather than committed: .gitignore records the repository's rule that review evidence is uploaded with gh pr edit --attach and never committed, and the design and UX lanes read attachments through .github/scripts/pr-attachment-evidence.sh as well as the committed diff.

The UX lane's remaining evidence gap was the transcript notice row, in both the default-brief
and custom-brief variants. This frame closes it, by the same pod-free route as the popover
capture, so #12958 does not block it either.

The row is not a component this PR adds: a judged verdict is written with
append_and_surface(state, slot, "notice", text, "msg msg-info"), the same surface a refused
arm uses, and the dashboard draws it with the existing NoticeCard. The frame therefore
mirrors NoticeCard.tsx exactly -- the outer div[data-testid=notice-card][data-tone=info]
with its ring-1 ring-inset ring-border bg-card text-muted classes, the inner flex row at
text-[13px] leading-5, lucide's own info glyph at size 13 read from
node_modules/lucide-react/dist/esm/icons/info.js, and the span.min-w-0.break-words that
holds the line. A judge notice carries no emoji prefix, so parseNotice yields tone info
and srSeverity('info') is empty, which is why no screen-reader severity span appears.

The four lines are not hand-written. Each is the verbatim return of
decisions/points/nudge_wake.py::notice_line for its case: quiet under the shipped default
brief, quiet under the owner's own brief, a wake, and a fallback with no answers at all. The
two quiet lines differ only in (default brief) versus (custom brief), which is the whole
point of that segment -- a quiet reached under the shipped default is not evidence that the
owner's own sentence works.

The harness reads the computed style back before it shoots, for the same reason it earned its
keep on the popover frame: it reports color: rgb(127, 127, 136), background-color: rgb(24, 27, 34), border-radius: 8px and an inner 13px / 20px, which are --muted,
--card, rounded-md and text-[13px] leading-5 resolving out of this revision's built
stylesheet rather than anything the harness supplies. The column is set to a 720px transcript,
so the wrap in the frame is the wrap a reader sees.

The UX lane's four Watch items

None is a defect in this diff and none is taken here, so each is recorded rather than left for
a reader to rediscover. Three are copy decisions across 13 locales -- the "Jev" versus "Judge"
naming, the judge_outcome_terminal: "finished" wording, and localizing the notice line, which
is deliberately hardcoded English today because it carries identifiers and probabilities rather
than prose. Inventing twelve translations is worse than one consistent English source handed to
a translation pass. The fourth is visual: the scope switch wants indenting or grouping under the
row it belongs to, which is a Decisions-card layout change affecting every point's panel rather
than this point's.

The pull-request collector has no producer yet, and the screen stays out of its way

A judged loop is a GATED loop -- _judge_tick_is_quiet returns None for anything else on
its first two attribute reads. The canonical observation the pull-request collector reads has
exactly ONE writer, apply_monitor_probe on the structured controller's path, and a gated
loop never reaches it: it observes through irq.poll, whose Verdict carries an outcome,
prose and terminal keys, and no canonical facts. So MonitorState.last_observation is {}
for every loop the judge screens.

What that empty reading MEANS depends on whether anything read the subject, and a drop says
"nobody looked". On the gated path the judge is asked only after the typed probe's own verdict
came back quiet, so the subject was read, by the very reader the judge was called to
supplement. autonudge_judge.pr_target_is_unread is that rule: with a probe behind it a
factless reading is not a drop, it contributes nothing, and the probe's free re-arm stands
exactly as it does on a build with no judge at all. With no probe behind it -- a loop carrying
no monitor, a spent watch, a brief naming some other pull request -- it is an unread target
and fires, which is the direction every unreadable input here resolves toward.

Getting that wrong in either direction is a real cost, and both reviewers named one. Counted
as a complete reading it is the no-evidence/no-drop shape a QUIET verdict is built on, so an
owner's criterion could never evaluate and they were told nothing about why. Counted as unread
it is a FALLBACK: a turn, a durable persist and a notice row every interval for the life of
the watch, against one turn per streak floor without any judge -- the screen inverting its own
purpose for the commonest gated loop there is. Deferring to the probe's quiet is the only
answer that is true about what happened.

Two tests pin it. pr_target_is_unread is asserted in both directions, and making it
unconditional fails test_a_reading_is_unread_only_when_no_probe_covers_the_subject by name.
At the tick level, a screened pull-request loop whose collector returns no evidence and no
drop answers QUIET, with its unread-target control beside it, so the free re-arm is pinned
where the turn is actually spent.

Threading real facts out of the kernel is deliberately NOT in this PR. The canonical shape is
built by the monitoring providers from their own fetch (review threads and a REST check
pass the gh pr view probe does not make), so a gated producer means either a second
subprocess per tick or a port of that provider, against a field whose exact shape is pinned
by full-dict equality and hashed into the wake fingerprint. The collector stays wired,
rendered and tested against that shape and gains a producer when a gated tick publishes one;
docs/feature-map/README.md states this rather than claiming the capability.

judge_quiet_streak is also gone from the frontend. It was parsed in automation.ts, typed
on AutoNudgeLoop and carried back by the popover, and no surface rendered it -- judgeReading
never read it. The backend field stays, because it is what the quiet-streak floor counts.

@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Sep 22, 2026
@github-actions

github-actions Bot commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — 🟡 CONCERNS

Premise-level review of 34483d00fb2c161a48864c6558592dfc2344fe34 — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

Default-brief screening ships one answer to a question its own RFC still records as unresolved (Q4: which switch authorizes a briefless loop on each lane).

Not justified as shipped

  • Item 3 — inherited: rfc-wake-judge.md (base status partial) covers this shape but marks its authorization open — §7 Q4 is "Unresolved" and §8's rollout entry for this very PR says "Blocked on Q4: which switch authorizes a briefless loop on each lane is undecided" — while the diff ships the choice that nudge_evidence (whose recorded wording names the Jev endpoint) licenses default-brief screening on the LLM lane too.
    Clears when: the base RFC records Q4 settled for the shape shipped here (then push or rebase), or a maintainer records /ai-review override first-principles 34483d00fb2c161a48864c6558592dfc2344fe34: <decision>.

What this change ships

Inventory (10 items) — 9 justified

Intent: stop each gated auto-nudge tick from spending a full main-session turn when a cheap typed judge can read the new evidence and say nothing needs the owner — an ADDITION, covered by rfc-wake-judge.md (partial on base, naming PR #12787).

  1. A gated loop's tick is screened by a wake judge; a quiet verdict spends no turn — justified
  2. judge brief (wake_when/quiet_when/targets) on monitor_start/monitor_update and POST /api/autonudge; false bypasses, {} clears — justified
  3. Once nudge_evidence is granted, every gated loop is screened under a shipped default brief — inherited: the covering RFC records the deciding question (Q4) as unresolved
  4. New keystone consent scope nudge_evidence with its own switch on the Decisions card — justified
  5. New config key decisions.nudge_wake.quiet_streak_floor, downward-only, clamped on every read (1 consumer counted: autonudge.py:5408) — justified
  6. Every verdict writes one text-free notice row on the owning session — justified
  7. AutoNudge popover shows the brief and the last verdict — justified
  8. Five new persisted loop fields (brief, cursors, streak, owed-wake flag, last verdict); cursors withheld from every projection — justified
  9. Consecutive quiet verdicts are floored at the probe's own _MAX_QUIET_STREAK, so prose can never buy silence past it — justified
  10. Feature-map and Decisions-card doc rows updated in the same commit; locale strings added — justified

[FIRST-PRINCIPLES-REVIEWED] 34483d0

@github-actions

github-actions Bot commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ✅ no blocking findings (all downgraded on adjudication)

GPT 5.6 flagged blocking issues on 34483d00fb2c161a48864c6558592dfc2344fe34; Opus 5 adjudication downgraded every one of them to advisory. Adjudication downgraded all 1 blocking finding(s) to advisory: the remedy each one requires is disproportionate to the harm it prevents. Read them as advice, not as merge conditions.

This comment is updated in place on each push.

Review details

BLOCKING -- src/kiro_crew/autonudge.py:5396 -- Judge state is published before persistence succeeds (origin: validation)

loop.judge_cursors = staged_cursors
State-write failure -> live cursors/verdict/streak remain advanced -> later ticks skip evidence that a restart reprocesses.
Anchor: persist-before-you-publish
Fix: Stage or snapshot these fields and publish them only after a successful write; restore them before firing on failure.
[BLOCK-MERGE-DOWNGRADED] 34483d0
[GPT-REVIEWED] 34483d0

Adjudication (Opus 5) — is blocking on each finding proportionate?

LOW — divergence is bounded and resolves toward spending a turn, never suppressing one; the failure is logged at autonudge.py:5503.
Conditions confirmed: the durable write must raise (autonudge.py:5501-5508 returns False); in-memory cursors/verdict published at autonudge.py:5396-5397 and streak at 5407/5439 before that write.
Recovery: every persist-failure path fires — the quiet branch checks the result and falls through to answer=False (autonudge.py:5430-5434, returned as "fire" at 5543-5544), the floor and wake branches fire and set judge_wake_pending (5423, 5445) which forces delivery without re-judging (5234-5243); so the rows whose cursors advanced were consumed by a real turn, making a restart's re-read the harmless direction the code documents at 5398-5404, and the streak skew moves the forced floor earlier (one extra turn), not later. Real fix cost: snapshot-and-restore of three coupled fields with a rollback branch at each of three persist sites, a new ordering contract between collector, verdict publish and write existing solely for the write-failure path, and permanent reader load explaining why published state gets un-published — all to buy a duplicate re-judge of evidence a turn already delivered.

[ADJUDICATION] 34483d0 total=1 uphold=0 downgrade=1
DOWNGRADE F1 src/kiro_crew/autonudge.py:5396 reason=disproportionate-remedy
[GPT-ADJUDICATED] 34483d0

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 34483d00fb2c161a48864c6558592dfc2344fe34: <one-sentence reason>

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 22, 2026
@github-actions

github-actions Bot commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — 🟡 CONCERNS

Design-level review of 34483d00fb2c161a48864c6558592dfc2344fe34 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: CONCERNS

A judge brief naming pull-request criteria is armed, stored, and shown active while no gated tick can ever produce the facts it would evaluate.

Watch

The description's final section states the canonical PR observation "has exactly ONE writer" that "a gated loop never reaches," so MonitorState.last_observation is {} for every screened loop — yet monitor_start accepts a PR-criterion brief, the popover renders Judge: wake when <criterion>, and the collector silently defers to the probe's quiet. An owner who arms "wake when a maintainer requests changes" gets an inert criterion with only docs/feature-map recording why; the earlier description section still claims render_pr_summary "closes it," which no longer holds at HEAD.
Clears when: the arming surface or popover marks a PR-only criterion as pending a producer (or refuses it), or the gated-tick canonical-facts producer lands.

Suggestions

  • Collapse the description to the state of HEAD before merge; the append-log format leaves superseded claims ("now has a producer") standing above the sections that reverse them, and the merged PR body becomes the archaeology.

[DESIGN-REVIEWED] 34483d0

@github-actions

github-actions Bot commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5 Review — ✅ no blocking findings

Reviewed 34483d00fb2c161a48864c6558592dfc2344fe34 — this comment is updated in place on each push.

Review details

No findings.

FINDING — src/kiro_crew/autonudge_judge.py:485 — a session target whose page comes back full at limit=MAX_ROWS_PER_TARGET advances its cursor with a backlog still behind it while collect_evidence reports dropped=0, so judge_tick answers "wake judge: no new evidence since the last tick" QUIET (no model call at all when the page holds no assistant row) and suppresses the owed turn until the quiet-streak floor → Fix: in the session branch, count a full page as an unread target (if len(rows) >= MAX_ROWS_PER_TARGET: dropped += 1) so the tick returns FALLBACK instead of a confident QUIET.

[OPUS-REVIEWED] 34483d0

Verdict parsed from the review's SHA-scoped output markers for commit 34483d00fb2c161a48864c6558592dfc2344fe34.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 34483d00fb2c161a48864c6558592dfc2344fe34: <one-sentence reason>

@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention merge conflict Branch has merge conflicts with its base — author must resolve before merge and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 22, 2026
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running merge conflict Branch has merge conflicts with its base — author must resolve before merge labels Sep 22, 2026
@chenmingwei23
chenmingwei23 marked this pull request as ready for review September 22, 2026 16:01
@chenmingwei23
chenmingwei23 requested review from a team and smeyffret September 22, 2026 16:01
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 22, 2026
@github-actions

github-actions Bot commented Sep 22, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Fable 5) — 🟡 CONCERNS

UX-level review of 34483d00fb2c161a48864c6558592dfc2344fe34 — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

UX-Verdict: CONCERNS

One feature answers to three names — "Jev" on the consent switch, "Judge:" in the popover, "Wake judge" in the transcript — and the blind reader could not connect them.

Watch

  • Naming split: the card grants "so Jev can skip a turn", the popover says "Judge: wake when…", the notice says "Wake judge"; the reader: "these feel like the same helper described under two different names… A new person would not know they are one thing." Every scope-granting user hits it, friction, permanent. Fix: one name across decisions_nudge_evidence, judge_wake_when/quiet_while, and notice_line.
  • Vocabulary drift between the two verdict surfaces: popover renders fallback→"could not judge", wake→"waking", "items"; the notice writes "fallback", "wake", "evidence item(s)". The reader "cannot tell… whether they are two views of the exact same thing or two different things." Fix: reuse the popover's outcome words in notice_line.
  • The notice row puts needs_owner, progress_only and bare decimals ("quiet 0.92") into the transcript on every judged tick; the reader had "no idea what 'needs_owner' means or whether 0.64 is good or bad." One row per tick, permanent noise. Fix: plain words for the two question names, or drop the probabilities from the transcript line (they already live in the decisions log).

Suggestions

  • A gated loop screened under the default brief draws no judge-line, so its popover is indistinguishable from a plain timer while a judge suppresses its turns; add a non-echoing state line (e.g. "Judge: screening with default rules") to AutoNudgePopover.tsx.

[UX-REVIEWED] 34483d0

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 22, 2026
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Sep 23, 2026
@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ⚠️ review incomplete

GPT 5.6 did not produce a complete verdict for b43307d4714e1fd28ff610c1f5ede4cf54aa1eba; inspect the workflow logs and re-run it.

This comment is updated in place on each push.

See the GPT 5.6 Review job logs; this commit has no completed GPT verdict.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt b43307d4714e1fd28ff610c1f5ede4cf54aa1eba: <one-sentence reason>

1 similar comment
@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ⚠️ review incomplete

GPT 5.6 did not produce a complete verdict for b43307d4714e1fd28ff610c1f5ede4cf54aa1eba; inspect the workflow logs and re-run it.

This comment is updated in place on each push.

See the GPT 5.6 Review job logs; this commit has no completed GPT verdict.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt b43307d4714e1fd28ff610c1f5ede4cf54aa1eba: <one-sentence reason>

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ⚠️ review incomplete

GPT 5.6 did not produce a complete verdict for e4bffb63bf63f348c5ea45f2babd8189a845b0a3; inspect the workflow logs and re-run it.

This comment is updated in place on each push.

See the GPT 5.6 Review job logs; this commit has no completed GPT verdict.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt e4bffb63bf63f348c5ea45f2babd8189a845b0a3: <one-sentence reason>

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — 🔴 changes requested (blocking)

GPT 5.6 found at least one blocking issue that must be resolved before merging ee1df06a8c3acb2ac39ebb59036c4d875b0790dd. Adjudication produced no [GPT-ADJUDICATED] marker for ee1df06: the adjudication stage FAILED TO RUN (its raw output is in the Adjudication details block -- typically an API or setup error), so no proportionality review took place and GPT's blocking verdict stands unreviewed.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/dashboard/channel_slots.py:1543 -- Folder backfill can recreate a deleted conversation
log.update_metadata_if, key, filing_meta, needs_backfill_filing
Deletion after candidate scan -> empty metadata passes the guard -> metadata upsert recreates a foldered transcript stub.
Anchor: residual/guard-removal
Fix: Restore the locked require-existing option and pass it for folder backfill.

BLOCKING -- src/kiro_crew/messaging/auto_title.py:296 -- A stale title can overwrite a replacement conversation
_record_is_untitled,
Delete and recreate the channel conversation during title generation -> the stale task accepts the untitled replacement -> the old title overwrites it.
Anchor: residual/crash-data-loss-corruption
Fix: Restore the pre-scheduling record identity pin and require the locked update to match it.

BLOCKING -- src/kiro_crew/telegram/transport_dispatch.py:3734 -- A fast SKIP permanently freezes the fallback title
if is_new and not auto_title.is_titled(session_key):
First title task returns SKIP before persistence -> fallback title lands -> subsequent generated title is rejected and its claim remains held.
Anchor: residual/guard-removal
Fix: Restore the captured auto-title-pending flag and suppress fallback whenever generation was scheduled.

[BLOCK-MERGE] ee1df06
[GPT-REVIEWED] ee1df06
False positive or not applicable? A repository writer can comment:
/ai-review override gpt ee1df06a8c3acb2ac39ebb59036c4d875b0790dd: <one-sentence reason>

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — 🔴 changes requested (blocking)

GPT 5.6 found at least one blocking issue that must be resolved before merging 571a2dac0e5d4ae70ae0ef87aad7304fcbc5ca38. Adjudication produced no [GPT-ADJUDICATED] marker for 571a2da: the adjudication stage FAILED TO RUN (its raw output is in the Adjudication details block -- typically an API or setup error), so no proportionality review took place and GPT's blocking verdict stands unreviewed.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/slack/gateway.py:8042 -- Judge cursors advance before the tick state commits
loop.judge_cursors = cursors
New assistant row -> collector advances the live cursor -> cancellation or persistence failure -> the next tick skips evidence absent from durable state.
Anchor: persist-before-you-publish
Fix: Stage cursors, verdict, and streak; persist first, then publish and emit the notice.
[BLOCK-MERGE] 571a2da
[GPT-REVIEWED] 571a2da
False positive or not applicable? A repository writer can comment:
/ai-review override gpt 571a2dac0e5d4ae70ae0ef87aad7304fcbc5ca38: <one-sentence reason>

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — 🔴 changes requested (blocking)

GPT 5.6 found at least one blocking issue that must be resolved before merging cf0dc90e138db7b93b39301ae2fc99ac359a858b. Adjudication produced no [GPT-ADJUDICATED] marker for cf0dc90: the adjudication stage FAILED TO RUN (its raw output is in the Adjudication details block -- typically an API or setup error), so no proportionality review took place and GPT's blocking verdict stands unreviewed.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/autonudge_judge.py:118 -- Target and cursor stores use divergent bounds
out.append(stripped) / _JUDGE_MAX_CURSORS = 16
Eight inferred sessions plus a PR -> ninth target is silently discarded; repeated retargets retain stale cursor keys without a runtime bound.
Anchor: a-bound-bounds-every-field-it-retains
Fix: Apply MAX_JUDGE_TARGETS everywhere, count overflow, and prune cursors to current targets.

BLOCKING -- src/kiro_crew/slack/gateway.py:8042 -- Judge state is published before durable commit (origin: validation)
loop.judge_cursors = cursors
await self._emit_judge_notice(...) / loop.judge_last_verdict = ...
New evidence -> timer cancellation or persistence failure -> rows are skipped in memory or a quiet notice is shown although the tick fires.
Anchor: persist-before-you-publish
Fix: Stage cursor/verdict state, commit it durably, then update memory and emit the notice.

FINDING -- src/kiro_crew/decisions/consent.py:29 -- "a forge comment's body" contradicts the collector, which sends only a fingerprint -> Fix: describe the typed observation and comment-body fingerprint here and in gate.py.

[BLOCK-MERGE] cf0dc90
[GPT-REVIEWED] cf0dc90
False positive or not applicable? A repository writer can comment:
/ai-review override gpt cf0dc90e138db7b93b39301ae2fc99ac359a858b: <one-sentence reason>

@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ⚠️ review incomplete

GPT 5.6 did not produce a complete verdict for 1587187c1dd81a21963390da72d52303610bb763; inspect the workflow logs and re-run it.

This comment is updated in place on each push.

See the GPT 5.6 Review job logs; this commit has no completed GPT verdict.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 1587187c1dd81a21963390da72d52303610bb763: <one-sentence reason>

1 similar comment
@github-actions

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ⚠️ review incomplete

GPT 5.6 did not produce a complete verdict for 1587187c1dd81a21963390da72d52303610bb763; inspect the workflow logs and re-run it.

This comment is updated in place on each push.

See the GPT 5.6 Review job logs; this commit has no completed GPT verdict.

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 1587187c1dd81a21963390da72d52303610bb763: <one-sentence reason>

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Rendered-state disposition for the Design and UX lanes

Every new user-visible state in this revision, written out, with the ones that have no
capture named as such. Posted as a comment as well as carried in the description.

Covered by the attached image: Settings -> Developer -> Decisions, showing the
nudge.wake row, the nudge_evidence switch and the egress note counting four
categories. Still current for the card's layout, with one known difference: the switch
description no longer ends in a state sentence, so the frame shows one trailing
sentence this revision omits.

No capture, popover judge row (data-testid="judge-line"), six states:

State Renders
wake-sense brief Judge: wake when {criterion}
quiet-sense brief Judge: stay quiet while {criterion}
no verdict yet criterion, then no verdict yet
timed verdict criterion, then last: {outcome} / {count} items / {time}
untimed verdict criterion, then last: {outcome} / {count} items
no row at all a loop with no criteria of its own, or judge: false

Segments are separated by a middle dot. {outcome} is one of quiet, waking,
finished, could not judge, unknown. The row carries its siblings'
text-muted text-[11px] contract with no clamp, so a criterion at the arming bound of
500 characters wraps rather than truncating. A test pins that it is carried whole, which
answers the shape question and not the rendered one.

No capture, transcript notice row: one line per verdict, reading
Wake judge / {outcome} ({default|custom} brief) / {question} {answer} / {n} evidence item(s), middle-dot separated. The (default brief) and (custom brief) variants are
new here and have never been captured.

No capture, and correctly so, the two bypasses: a gate=false loop and a
judge: false loop are never screened, so they render no judge row and emit no notice.
Their absence of UI is the correct behaviour and is asserted by tests.

Why no capture exists: a capture needs a pod serving both this revision's backend
and its bundle. The pod behind the attached frame booted hours earlier and does not
carry this revision's popover code. A fresh pod was provisioned and booted correctly at
this head, but no token could be minted for it from the agent sandbox: the gateway
requires unix-socket admission on /api/token/local and no socket is exposed in its run
directory, so it answers /api/health and refuses every authenticated call. Tracked as
#12958. The pod was released rather than left holding a port.

A reviewer should treat every row above as unillustrated rather than approved.

@chenmingwei23

chenmingwei23 commented Sep 23, 2026 •

Copy link
Copy Markdown
Contributor Author

Disposition of the advisory CONCERNS on 48a4a175cdae31253d5b68671d296f4b35ed6893

All three review lanes are advisory on this head and none is a BLOCK. Each finding below
is answered as fixed, deferred with a reason, resolved, or not applicable.

Updated after a rebase onto a8c505beb9, head now 60b455b340. The rebase was
required (the branch had gone CONFLICTING) and curative for the first item below. It
changed no product code: the only conflict was docs/request-for-change/rfc-wake-judge.md,
resolved in favour of the ratified version, so this branch now carries NO edit to that RFC
at all. Every other disposition below is unchanged and still accurate at the new head.

Design, default screening ships against a draft RFC. RESOLVED: the RFC status landed in
#13082, merged 2026-09-23T22:54Z, which takes rfc-wake-judge.md past draft (status: partial) and ratifies the default-screening shape in section 3.3. First Principles item 4
is the same finding from the premise side and is resolved by the same merge; its
subtraction (drop the default_spec() merge) is answered by the ratified text rather than
declined, since that text now states default screening as the design.

This branch's own RFC prose is withdrawn in favour of it. The ratified section is strictly
fuller than what this PR carried: it adds the untrusted-evidence clause the compounding
bound rests on, the reasoning for nudge_evidence standing in for a brief the loop never
wrote, and where the judge sits relative to the typed probe. It also deliberately keeps the
full design's pr_comment evidence kind and comment-body collector, recording in its own
preamble that the landed branch omits them because the reader publishes only a digest. That
framing is better than this PR's edit, which had narrowed the design text down to the
subset, so the edit is dropped and the RFC is single-sourced.

One observation for whoever owns that RFC, recorded rather than changed here: its section
3.5 notice example predates the brief marker this branch ships. notice_line renders
Wake judge <outcome> (default brief) or (custom brief) when a brief name is passed,
because a quiet reached under the shipped default is not evidence that the owner's own
sentence works. The example is illustrative and the preamble already schedules a re-audit
at merge, so this is a note for that pass, not a defect.

Design, the transcript notice has never been rendered. DEFERRED, blocked by #12958.
The popover row now has a component-level capture at this head, which is what moved this
lane off BLOCK; the notice row has no equivalent because it is produced by a live judged
tick, and a live tick needs a pod the agent sandbox cannot mint a token for. The lane's
own clears-when accepts either a post-#12958 capture or the UX lane accepting tests-only
coverage.

UX, one feature wears three names. DEFERRED, and it is a fair finding. "Jev" is the
existing product name for the LLM lane and is shared with the other decisions points;
"Judge:" is this row's prefix. Picking one word changes a shipped decisions-point name and
the string in 13 locales, so it is a product naming decision with a translation pass
attached, not a rename this PR should make on its own judgement.

UX, judge_outcome_terminal: "finished" is ambiguous. DEFERRED for the same reason:
the suggested replacement is copy in 13 locales. Inventing twelve translations is worse
than leaving one consistent English source and handing the pair to a translation driver,
which is the same call taken earlier in this PR for the watching/waiting wording.

UX, the notice renders question IDs and raw probabilities. NOT APPLICABLE as a defect,
and recorded as a disagreement a maintainer can settle. The quoted "never a probability"
comment governs the POPOVER row, which is glanceable UI; notice_line's own docstring
states the opposite intent for the transcript notice, deliberately -- "Probabilities, not
prose: the numbers are what a reader needs to tell a confident quiet from a lucky one."
The two surfaces have different audiences and each states its rule, so the code is not
self-contradictory. The lane's real point stands and is worth a maintainer's view: the
notice is in the owner's chat tab rather than in the decisions log, so a plain-words line
may serve better. Changing it reverses a documented choice, which is why it is not taken
here.

UX suggestion, shot-01 shows an earlier label. DEFERRED. The difference is already
disclosed in the description, which states that frame shows one trailing sentence the
current build omits and predates this revision's bundle. A fresh Decisions-card frame is
producible with the same harness that made the judge-line capture and is the natural
follow-up once #12958 unblocks a live capture, so both frames can be retaken together.

First Principles item 5, quiet_streak_floor has no named consumer. DEFERRED as a
scope call. This head already narrowed that knob at this lane's own earlier request: it is
downward-only now, the shipped floor is its ceiling, and _JUDGE_QUIET_STREAK_FLOOR_MAX is
deleted. Removing the key entirely is a further subtraction of a config surface the RFC
names, and the ratified RFC keeps it (clamped, never off), so it belongs to whoever owns
that document rather than to this PR.

First Principles item 7, Q_URGENCY has zero consumers. DEFERRED, awaiting a decision
that has now been requested four times. The finding is accurate: the answer is asked on
every call and read only by notice_line, while map_answers consumes outcome and
needs_owner only. It is a shape change to a shipped decision point, so it is not deleted
unilaterally. The recommendation on record is deletion.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Dispositions for the findings on e41842f11d / 69c3bd63b1

GPT 5.6 -- docs/feature-map/README.md:215, pull-request criteria receive no canonical facts

Taken, as a prose edit -- the second of the finding's own two options ("or remove the
PR-evidence claim"), which is also the one its adjudication names: "a feature-map cell's
wording, no runtime effect ... tightening the map's PR-evidence sentence is a prose edit, not
the runtime rewiring the finding's first option would require."

The map's sentence opened with "a watched pull request contributes the CANONICAL observation
held on its monitor record" and only qualified that two clauses later, which is the clause the
finding quotes. It now leads with the absence: a watched pull request contributes NOTHING on
any loop this judge screens, because the canonical observation its reader wants has one writer
and that writer is on the structured path. The renderer is described as what it produces once a
gated tick publishes one, the companion sentence about the owner's criterion is conditional on
the same producer, and the PR body's matching passage is corrected so the description and the
map agree, which is what the feature-map-correctness anchor compares.

The runtime is deliberately unchanged, and the "turn suppressed until the floor" line is the
settled behaviour rather than an open defect.
That rule has now been asked for in both
directions by different lanes on consecutive heads: treating a factless reading as a complete
one, and treating it as an unread target that fires. autonudge_judge.pr_target_is_unread is
the answer to both, and it turns on whether anything read the subject rather than on whether
the judge got facts:

  • With a typed probe behind it, which on the gated path is always -- the judge is asked at
    autonudge.py:5930 only after irq.poll returned QUIET -- the subject WAS read. The target
    is not a drop, the tick stays quiet on the PROBE's own verdict, and the probe's free re-arm
    stands exactly as it does on a build carrying no judge. The judge neither reaches that
    decision nor overrides it, so nothing here suppresses a turn the timer would have spent.
  • With no probe behind it (a loop carrying no monitor, a spent watch, a brief naming some other
    pull request) it is an unread target and fires.

Pinned by TestAScreenedPullRequestTickLeavesTheProbesQuietAlone, which drives the real tick
and asserts a screened pull-request loop answers QUIET with its unread-target control beside
it, and by test_a_reading_is_unread_only_when_no_probe_covers_the_subject, which asserts the
rule in both directions and fails by name when the rule is made unconditional.

Threading real facts out of the kernel stays out of this PR: the canonical shape is built by
the monitoring providers from their own fetch, including review threads and a REST check pass
the gh pr view probe never makes, so a gated producer means a second subprocess per tick or a
port of that provider, against a field pinned by full-dict equality and hashed into the wake
fingerprint.

First Principles item 2 -- section 7 Q4, the authorization for a briefless loop

Deferred to the design record, where it belongs, and it is already in flight: PR #13234
records Q4 as decided from this code.
This branch carries no edit to
docs/request-for-change/rfc-wake-judge.md, deliberately, so the design record stays
single-sourced after #13082 ratified it.

Design -- the point's spec in the module spec tree

Advisory, and not taken here. docs/system-specs/modules/decisions.md:419 promises the
point is "specified with the autonudge module", and that promise was added by merged PR #12776
rather than by this branch, while docs/system-specs/modules/monitor-architecture.md carries
no judge section for it to land in. Writing one is a new document in another PR's obligation,
so it stays out of a change this size.

UX -- one name instead of three, and the notice line's wording

Advisory, and not taken here. "Jev" in Settings, "Judge:" in the popover and "Wake judge"
in the notice are one feature under three names, and the notice's answer names are machine
labels. Both are copy, across thirteen locale catalogues, and inventing twelve translations is
worse than one consistent source handed to a translation pass.

An auto-nudge loop fires a full model turn every interval. For a pull request
named by URL the typed probe already turns an unchanged tick into a free
re-arm; for everything else -- a conductor patrolling workers, a babysitter
reading review prose, a loop watching a log -- it cannot, because the evidence
that justifies staying quiet is prose.

The `nudge.wake` decision point reads what the loop's targets produced since
the last tick and answers QUIET or fire. A watched session contributes its new
assistant rows through `session_control.read_messages`, authorized with
`authorize_target` first, so a target the owner could not read by hand is
dropped and counted rather than fetched. A watched pull request contributes
`render_pr_summary` over the twelve canonical keys the probe already published,
plus the comment-body fingerprint when one exists -- never body text.

Ordering: a gated monitor probe observes FIRST and a typed verdict wins
outright, so a merged or closed pull request still deactivates a judged loop.
The judge is consulted at exactly one point, the probe-quiet return.

The judge never ends a loop. `finished` and `broken` wake with the verdict
attached, because a prose-minted terminal would let one hostile comment buy
permanent silence. Consecutive QUIET verdicts are floored by
`decisions.nudge_wake.quiet_streak_floor`, clamped on read since config.json is
agent-writable, so a judge wrong about a subject costs a late turn, not
silence.

A brief is credential-scrubbed at every entrance -- arm, update and decode.
Bounding shape is not scrubbing a value: an allowlist with a length limit keeps
a criterion naming a bearer token whole and merely shorter. Scrub precedes
clip, because a redaction marker can be longer than the secret it replaces.

The Jev lane needs the Decisions consent switch plus the `nudge_evidence`
scope; with the scope off a stored brief is ignored and the loop runs as a
plain timer. The tick resolves lane and authorization through one `is_enabled`
call rather than a second rule of its own.

Feature preview, default off. Design: docs/request-for-change/rfc-wake-judge.md
…none is given

A brief is no longer the thing that arms the judge. Once `nudge_evidence` is
granted, every GATED loop is screened on every tick; a loop naming no criteria of
its own runs under `autonudge_judge.default_spec`, whose wake sentence asks
whether the subject needs its owner and whose quiet sentence is "nothing new for
the owner since the last tick". The loop instruction is already the tick context,
so that default reads the loop own exit condition without restating it.
Requiring a brief per loop made the saving opt-in, and the loops that need it
most are armed by agents mid-task with no reason to spend the argument.

An explicit brief overrides the default. A brief naming only `targets` keeps them
and takes the default sentences, which is why the branch keys on the CRITERIA
being absent rather than on the brief being empty. The default is never written
back, so the stored field stays a record of what the owner asked for, and the
mid-tick replacement guard now compares a re-read against what was STORED: the
merged form differs on every default-brief tick, so comparing it would report a
replacement nobody made and discard the verdict.

Two bypasses, and they mean different things. `gate=False` is never screened,
because such a loop acts WHILE its subject is quiet and suppressing that removes
the work rather than the waste. `judge: false` is an owner who wants observation
gating and no judge; it normalises to a reserved marker the arming validator
refuses from a caller, so the boolean is its only spelling. An empty object is
neither -- it drops the owner criteria and the default applies.

The transcript notice names which brief a verdict was reached under, because a
quiet under the shipped default is not evidence that the owner sentence works.

Also in this commit, from review: two dead judge constants removed
(`_bounded_judge_spec` and `_bounded_judge_verdict` each spell their allowlist
inline, which is why neither had a reader), the RFC collector section corrected
to state that comment body text stays out of the evidence, and two pieces of
unrelated churn dropped from the diff.

Two review findings on this work are folded in here rather than left to a third
commit, because PR Hygiene allows two.

`pr_observation_is_about` decides whether a loop's single observation is about the
target the collector asks for. When the two strings differed it inferred BOTH
sides and compared identities. `infer_monitor` stores the canonical subject
(`owner/name#123`) with the inferred kind, and that shorthand carries no host by
design, so inference declines it: the watched side inferred to nothing, the
comparison could not succeed, the target was dropped and the tick answered
FALLBACK. Every gated loop whose subject is a pull request named in its own
instruction therefore paid a full turn on every interval -- the waste this point
exists to remove -- and it failed silently, because firing is the safe direction.
Both stored shapes now work: `monitor_watch` keeps the caller's canonical URL,
covered by the existing string and identity comparisons, and the shorthand is
covered by a third comparison of the inferred kind and subject against the pair
the monitor is bound to. That one needs no host of its own, because the inference
pins one host and refuses any other. The tests hand-wrote the watched side as a
URL and the kind as the wire name, so they ran on two values neither producer
emits and passed on the exact-string shortcut; the new class reads both fields
from a real `MonitorState` and fails by name when the third comparison is removed.

The feature map's Developer row still described `nudge.wake` as registered and
fired by nothing, contradicting the Monitor loops row in the same file. It now
states that the point fires and what arms it, and carries the `nudge_evidence`
scope it had omitted -- its own paragraph on the terms the row uses for its
sibling scopes, a place in the consent endpoint's scope list, and the point's
module beside the others in the backend column.

Rendered evidence for the transcript notice row is added at
`temp-screenshots/judge-notice-row.png`, closing the UX lane's remaining evidence
gap. A judged verdict is written as an ordinary `notice` row and drawn by the
existing `NoticeCard`, so the frame mirrors that component's DOM and its four lines
are the verbatim return of `notice_line` -- quiet under the shipped default brief,
quiet under the owner's own brief, a wake, and a fallback with no answers. The
harness reads the computed style back before shooting and reports the `--muted` and
`--card` tokens with a 13px/20px inner row, so the frame is evidence of this
revision's built stylesheet rather than of the harness.

An unwritten canonical pull-request observation reads as an unread target rather
than as a calm subject. The field has one writer, apply_monitor_probe on the
structured controller's path, and a judged loop is gated, observing through
irq.poll whose verdict carries no canonical facts -- so the collector saw {} for
every loop the judge screens. Handed on as a dict that was indistinguishable
from a complete reading with nothing to report, and the resulting no-evidence
no-drop shape is the one a QUIET verdict is built on, so an owner's pull-request
criterion bought silence up to the streak floor. pr_observation_has_facts is the
one named rule and both the gateway reader and collect_evidence's drop
accounting call it; the reader must answer before it stamps observed_at onto its
copy, which a plain emptiness test in the collector alone would pass through.

The feature map states what the collector can do instead of claiming a producer
it has none for, and the review captures move to PR attachments, which is the
route .gitignore records for review evidence.

A factless pull-request reading is an unread target only when no typed probe
covered the subject on this tick. On the gated path the judge is asked only after
the probe's own verdict came back quiet, so that subject WAS read and counting it
unread would fire a turn the probe had already settled, every interval, for the
life of the watch. pr_target_is_unread carries the rule and the reader passes it
whether a probe covers the subject; the collector's drop accounting trusts the
reader's None, because the monitor and the probe's schedule are in the reader's
reach and not the collector's.

judge_quiet_streak leaves the frontend, where it was parsed, typed and carried
with no surface rendering it. The backend field is what the quiet-streak floor
counts and stays.

The feature map's pull-request sentence leads with the absence: a watched pull
request contributes nothing on any loop this judge screens, and the reader's
renderer is described as what it produces once a gated tick publishes a canonical
observation. The companion sentence about the owner's criterion is conditional on
the same producer, so no clause in the row asserts a pull-request evaluation that
cannot happen.

The update path's comment on an empty judge object says what the code does: {}
clears the owner's own criteria and a gated loop then runs under the shipped
default, while judge: false is the bypass and normalises to a reserved marker
rather than to this shape. validation.py and autonudge.py already state it that
way, and the PR body already claims this comment does, so the three now agree.
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Dispositions for the advisory verdicts on 34483d00fb

This head is a curative rebase onto de2058659d, which IS #13230's fix for the inherited
::1 bind failure. No code changed in the rebase. All three verdicts below are advisory
CONCERNS and none gates PR readiness; each is a re-raise of a theme already dispositioned in
the earlier comment on this pull request.

First Principles -- section 7 Q4, the authorization for a briefless loop

Unchanged disposition: this belongs to the design record, not to this branch, and it is in
flight as #13234, which records Q4 as decided from this code. That PR is still OPEN. This
branch carries no edit to docs/request-for-change/rfc-wake-judge.md, deliberately, so the
record stays single-sourced after #13082 ratified it.

UX -- one feature under three names, and the notice line's answer names

Unchanged disposition: "Jev" on the consent switch, "Judge:" in the popover and "Wake judge"
in the notice are one feature under three names, and the notice's answer names are machine
labels. Both are copy, across thirteen locale catalogues. Inventing twelve translations is
worse than handing a translation pass one consistent source.

Design -- a pull-request criterion is armed and shown while no gated tick can produce facts

The mechanism is accepted and is this revision's own documented position: the canonical
observation has one writer, on the structured-controller path, and a gated loop observes
through the raise-based kernel, so the reader finds an empty canonical on every screened loop.
That factless reading defers to the probe's quiet rather than counting as an unread target,
which is the shape BOTH this lane and First Principles required on an earlier head, after the
opposite shape was required before that. autonudge_judge.pr_target_is_unread is the settled
rule, pinned in both directions by
test_a_reading_is_unread_only_when_no_probe_covers_the_subject and at the tick level by
TestAScreenedPullRequestTickLeavesTheProbesQuietAlone. It is not reopened here.

Marking a pull-request-only criterion as pending at the arming surface or in the popover is a
new product surface, and refusing such a brief would reject a criterion that becomes correct
the moment the producer lands. Both are scope for the producer change, not for this one.

One sub-claim in this verdict is correct and is HELD, not dismissed. An earlier section of
the description still says render_pr_summary "closes it", which stopped holding when the
later section was rewritten to lead with the absence. The sentence should read that the
renderer produces that line once a gated tick publishes a canonical observation, which is what
both the final section and docs/feature-map/README.md already say. It is a description-only
correction, so under the current push freeze it is recorded here and batched with the next
change that has an independent reason to push, rather than re-rolling six review lanes for one
sentence.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Holding this one, and I have taken auto-merge back off so an approval cannot land it while the defect stands. This is not about the GPT BLOCKING — that one is genuinely over-stated, and the Opus downgrade of it is correct: a failed _persist_judge_state never suppresses an owed turn, it can at worst re-judge already-delivered evidence once after a restart.

It is about the advisory FINDING in the Opus 5 body that has no disposition on this head, which is real and does change behaviour:

collect_evidence reads one page of 12 durable rows per target. Every role counts as durable — tool, notice, system, error, user, assistant — so a single busy worker turn can produce more than a page of tool rows alone. When that page contains no assistant row, evidence comes back empty with dropped=0, so judge_tick calls no model and returns QUIET ("no new evidence"), the cursor advances 12, and the backlog is left for the next tick. On a busy worker the actionable reply can sit several pages behind and be judged QUIET every tick until quiet_streak_floor forces a wake — hours at a 45-minute interval.

That contradicts this PR's own stated invariant, the one collect_evidence's MAX_TARGETS handling exists for: an incomplete read must never look like a complete one.

Minimal fix, either one

  • src/kiro_crew/autonudge_judge.py:485-487 — after evidence.extend(session_evidence(...)), add if len(rows) >= MAX_ROWS_PER_TARGET: dropped += 1 so a full page routes to FALLBACK and fires (this is the remedy Opus named); or
  • src/kiro_crew/slack/gateway.py:7980-8001 — have _read_session read payload.get('total') and signal not-read-to-end when total > next_since; collect_evidence already counts a raise as dropped.

Plus a case in test/test_autonudge_wake_judge.py with a full page (12 tool rows, total=24) asserting the tick returns FALLBACK rather than QUIET.

Re-arm auto-merge once that is in or dispositioned with evidence.

@buluoray buluoray left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving at 34483d0.

Verified the fail-safe properties:

  • Session reads go through read_messages(caller_session_key=loop.slot_key), which runs authorize_target.
  • A tick with an unreadable target returns FALLBACK (nudge_wake.py:484). Removing that check reddens 4 tests.
  • The quiet floor is clamped with min(floor, _JUDGE_QUIET_STREAK_FLOOR_DEFAULT) (autonudge.py:5195). Removing the clamp reddens the clamp test.
  • Any judge exception fires the turn (autonudge.py:6220).
  • PR-monitor terminal branches run before the judge.
  • Jev egress requires the new nudge_evidence scope.
  • judge_cursors are never serialized.

875 tests passed.

Non-blocking:

  • No test pins the gateway collector's caller_session_key.
  • The description's "with the scope off a stored brief is ignored" overstates the LLM lane, which still runs a custom brief.
  • I didn't confirm the decisions-log write in judge_tick stays off the event loop.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants