Repository navigation
Conversation
GPT 5.6 Review (fork) — ✅ no blocking findingsReviewed Review detailsNo findings. |
UX Review (Fable 5, fork) — 🟡 CONCERNSUX-level review of No screenshots and no recordings were supplied (all three evidence files are empty; the PR removed the twelve committed frames). I've reconciled the user-visible changes against that. User-visible elements this PR adds/changes, none shown in any artifact:
No blind read runs in this lane, so comprehension of the badge, the dashed edge, and the notes is UNKNOWN, not inferable from the labels. No lens-13 hard swap (the recommended/declined state is fixed per option at render, not a user-driven transform of an already-identified element), and the notes assert what happened and offer an action, so no BLOCK exit fires cleanly. UX-Verdict: CONCERNS Every control this PR adds — the RECOMMENDED badge, the dashed "won't-send" chip, the ring flash, the three notes — ships with zero screenshots or recordings, so nothing has been seen. Watch
Evidence gaps
[UX-REVIEWED] e941d56 |
Opus 4.8 Review (fork) — ✅ no blocking findingsReviewed Review detailsI've independently verified the core logic: the No findings. [OPUS-REVIEWED] e941d56 |
Design Review (Fable 5, fork) — 🟡 CONCERNSDesign-level review of The design is coherent and the code matches the description's claims. The core feature solves a real problem (a recommendation the rendered menu never shows), and the Slack Design-Verdict: CONCERNS A real fix, soundly shaped — but an independent privilege-escalation fix is bundled into the feature commit, so reverting the badge also reverts the security fix. WatchScope bundling / revert coupling. The Slack SuggestionsThe in-label marker keeps a dual-runtime guard fence (34 literals, 4 parity suites) that the author's own cost table shows an out-of-band control tag would delete; since the grammar is deliberately withheld from the published SDK contract, that move stays reversible — worth a tracked follow-up, not a change here. [DESIGN-REVIEWED] e941d56 |
First Principles Review (Fable 5, fork) — 🟡 CONCERNSPremise-level review of First-Principles-Verdict: CONCERNS The "recommendation nobody can read" defect is self-created: this PR invents the Not justified as shipped
What this change shipsInventory (10 items) — 2 justifiedIntent: let an agent visibly flag its recommended chip option without that flag becoming the user's dispatched message. ADDITION.
Watch
Subtractions
[FIRST-PRINCIPLES-REVIEWED] e941d56 |
e4fcbc6 to
a440191
Compare
a440191 to
a1c3b2d
Compare
a1c3b2d to
9b0718c
Compare
9b0718c to
e29337c
Compare
|
The chips are capped at On reordering: worth noting the two are not exclusive — ordering communicates rank, the marker communicates which single option the agent actually recommends, and the agent emits that marker as text today with no way to signal position. Happy to defer to designers on which carries it. One caveat if you compare the screenshots: they were generated before the ordering-variant forms were dropped, so they show a second |
|
Closing out the screenshot caveat from my previous comment: the regenerated pair is already on the branch, so the stale second badge is gone — my "I will regenerate them" was a beat behind the branch. Verified at head
The design question you raised is untouched by any of this — badge versus reordering is still yours and the other designers' call, and I have not moved it. |
|
One change since you looked, on the "does not help much" point specifically — at head The badge previously shared the picked chip's own fill, so once an option was selected the tag melted into it and stopped being readable at exactly the moment it mattered. It now uses a distinct fill: Nothing else about the badge changed, and I have not touched the ordering question — badge versus reordering is still yours and the other designers' call, and I have deliberately left it open rather than implementing either side. |
|
Thanks for looking. Measurements at the current head Your premise is right, and this branch does not touch it. Where the badge sits relative to the label. On reordering "as always" — there is no ordering behaviour in place to build on yet. That last measurement is the useful part of your suggestion: because nothing sorts, "most reasonable first" would be a change to the producer guidance rather than to this component — which is cheap, and not mutually exclusive with a badge. Ordering could carry the ranking while the badge names the pick explicitly for a screen reader or a user who does not read position as ranking. Which of the two we want, or both, is your and the other designers' call — I have not implemented the reordering, and I will follow whichever way you land. |
|
@rnoack1 the 2026-09-08 open-PR relationship audit found two newer open PRs writing into the same lines as this one. The audit read this PR at #8613 (session_escalate, @CrysisDeu) shares #8003 (subagent credit usage, @welikoiwanenko) shares Neither PR duplicates this one. A note on each about landing order is enough, and @CrysisDeu / @welikoiwanenko may want to watch this PR for the merge order. Posted from the 2026-09-08 open-PR relationship audit (read-only, one auditor per PR); reply here if any of this is wrong. |
|
On the reordering half of this, verified at
So position still carries the ranking you want, and adding a client-side reorder on top would override deliberate producer order — a trailing "Nothing more (recommended)", or a One mechanical detail on "with limited chips, adding tags does not help much", offered as information rather than as a counter-argument: a marker written inside the label competes for the clamped label width and disappears into the ellipsis, whereas the badge is drawn outside the truncating span, so it survives the clip. That clip is the specific problem it addresses. Whether that is worth a badge at all is the design call, and I am leaving it with you and the other designers as you asked. |
|
Re-verified at Ordering, unchanged in substance: still no client-side reorder — no What has changed, because it bears on "adding tags does not help much": the badge no longer borrows a monospace-italic voice. It is now an uppercase, letterspaced micro-label matching the product's existing micro-label style, and monospace is reserved for the one case where the marker is NOT stripped and really is sent as typed. So the two states no longer differ only by slant. The design call is still yours and the other designers', exactly as you left it — this is only to keep the evidence current. |
|
Re-verified at Ordering, unchanged: still no client-side reorder — no What changed, and it speaks to "with limited chips, adding tags does not help much": the readability cost you were pointing at is now bounded rather than argued. The badge cannot shrink, so previously it could squeeze its own chip's instruction down to about six characters at narrow widths — worst on the one option being steered toward. The label now carries a 12-character floor, and only on a chip that actually has a badge competing with it ( The marker also carries no special typeface any more: monospace already means "recommended" elsewhere in the product, so a second meaning there collided instead of teaching. Whether the badge is the right idea at all is still yours and the other designers' call — this is only to keep the evidence current. |
|
At Ordering-first is already mandated, independently of the badge. The producer rule now carries it, in
Two details worth having:
The rule ships in the always-on dashboard rules block, so it applies to every dashboard session rather than being opt-in. What your objection leaves open is the badge itself, and that part is a product call, not something I should decide by verification. You deferred it explicitly, so it is with the maintainers; nothing here is meant to argue it either way. |
|
Re-verified at Your ordering ask is still mandated, and still in the producer rule rather than the client. The line moved with the rebase — it is now
One correction to something I told you. I previously reported a flat 12-character floor on a badged chip's label. That was accurate then and is not now: a fixed 12ch plus a long-locale badge (uppercased Also worth stating plainly, since it is the shape of your objection. In between, I did try enforcing the ordering in the renderer by hoisting the marked chip to first position. I took it back out: overriding producer order breaks a deliberately ordered list, and a review lane objected to repairing a producer nobody has observed misbehaving. So ordering is an instruction to the producer, not a guarantee in the client. If you want the hard client-side guarantee instead, that is a call for you and the other designers — the two are mutually exclusive and I am not going to pick for you. The badge-versus-tags question I have left alone, since you deferred it. |
|
Re-verified at Ordering-first is mandated in the producer rule, independently of the badge.
It is producer-side rather than client-side deliberately, so it also applies on the surfaces that render no buttons at all — a client-side sort could not reach those. On "with limited chips, adding tags does not help much": the badge does not spend label width. I am not treating the design question as settled by either point — you asked for reordering instead of tagging, and the ordering mandate above is the part of that which is now in code. Whether the badge should exist alongside it is still open, and you deferred it to other designers. |
|
Correcting something I overstated in my previous comment, now that the frames are actually viewable at I said the badge "does not spend label width" and that it "is not competing with the instruction text for the chip's clamp budget". The first half is right in the sense that matters — the badge sits outside the truncating span, so it is never itself clipped and a long locale cannot ellipsis it away. The second half is wrong. The badge and the label share one width-capped chip, so the badge does take room from the label. The two frames show it directly: unbadged, the label clips at So the honest version of the tradeoff is: the tag costs about a character of the label at this width, not zero — and what the floor buys is a guaranteed readable stem (12ch from the That is a smaller cost than a tag inside the label, which spends its own full length and is then the first thing clipped — the case your objection is about. But it is not free, and I should not have said it was. |
|
Not approving for now: an outstanding CHANGES_REQUESTED review is still open, and the body itself leaves a scope call unresolved by bundling a second, independent change (Slack option clicks no longer being command-interpreted, affecting every option click) into the marker-badge work. Please split that out or get an explicit maintainer ruling first. |
The marker sat inside the chip's single truncated line and the ellipsis reached it first, so the recommendation was readable only by clicking every chip.
|
Rebased onto main Conflicts resolved (only these files were hand-merged):
Same single commit, same author, same message. The changed-file set remains exactly 102 files, with no added or absorbed paths. Outside the hand-merged conflict areas, changes come from Git’s automatic rebase onto main; no unrelated edits were made. Validation: 35 targeted tests passed; all 62 changed Python files compiled and all 14 changed JSON files parsed. No conflict markers remain. The existing blank-line-at-EOF warning in Prior approvals need to be re-given after CI re-runs. This is a conflict-only rebase, not an approval or merge. |
|
Rebase needed again: at head Triage result (read-only, from the full diff): no duplicate PR, and main has none of this ( |
|
Thank you @rnoack1 for the very thorough work and the careful follow-ups. We're closing this one: the design call went the other way, and we'd rather keep ordering the most reasonable option first than add a badge to a small set of chips. Main also doesn't use a |
Problem / Motivation
This PR introduces a convention and the rendering it needs: an agent marks its
recommended choice by writing
(recommended)at the START of an option label. Nothing inthe base repo asked for that marker, so the producer rule below is part of this change
rather than behaviour already in the field — see "Backend" under What changed.
Once the marker exists, two things are wrong with leaving it in the label.
The first is dispatch: the label doubles as the user's next message. Clicking
(recommended) Merge it nowsends exactly that, so the user appears to be recommendingsomething to the assistant. Worse, stripping it naively is its own hazard — a cleaned
label can open with
/,@or[, or BE a plan action or a stop word, and then a clickdispatches something the agent authored rather than words the user chose. That is the
harm the guards below exist for, and it is the one the feature is bought for.
When the guard declines, the chip shows the raw
(recommended) …text and a click putsthat string in the composer as the user's own message. The marker carries NO typographic
signal of its own: mono already means "recommended" elsewhere in the product
(
SpecStatePanel), so a second meaning here would collide rather than teach. One note underthe bar explains it instead, and a declined chip is exempt from instant send so the click
always leaves a chance to edit the prefix out. There is no per-chip screen-reader note, and
it would be redundant: the prefix is real label text, so it is already read out.
The second is presentation: the marker is plain label text, styled identically to the
instruction and competing with it for a single clamped line's width budget. A badge is
one word, outside the truncating span, and visually distinct — so the recommendation is
legible at a glance instead of being read out of a sentence.
The plan-action, stop-word and injected-prefix literals are HOISTED into
constants.pybythis change, and that hoist is declared scope rather than incidental: it exists so one
definition feeds both the strip guard and the parity suites instead of each carrying a copy.
It is mechanism for the guard, not for the badge, and it is listed here so a reviewer is not
left inferring why a feature PR moves constants.
The Slack
interpret_commands=Falsehalf is SETTLED scope, not an open question: it closesthe
!-family hole the sigil guard cannot see and aligns Slack with the four transports thatalready carry the flag.
Scope note, stated plainly because an earlier revision of this description claimed more:
the marker is only admitted at the START of a label, and a leading marker is never what
an ellipsis reaches. So this change does not rescue a marker from being clipped away;
that only happened for a trailing marker, a shape nothing emits and which this PR
deliberately does not recognise.
ChipBodyalso already puts the full option on thebar note, so the text was never unreachable.
Why it matters
A recommendation nobody can read is worse than no recommendation, because the
turn was written on the assumption it would be visible — the prose above defers
to "the recommended option" that the buttons never name. The failure is also
silent from the authoring side: the marker IS in the response text, so any check
that greps the text passes while the rendered menu shows nothing.
Shortening labels does not fix it. Truncation depends on rendered width, font and
the chip's own box, so any character budget leaves a band of labels visibly cut —
the same reasoning already recorded above
chipTooltipfor why a 60-charthreshold was the wrong proxy.
What changed
(recommended)is now treated as protocol rather than label text.protocol/recommendation.ts—splitRecommendation(option)returns thelabel with the marker removed plus a boolean saying whether it carried one. The grammar is
deliberately narrow (
recommendedand nothing else — therecommended first/recommended thenordering variants are NOT admitted, since nothing in the repo emits them): admitting a markerpaints a badge, so an open-ended parenthetical rule would let
(destructive)or(see below)style themselves as a recommendation. A label that is only themarker is left alone — a badge names no action, and stripping it would send an
empty message. A label that IS or WOULD BECOME a dispatched command is also left
alone: the label is dispatched verbatim, and the dashboard treats three leading
characters as more than plain text — a leading-slash first word is forwarded to the
harness, a leading
@is resolved by_expand_prompt_mentionto a storedprompt whose CONTENT replaces the message, and a leading
[opens a reservedprovenance prefix the backend byte-matches. Stripping a front marker would
promote inert text into something that runs —
(recommended) /clearwouldleave as
/clearand erase the transcript, and(recommended) @deploywouldleave as
@deployand execute that prompt. For such a label the splitter is ano-op returning the original text and no marker, so it behaves exactly as if
the feature were absent and introduces no dispatch path that did not already
exist. The test is prefix-only; either character inside a label is ordinary prose.
parseOptionsapplies the split, sooptionsare clean at the protocolboundary and the four TypeScript hosts send the instruction alone. The messaging
channels are NOT covered, deliberately:
split_options_trailer(
src/kiro_crew/messaging/renderer.py), which 6 renderer modules import, leaves adrifted marker in the choice, so on those channels it is displayed AND dispatched
verbatim as ordinary label text.
strip_recommended_markerhas exactly oneproduction consumer, the Slack path (
src/kiro_crew/slack/format.py), reached throughextract_options_with_recommendation. That strip carries the same dispatch guard asthe frontend for the forms it can promote — the
/and@sigils, theaction::dispatch protocol, the reserved and injected provenance openers and the plan
actions — because the label is sent as the user's message and an unguarded strip
would turn
(recommended) /clearinto/clear. The frontend carries ONE arm the backend does not,deliberately: a leading orchestration stop word (
stop/cancel/abort), matched onthe FIRST word rather than the whole label because the dashboard chat endpoint reads
it that way, so
(recommended) stop after this stagewould otherwise strip anddispatch as a cancellation of a live run. That consumer is reachable only from the
dashboard, so mirroring the arm onto the channel guard would reserve a word no
channel dispatches. A channel has no badge to render and is not
asked for the marker at all, so the strip there is purely defensive, keeping the
marker carried instead of dropping it.
parseOptionsalso returnsrecommended: the one marked label, ornull. A single label rather than a setbecause the only sanctioned producer marks at most one option, and rather than a
widened
optionselement type becauseoptionsmust stay astring[]— it isthe canonical string a click dispatches and every
pickedset is keyed on, so alabel that differed between display and dispatch would break selection tracking.
FollowUpBarrenders the marker as a badge in a newChipBody, as ashrink-0sibling of the clamped span rather than inside it. Position is theentire fix. It stays on the same line, so chips remain the same height — the
constraint
ChipLabel's own comment exists to protect.followUpRecommendedthreaded through the four hosts that render the bar(
ChatPage,ChatPane,ChatEmbed,SideChat) plusChatInput. All four,not a subset: the marker is stripped for everyone, so a surface left unwired
would lose the recommendation entirely rather than merely render it plainly.
ChipBadgerather than threaded through the protocol:the grammar admits one spelling, so there is no second word to carry. It renders
through
i18nT('components.followUpBar.recommended'), and that key is added toall 13 locale catalogs because the badge is UI copy the user reads and the repo's
catalog-parity gate requires every key in every catalog. The
(recommended)marker itself is NOT translated — it is protocol vocabulary, matched
case-insensitively against the literal English word, so translating it would stop
the parser recognising what an agent wrote.
src/kiro_crew/context.pygains
_OPTIONS_RECOMMENDED_RULE, which instructs the agent to mark one option.Before this PR nothing in the repo asked an agent to emit
(recommended), so thisrule — not pre-existing behaviour — is what makes the marker systematic. It changes
the critical-rules block of every dashboard session. It is added to the DASHBOARD
variant only:
_CRITICAL_RULES_TAILis shared by both surfaces, so appending therewould ask channel agents for a marker no channel can render as a badge — the strip
above removes it, so the instruction would buy nothing while adding a way to get it
wrong. Splitting the
[END CRITICAL RULES]terminator into_CRITICAL_RULES_ENDis what makes a surface-specific slot possible, mirroring theexisting
_DIFF_RULE_DASHBOARD/_DIFF_RULE_CHANNELpair._critical_rules_forpicks the block per turn from the LIVE runtime source, not once atsession start, so an ORDINARY channel turn never receives the marker instruction and has
nothing to retract —
TestNoOrdinaryChannelTurnCarriesTheRetractionpins that absence onslack, telegram, discord and cron turns. A channel RESUME of a dashboard-origin session is
the exception the selector cannot cover: the restored transcript still carries the
instruction, so that path appends a retraction, gated on the resume variant and worded
without spelling the marker (the channel rule block must never contain the literal).
test_channel_resume_retracts_marker.pypins the retraction and its gating;test_channel_resume_retraction_not_gated.pypins that it survives the crew-contextopt-out, which previously suppressed it while the restored history still carried the rule.
ParsedOptions.recommended.splitRecommendationis deliberatelyNOT exported from
protocol/index.ts,app-sdk/index.tsorpublic/vendor/kirocrew-app-sdk.mjs: every consumer imports./recommendationdirectly, so a barrel export would be a zero-consumerone-way-door addition riding along in a fix. Apps already get the behaviour
through the exported
parseOptions, whoserecommendedfield subsumes it.docs/app-kit/api-reference.mddocuments that FIELD for out-of-tree appsand explicitly withholds the marker's wire spelling and placement from the
published contract, so apps bind to
recommendedrather than to the grammar.A SECOND, INDEPENDENT change ships in the same commit: Slack option clicks stop being
command-interpreted. This is not part of the marker feature above and is not scoped to
marked labels — it changes behaviour for EVERY Slack option click, including options that
carry no
(recommended)marker at all. It is declared separately here because the repoallows at most two commits per PR, one logical change each, so it CAN be landed as its own commit ordered first
this PR — a scope call left open below.
Slack option clicks no longer interpret a leading command token.
handle_message(src/kiro_crew/slack/handler.py) takes a newinterpret_commandskeyword,Trueby default so a human-typed message isunaffected, and the three Slack option-dispatch sites
(
src/kiro_crew/slack/interactions.py) passFalse. It resolves to oneinterpret_as_commanddecision every command branch reads, so a new branchcannot forget it. This applies to every Slack option click, not only the
ones carrying a marker, because an option label is model-authored either way.
The harm it closes is separate from the marker work and predates it: a label
whose first word is one of the nine bangs at
handler.py:155-166was executedon click rather than sent as turn content, so an agent-authored
!yolo onbecame
/kirocrew yolo onand changed the approval mode. The marker-stripguard cannot cover this —
!is not one of the reserved dispatch sigils(
/and@), so the guard has nothing to match and would strip such a labelhappily. Stated here as its own change rather than folded into the badge work,
since reverting the badge would reopen it.
The two promotion fences can no longer drift apart. The fence is implemented
twice by construction —
strip_recommended_marker(Python, channel dispatch) andsplitRecommendation(TypeScript, dashboard dispatch) — because each runtimedispatches a clicked label itself. The shared vector fixture pinned the forms that
exist today, which says nothing about the next one: a slash command added to one
grammar and forgotten in the other would let a marker strip promote a
model-authored label into a real command on the surface that was missed, with every
existing test still green.
test/test_promotion_fence_drift.pyasserts theinvariant instead, in both directions. Every reserved list must be either PAIRED
with its frontend symbol and match it, or declared single-surface with a written
reason; a list or symbol that is neither fails the completeness test, so a seventh
one cannot skip the pairing. Verified by mutation in four shapes — a Python entry
the TS array lacks, an alternation branch it lacks, a brand-new backend list, and a
brand-new frontend symbol — each of which the gate catches.
The marker is instructed on the dashboard ONLY. The dashboard is the surface that paints the badge. No channel producer rule asks for the marker, so a channel label carrying one is model drift rather than protocol, and
strip_recommended_markerkeeps it out of the dispatched string as a defensive measure rather than as half of a paired feature. An earlier revision added a channel-side producer rule and aRecommended: <label>restatement; both are withdrawn, which also removes the hardcoded English prefix that restatement shipped to every locale.Three riders declared, because none of them is the badge
A Slack click routed to a linked dashboard slot now delivers its turn rows AND carries its
action context. Two failures were traded against each other before this settled. Refusing to
route kept the payload but left the linked slot with neither turn row while its session
advanced. Composing the payload into the dispatched text restored the rows and opened a worse
hole: the dashboard runner expands
$skillover user text, so model-authored payload textjoined to it would load local skill bodies. What ships carries the payload OUT OF BAND instead —
on the queue item's
meta, read back on the drain and handed to the context builder asaction_context, whose reader already exists in the base tree. The rows land, the payloadreaches the turn, and nothing expands, because the payload never enters the dispatched text.
Provenance is what closes the expansions: a clicked label is flagged model-authored, which
blanks the leading command word before any slash,
@promptor$skillarm reads it.A merged drain keeps EVERY clicked payload — a separate defect, declared here rather than
left to its tests. A busy slot's queue drains into ONE turn, so a batch can carry several
clicks, and taking only the first payload silently dropped every later one.
pair_action_contextspairs each payload with the label it arrived with, which matters because the labels are
concatenated and a payload alone cannot say which one it belongs to; a lone click still passes
through unwrapped so the ordinary turn is byte-identical. This is not part of the badge and
would be worth fixing without it.
The label width floor applies only to a BADGED chip. The badge is
shrink-0and cannotgive width back, so beside it an unfloored label absorbed the whole squeeze — a 24-character
en-XAbadge left about one word of its neighbour readable. The floor is 12ch and it ispassed only where the badge renders; an unbadged chip keeps
min-w-0, so this does notchange any chip that has nothing competing with it.
Tests
src/test/recommendation.test.ts(new, 33): the split at the leading andtrailing edge; that both ordering variants are REJECTED; case-insensitivity; a negative
control that
(destructive),(see below)and(recommended by nobody at all)are not recommendations; the marker-only label; a no-regex-state guard;and the three regressions this turns on — an EDGE marker never survives into a
dispatchable label, an INTERIOR one is never removed from it, and stripping
never promotes a label into a dispatched command, by slash or by
@mention. Plan chips(
Go,Go All,Cancel) are asserted byte-identical, sinceusePlanActionMutationdispatches on exact label equality.src/test/FollowUpBar.test.tsx: its form is pinned against the existingspec-decision badge — a trailing uppercase micro-label rather than a leading pill, matching
apps/spec-builder/components/SpecStatePanel.tsxso the same word does not render intwo shapes. Colour is the one deliberate difference: that sibling tints itself with the
accent, which on a chip is the SELECTION signal, so this badge keeps a neutral text
colour and the test pins zero accent tokens on an unpicked recommended chip. The badge
is also asserted to be a
sibling of the clamped
.truncatespan and never a descendant, with that spancarrying only the label. An assertion on the rendered text alone would pass
either way and prove nothing.
test/test_messaging_recommended_marker.py(new): the channel half, pinning theno-strip decision. Its opening line is "A channel does not strip a
(recommended)marker; it renders it as label text", and
TestTheChannelLeavesTheMarkerAloneasserts a leading marker survives into the choice unchanged. Its companion
test/test_channel_recommendation_not_restated.pypins that nothing is restated inits place.
test/test_slack_option_click_not_a_command.py(new): every top-level command branchin the Slack handler tests the flag, and both option-click dispatches pass it as
False. Mutation-verified: ungating the!family fails 4, dropping the flag from onedispatch fails 1, and removing all of it fails 7.
test/test_slack_linked_option_routing.py(new): a command-shaped label clicked as anoption lands in the linked slot's queue rather than falling through, and a user-typed
bang still falls through to the command handler. Mutation-verified: ungating the
fallthrough fails 5.
test/test_dispatch_sigil_parity.py(new): fails if the/,@,[deny listdiverges between the backend tuple and the frontend list, so a fourth dispatch
prefix cannot be added to one surface alone. The same suite pins the
action::dispatch protocol, which the single-character sigil tuple cannot express, against the action router's own spelling, and asserts the frontend guard actually consults the mirrored list rather than merely declaring it. It also asserts the extraction found anon-empty list, since an unreadable list would make the comparison vacuous.
test/test_context_critical_rules_assembly.py(new): pins the backend producerhalf — that the dashboard block instructs the marker and the channel block does
not, that the LIVE surface rather than the session's origin decides which block a
turn receives, that no ORDINARY channel turn retracts the instruction (the resume
path is the deliberate exception, pinned separately), and that every reserved
dispatch prefix the backend byte-matches opens with
[, which is the property thefrontend guard relies on. Each arm is mutation-verified: re-adding a retraction
paragraph to an ordinary channel turn fails the absence test, and unbracketing one
backend prefix fails the prefix test. A positive control asserts the scan reaches a
real channel turn, and a
guard asserts the channel's own diff rule was not removed alongside the retraction.
capture/followup-recommended-badge.{html,tsx}+scripts/capture-followup-recommended-badge.mjs(new): real-layoutmeasurement, because the DOM contract above is necessary and not sufficient — a
badge outside the span but pushed past the chip's edge satisfies every class
assertion and is still invisible.
__measure()takes a Range over the marker'sown characters and compares its rect against the chip's painted box.
fix=offrenders upstream's shape verbatim, so the before arm is asserted to reproduce
rather than assumed. 12 of 12 assertions pass across both themes.
1683/1683files,26613tests.tsc -bclean.eslinton thechanged files: 0 errors, and the 22 pre-existing hook warnings in
ChatPage/SideChatare unchanged from main (measured both ways).main;git patch-id --stableidentical before and after.The harness earned its place on its first run: it failed, because the initial
measurement tested horizontal overflow.
line-clamp-1isdisplay:-webkit-box+-webkit-box-orient:vertical, so an over-long labelwraps and later lines are clipped — the marker disappears downward, and a
horizontal test reports it visible. The paint test now checks both axes, so it is
correct under either clipping mechanism.
It caught a second thing later, which is why the framing above is what it is. When the
fixture was moved to the sanctioned leading marker, the old
fix=offassertion — "markerNOT painted" — went red:
markerVisible=true, because a leading marker is never clipped.The measured defect is therefore not invisibility, and the arm now asserts what is
actually true pre-fix:
markerInLabelis true, i.e. the marker is part of the label aclick dispatches. The
fix=onarm asserts the converse plus the badge.Note on overlap
#7125 is open on the same
ChipLabelline, swappingline-clamp-1 break-wordsforblock truncate. Thetwo are complementary and this PR does not depend on which lands first: that one
changes how the label is trimmed, this one moves the marker out of the trimmed
element. If it merges first, the badge is unaffected and only this PR's test
selector for the clamped span needs updating — happy to rebase onto it.
Security-relevant behaviour change on Slack, stated explicitly
The channel-side marker strip alone does not cover
!-commands, and this is thepart of the diff a reviewer would otherwise have to find for themselves.
Stripping
(recommended)cleans the label, but it says nothing about what the cleanedlabel is.
(recommended) !yolo onstrips to!yolo on, and Slack read a clickedoption through the same path as a typed message — so the click ran the command, turning
on process-wide auto-approval. The frontend sigil guard cannot close this: it can only
enumerate prefixes (
/,@,[) and!commands are a separate family reached by adifferent branch.
interpret_commandsis new onslack/handler.py::handle_messageand passed asFalsebyboth option-click callbacks. It fixes a PRE-EXISTING privilege escalation and does not
depend on this feature: before any marker existed, a model-authored label spelled
!yolo onwas already click-executable, because an OPTIONS label is turn content whateverit looks like. So this half stands on its own, and reverting the badge would reopen the hole
rather than restore a safe state. With the flag off,
!yolo,!agent,!compact,status,sessionsand the!temporary/!incognitoprivacy modifiers are no longerreachable by clicking a chip. A user who TYPES any of them is unaffected —
the flag defaults to
True. This mirrors the Telegram and Discord dispatchers, whichalready pass the same flag on their callback paths.
maybe_route_linked_threadtakes the flag too. It deliberately lets a bang command fallthrough to normal handling so one can still be run inside a linked thread; for a
model-authored label that fallthrough would persist the turn under the dashboard key
while the linked slot's transcript never saw it, so a command-shaped click would resolve
to a different slot than an ordinary message from the same thread. With the flag off the
fallthrough is suppressed and both resolve identically.
Channels leave a drifted marker as label text and restate nothing
Six renderers parse the trailer through
messaging.renderer.split_options_trailer, whichleaves the marker in the choice — so on those channels it is displayed and dispatched
verbatim as inert label text — and appends nothing in its place. That is a decision, not a gap, and two facts drive it. No channel producer rule
asks for the marker — only the dashboard is instructed to emit one, and
_OPTIONS_RECOMMENDED_RULEis wired into the dashboard block alone — so a marker arrivingat this seam is model drift, and restating drift would give it protocol standing. And the
two-value wrapper has no recommendation identity to restate WITH: it drops that identity by
contract, which
test/test_recommendation_seam_parity.pypolices, so the choice a linewould name is not knowable there.
test/test_channel_recommendation_not_restated.pypinsboth halves — the marker leaves the dispatched value, and the body gains no line.
Slack is the one surface that CAN name the choice, because it does not use this parse at
all:
slack.format.extract_options_with_recommendationcarries the identity explicitly andrenders its own
*Recommended:*context block, cut at the same checkbox cap the optionitself is cut at.
Cost of moving the marker out of the label
Recorded as a cost statement, not a proposal: the marker's placement is an open design
question and this section only measures what the alternative would remove.
The marker sits inside the label a click dispatches, so the strip needs a guard for every
value that must not be promoted. Moving it to an out-of-band control tag removes the need
for that guard entirely. Measured by AST at this head:
action::)test/test_dispatch_sigil_parity.pytest/test_injected_provenance_parity.pytest/test_reserved_plan_actions_parity.pytest/test_reserved_provenance_parity.pytest/test_dispatch_prefix_declared.pySo 3 of 4 suites and 353 lines go, along with the frontend mirrors of all four lists. The
badge itself survives the move:
keepVisibleMarker.tsis the in-repo precedent for acontrol tag that renders as nothing, and
strip_control_commentsalready removes such tagsfrom every plain-text projection. The remaining cost is that label-to-tag correspondence becomes a validation concern
rather than a structural one. The grammar is NO LONGER published SDK surface: this PR
documents only the
recommendedfield and states that the marker's spelling andplacement are not part of the published contract, so moving out-of-band later needs no
app-author migration and is no longer a one-way door.
Why the Slack interpretation flag stays in this change
It lands inside this commit, and the consequence is stated rather than implied. An
earlier revision of this description claimed the repo enforces one commit per PR. That was
wrong:
AGENTS.mdallows "one logical change per commit, and at most two commits per PR",so a security commit ordered ahead of the badge IS available here and the split is the
right shape. It has not been made yet. The ordering dependency it used to carry is now
GONE:
!is a reserved dispatch sigil as of this revision, mirrored inconstants.pyandrecommendation.tsand pinned by a shared-fixture vector, so the strip declines(recommended) !yolo onand leaves it whole. The badge no longer depends on the flag.The cost a reviewer should see plainly: reverting this commit reverts the flag with it, so
a revert of the badge is also a revert of the privilege-escalation fix. If that coupling is
unacceptable, the flag needs its own PR ordered first, and that decision is a maintainer's.
Why the channel seam restates nothing, given two lanes asked for opposite things
Worth stating plainly, because the two remedies for the doc/code mismatch pull apart. One
asks for the append to be implemented; the other asks for the channel strip to be deleted
entirely and a drifted marker left as inert label text. Both would cure the mismatch. The
shipped shape is the middle one, and it is chosen from what the tree already asserts rather
than from taste: the strip stays, because a marker must not reach a dispatched value, and
nothing is appended, because the seam that would append has no recommendation identity —
test_recommendation_seam_parity.pystates that the two-value wrapper drops it by contract,so an append there could only name a choice it cannot know is the right one. Implementing it
would mean either widening that seam's signature or guessing, and it would restate a steer
no channel producer rule ever asked for.
The narrower reading also matters: with the channel rule instructing no marker, the code
path exists only to contain drift, so documenting it as containment is the honest
description. This is the reasoning, not a rebuttal — the mismatch is fixed in the tree, in
docs/system-specs/modules/messaging.md, in this section, and in a test that fails if arestatement is ever appended.
The two-value
extract_optionsis deletedA review asked whether
slack/format.py::extract_optionswas dead. An earlier revision ofthis description argued it was live and should be kept; that was wrong about the outcome, and
this diff DELETES it. Its one real consumer discards the choices it returns, so that call site
now uses the three-value
extract_options_with_recommendationdirectly(
subagent.py:101imports it,subagent_manager/run.py:1634calls it). Only one spellingsurvives, and two ratchets pin that:
test_recommendation_seam_parity.py:80asserts nodef extract_options(exists in the module, andtest_slack_mirror_recommendation.py:186asserts the attribute is absent, so a re-add fails the suite rather than passing silently.
Why the dashboard chip dispatch does not carry
interpret_commands=FalseThe review asks which dashboard entry points would take the flag that Slack now uses, and
why it was not taken there. Naming them: a chip click reaches
src/kiro_crew/dashboard/handlers/messaging.py::api_send_message, and the interpretationthat matters for a marked label is the first-word stop match in
src/kiro_crew/dashboard/chat_handlers.py(message.strip().lower().split()[0] in _RESERVED_STOP_WORDS).The flag was not extended there because the two surfaces differ in what the dispatcher can
see. On Slack the option click arrives at a dispatcher that ALREADY takes
interpret_commands(slack/handler.py), carried by four transports, so Slack was aparameter already on the seam. The dashboard chip click arrives on the same endpoint as
text the user typed, with nothing on the request distinguishing the two, so the flag has no
argument to read: giving it one means adding a provenance field to the send contract and
teaching every consumer of that endpoint to honour it. That is a larger, separable change
than this PR, and until it lands the guard lists are what stand between a model-authored
label and a dispatch — which is why they are here rather than replaced.
This is an ACKNOWLEDGED cost, not a claim that the fence is the better shape. The
dashboard counterpart of the hole Slack just closed is still open: a bare
/clear,@deployorGo Alllabel an agent authors still executes on click, and only Slack gotthe flag in this PR.
Screenshots
Not committed:
.gitignorereservestemp-screenshots/for local capture output and states thatreview evidence is uploaded as a GitHub attachment, never tracked. Twelve frames were briefly
committed here and have been removed from the tree for that reason.
Every frame is reproducible from a clean checkout, deterministically and without a running app:
website/scripts/capture-followup-recommended-badge.mjswrites twelve frames across six statesand two themes, and asserts 44 measurements against the real rendered box before it writes any of
them -- including that the BEFORE arm still reproduces the defect, so an after-frame cannot pass by
the label having simply got shorter. The states are:
marker-inline-unbadged-*badge-beside-label-*badge-on-picked-chip-*marker-kept-on-guarded-label-*bare-command-chip-*mixed-hold-note-*The assertions are the machine-checkable half of that table and they run in the capture, so a
frame that disagreed with its row could not be written.