Repository navigation
Conversation
|
👋 Hi! This PR is currently in draft status. Workflow runs won't be auto-approved until it's marked as ready for review. When you're ready, click "Ready for review" and the workflows will be approved on the next cycle automatically. |
Design Review (Opus 5.5, fork) — ✅ PASSDesign-level review of Design-Verdict: PASS Nothing blocks: one shared per-field rule covers all three ways a loop is served, takes nothing away, and fails closed with a placeholder instead of a 500 or a skipped event-log append. Notes
[DESIGN-REVIEWED] 89ddaf9 Description read[DESCRIPTION-READ] ef3f7df15fbfe45f0cd5cabc6bb29d05a836451a634fe7687e832e99c227e12f That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with |
First Principles Review (Opus 5.5, fork) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS The fix aims at the cause: three readers now share one per-field rule, which the base already expected. The two notes below are second spellings that can be deleted. Notes
What this change shipsInventory (6 items) — 4 justifiedIntent: stop a credential typed into an auto-nudge goal from being served back to dashboard readers. This is a FIX.
[FIRST-PRINCIPLES-REVIEWED] 89ddaf9 Description read[DESCRIPTION-READ] 4a4ab62091c388d8beb5819923dbb8dfeb37d2918d140e4816821a3ada514e58 That sha256 names the PR description this verdict read. Recompute it with |
GPT 6.1 Review (fork) — ✅ no blocking findingsReviewed Review detailsNo findings. |
Opus 5.5 Review (fork) — ✅ no blocking findingsReviewed |
74cac05 to
fcaad72
Compare
fcaad72 to
fd4eaad
Compare
fd4eaad to
54fa678
Compare
|
🤖 Kiro Crew [operator: NicholasRBowers#a942f9ca]: This PR has been inactive for 7+ days. I reviewed the blockers but they require your input: Your own later split PRs landed most of this on
What is still genuinely unique, if you narrow: the REST-egress denylist scrub. Decision 1 — where do refused rows live? This is a policy choice I cannot make, because the two sides contradict each other. Decision 2 — the one blocking review finding sits on exactly that superseded half. GPT 5.6 is 🔴 blocking on the current head Mechanical once you have ruled — none of this is a reason to hold:
When you've addressed these, the pipeline will re-assess on its next cycle. |
|
PR triage (2026-10-05): PARTIALLY_COVERED by I checked head Already on
Still missing on
Note: the comment above Rebase hazard (the API would break if this is missed): since this PR's base, Related open PR: #11027 (popover redaction UI) is complementary, not a duplicate. Its redaction notice works from the served text, and this PR's egress scrub is the server half that would supply it. The two should be sequenced together. Recommendation: rebase onto |
d96dda2 to
eb6c5a8
Compare
|
Requesting a maintainer carry-forward, which is what the Sensitive Change Review gate itself prescribes. The narrowing you both asked for is done and pushed; the remaining blocker is structural and I cannot clear it from a fork. The narrowing is completeHead Following bolichen97's triage and NicholasRBowers' earlier note, I rebuilt this on current
The dict-coercion hazard bolichen97 flagged is fixed and pinned. Why I am asking rather than pushing again
I confirmed that is not a soft refusal: That one file is 19 lines of additive sink documentation, and Three failures are not from this PR
Running your own It also cascades, so it is worth fixing for everyone: Two failures I can fix on request
I have a corrected description ready that passes Happy to split the |
UX Review (Opus 5.5, fork) — ⏭️ skippedRevision |
|
HOLD (policy: human review required) at 5206072. This PR changes what is redacted on every auto-nudge egress through one shared rule (handlers/autonudge.py#L134) and declares a new redaction sink (security_posture_sinks_gateway.py#L514). Credential-redaction changes are reserved for a human reviewer, and Sensitive Change Review fails on this fork head, so a maintainer has to carry it forward as the author asks. I found no defect in the scrub itself: addressing fields stay verbatim, dicts and lists are walked, and writes that echo the loop refuse before mutating. Unanswered on this head, please reply to each:
To clear: a maintainer takes the change onto a same-repo branch and approves it, and the four notes are answered. — crew-pr-reviewer (r129) |
|
HOLD (policy: human review required) at 0be2c30. This PR changes what is credential-redacted on every auto-nudge egress through one shared rule (handlers/autonudge.py#L135) and declares a new redaction sink (security_posture_sinks_gateway.py#L513). Redaction changes are reserved for a human reviewer, and Sensitive Change Review fails on this fork head, so a maintainer has to carry it to a same-repo branch. I found no defect in the scrub. Addressing fields and One observation, not a blocker: the broadcast guard in nudge_wiring.py#L282 protects the event-log append only for loops without a monitor. To clear: a maintainer takes the change onto a same-repo branch, reviews the redaction change and approves it. — crew-pr-reviewer (r133) |
|
HOLD (policy: human review required) at e308bfe. This PR changes what is credential-redacted on every auto-nudge egress through one shared rule ( KiroCrew/src/kiro_crew/dashboard/handlers/autonudge.py Lines 135 to 162 in e308bfe autonudge_state broadcast (KiroCrew/src/kiro_crew/slack/gateway_runtime/nudge_wiring.py Lines 282 to 313 in e308bfe This head is the r133 commit rebased onto main with no logic change. I found no defect in the scrub: addressing fields and AI findings judged non-blocking:
To clear: a maintainer takes the change onto a same-repo branch, reviews the redaction change and approves it. No PR code was run locally. — crew-pr-reviewer (r141) |
|
Holding this PR at e308bfe. Sensitive Change Review is red on this head, and the log gives a real reason, not a flaky run: this is a fork PR that changes a sensitive path (the gateway security posture sinks), and there is no reasoning template for this head. A fork PR cannot pass that gate. It needs a maintainer security review before it can move. The gate's own path for this is for a maintainer to take it over on a branch of this repository, keeping the author with |
bolichen97
left a comment
There was a problem hiding this comment.
Maintainer decision (security sign-off): we are not increasing security strictness, so the new refusals in this PR cannot land. The scrub itself can.
At e308bfe I split it like this:
- Keep: running every served loop field through the one
_scrub_serialized_fieldrule, so the REST payloads, the legacy reader and theautonudge_statebroadcast all redact the same way. This uses the existing redaction shim and refuses nothing. - Drop: the new refusals.
scrub_policy_unavailable()is now checked in_dashboard_admissionand before writes (_refuse_unscrubbable_write), and_read_scrub_unavailableturns the list and read routes into a 503. Each of those refuses a request that main serves today. The two existing 503s in the authorizers, which only move to the shared constant, are fine to keep.
Requesting changes for that. The branch also conflicts with main, so please rebase it when you push. Sensitive Change Review is red on this head and needs its reasoning template filled for the security path.
|
Re-reviewed at d695147: the change I asked for is done, thank you.
So the security direction is now neutral, and the code side looks good to me. What still blocks a merge is not something you can fix from here. Sensitive Change Review cannot pass on a fork PR that changes a sensitive path; its log says a maintainer has to re-open it from a branch of this repository and drive that branch green. I am flagging that to the maintainers. E2E, Integration and the redaction gate are still running on this head. |
|
Re-read at 3763d51. My earlier points are addressed, thank you: the new request refusals are gone, every served loop field goes through the one scrub rule, and no regex is added. One new thing on this head. In nudge_wiring.py, when the redaction policy cannot compose, the observer now drops the |
|
HOLD at 3763d51: @bolichen97's change request is still active, and this redaction change is reserved for a human. The new request refusals are gone, as @bolichen97 confirmed, and every served loop field still goes through the one AI findings judged non-blocking:
Also blocking: Sensitive Change Review is red on this fork head, so a maintainer has to carry the change to a branch of this repository. To clear: the author drops the frame-withhold path, @bolichen97 lifts the change request, and a maintainer takes the change over and approves it. I read the source and CI; I did not run any PR code. — crew-pr-reviewer (r146) |
KiroCrewCaptain
left a comment
There was a problem hiding this comment.
Thanks for narrowing this. One change is still needed at this head before it can merge.
src/kiro_crew/slack/gateway_runtime/nudge_wiring.py:282-312. The frame-withhold path adds a refusal that main does not have. Trigger: a host whose credential policy stops composing after startup, soredact_via_contextraisesPlatformCompositionError, and then a plain loop (no monitor) is added, updated or removed. Outcome:_scrubbedis set to False, so_publishreturns early. Theautonudge_stateframe that main broadcasts is not sent. Thecrew_work.worker_loop_moved(slot)refresh after it is skipped too, so conductor boards that name this worker keep a staleworker_loopingreading. That refresh carries only a slot key and no loop text. This conflicts with the body's "Removes nothing" and with "Any new refusal" under Not a goal. It is also the path a maintainer asked to drop on 2026-11-05. Smallest fix: delete_scrubbed = True(L282),_scrubbed = False(L287) and theif not _scrubbed: returnin_publish(L311-312). Keep the try/except, so the event-log append still runs before the publish. Reword the warning (L289-290) and the comment (L273-281) so they no longer say the frame is withheld. Removetest_an_unscrubbed_frame_is_never_broadcastintest/test_autonudge_egress.pyand keep the other guard tests. On a host whose policy composes, every frame field still goes through_scrub_serialized_field, so the Goal still holds.
Optional:
- The broadcast scrub only has AST pins. If the observer discards the result of
_scrub_serialized_field, the related tests still pass. The existingTestAutonudgeRouterAndObserver._wireharness intest/test_slack_gateway_coverage_nudge_routing.pyalready drives this observer with mocks. A short test there could arm a plain loop whosemessagecarries a secret, then assert the secret is not in the broadcast frame and thatidandslot_keycome through verbatim. That would pin the behaviour, and the docstring's "needs the whole gateway" claim could then be corrected. security_posture_sinks_gateway.py:527names onlyidandslot_keyas exemptions._scrub_serialized_fieldalso exemptsgoal_tokenandmonitor. Naming all four, each with its reason, would keep the sink text accurate.- The "adds no refusal" route tests use an empty store. Rendering one plain loop on a host whose policy cannot compose makes the list and slot routes raise where main answers 200. Narrowing the two docstrings (
test/test_autonudge_egress.pyL12-14 and L204) to what the tests show would keep the claims honest. Whether REST should fail closed there is a maintainer decision, and it does not need new code in this PR.
…ot reach a reader Every reader-facing projection now goes through one per-field scrub rule instead of a bare asdict, and both authorizers probe the credential policy before mutating.
|
Thanks for the rework. The review found no blocking defect at this head. It still needs a maintainer before it can merge. Follow-up on my earlier review (at 3763d51):
What still needs a maintainer:
What the review checked at this head: the REST serializer, the legacy reader, the in-session reading and the Optional:
|
|
Continuing this in #32954; thanks for the start. |
Problem / Motivation
Goal: A credential typed into an auto-nudge loop's goal is no longer served back to the people reading that loop in the dashboard.
A loop's own
messageandbannerwere serialized verbatim to every dashboard client. A credential typed into a goal was therefore served back in full to every reader of that loop, on every read, for as long as the loop existed.Why it matters
The goal field is exactly where a credential is most likely to be typed, because a goal often describes an operation against a real system. The serializer is the single point every reader passes through, so a gap there is a gap for all of them at once, not for one surface.
Not a goal
idorslot_keyat the load boundary. That refusal is what keeps the addressing exemption below safe, and it is already on this base inautonudge_service/store_loader.py— this diff has no hunks in that package and adds nothing to it.message_is_echoed_projection) is already on this base, and no test in the repository exercises it yet. That unit follows separately.[redaction unavailable]instead of raw text.autonudge_authz.py.What changed (motivation → approach → change)
The symptom is one field reaching readers unscrubbed, but the root cause is that each reader of a loop assembled its own payload, so there was no single place a scrub could cover all of them. Three arms project a loop: the full REST serializer, the reducing arm for legacy readers, and the gateway's
autonudge_statebroadcast.So the change is one per-field projection rule that all three call, rather than a scrub repeated at each caller — a second independent assembly would serve raw whatever the rule scrubs.
messageandstopped_reasonamong them, are credential-scrubbed on the REST list, the per-loop detail, and the echoedPOST/PATCHreplies.autonudge_stateWebSocket broadcast applies that same rule rather than a second copy of it, so a field cannot end up scrubbed on one surface only.stopped_reason, which is agent-supplied free text on a route with no owner gate.goal_tokenis exempt for the same reason: it is random hex the popover sends back asexpect_fingerprint, so a scrubbed token would refuse every save as a stale baseline. Today's tokens match no detector; the exemption keeps a future detector change from breaking saves silently.monitoris exempt too, because its nested state is already walked in place by the caller.message_is_echoed_projection), so an edited one is stored as typed. The write path already redacts incoming text the same way on base (authorize_and_update_nudge), so this is the existing inbound behaviour, not a new loss.judgereadings keep the shape the popover parses.[redaction unavailable]for each field it could not scrub (_project_field), so a list, slot read or a save that already committed answers 200, never 500, and serves no raw text. A policy broken at startup makes the loader refuse to arm any loop (store_loader.py), so this only bites a policy that breaks later. No route adds a probe or a 503 for it.reconcile_members_at_startupwould close the log asinterrupted, replacing a real reason permanently. The scrub is therefore guarded there. The frame is still broadcast, so a policy failure costs no event and no conductor-board refresh, but every field the scrub could not reach is replaced with[redaction unavailable]first (_withhold_serialized_field). The exempt fields, numbers, booleans and null pass unchanged, so the frame still addresses its row.Backwards compatibility
Compatible: no field is removed, renamed or newly rejected. Addressing fields still round-trip verbatim, numeric and container shapes are preserved, and ordinary text is unchanged because the redaction is shape-based and idempotent. No status code changes on a host whose credential policy composes.
Removes nothing: the diff adds a scrub and no refusal; no field, key, route or public function is hidden, deleted, tightened or migrated.
Tests
25 tests in
test/test_autonudge_egress.pyand two intest/test_slack_gateway_coverage_nudge_routing.py, all passing, grouped by what each locks in:messageand instopped_reasondoes not reach the client; the addressing fields survive verbatim; ordinary text round-trips unchanged. Includes a positive control that the redactor really rewrites the value used, so a passing assertion cannot be vacuous.goal_tokensurvives verbatim — a token shaped like a credential is served unchanged, while the same value inmessageis redacted as the control.judgeandjudge_last_verdictkeep their object shape, and a credential nested insidejudgeis still scrubbed.stopped_reason, and a nested key that merely shares an addressing field's name is not exempted.messageandstopped_reasondoes not reach the frame, while a credential-shapedidandslot_keypass verbatim. With redaction raising, the frame is still sent,messageandstopped_reasoncarry the placeholder, no raw secret appears, andid,slot_keyand a number pass unchanged.Each bound was mutation-tested: removing the
_serializescrub or thegoal_tokenexemption, re-adding a policy probe to the list route, the slot route or the arm path reddens a test. So does making the REST fallback re-raise, using the bare scrub in_serialize, the reduced row or the in-session reading, or letting the placeholder pass raw text (5/5 caught). Restoring the pre-fix raw send, letting the placeholder replaceid/slot_keyor a number, dropping the frame, or discarding the scrub result reddens the observer tests (5/5 caught).The 8,272-test autonudge / nudge-wiring / nudge-routing / security-posture / monitor / event-log / patrol / composition / app-decoupling selection passes with 0 failures.
black,isortandflake8clean on every file touched; Semgrep with CI's rule packs reports no findings.Manual verification
N/A — the surfaces under change are HTTP responses and one WebSocket frame, and the tests assert on the served payloads directly, including the shape the dashboard popover parses.
Related Issues
One unit of a split of #7996.
Scope
One unit of a split of #7996, which is 9.3x this repository's added-line cap and cannot be reviewed as a single change. This unit is the egress scrub alone, with no new refusal, and can merge on its own. The load-boundary refusal that keeps the addressing exemption safe is already on this base; the fingerprint gate that builds on this scrub follows separately, as does any operator-facing surface for held-back rows.