Skip to content

fix(channels): grade the delivered sequence so a split cannot rejoin a key - #13836

Closed
chenmingwei23 wants to merge 2 commits into
mainfrom
fix/cross-delivery-redaction-13743-v3
Closed

chenmingwei23 wants to merge 2 commits into
mainfrom
fix/cross-delivery-redaction-13743-v3

Conversation

@chenmingwei23

Copy link
Copy Markdown
Contributor

What is the problem?

Supersedes #13828, which in turn superseded #13758. Each replacement exists for the
same mechanical reason: taking a review fix while staying inside the two-commit limit
needs the commits reshaped, and a reshaped branch cannot be published by a
fast-forward push. Cutting a fresh branch publishes the same two commits as a plain
create instead. No review had been left on either predecessor.

Six channel delivery paths cut model text on a length budget and scan each piece on its
own. A credential the cut severs matches nothing in either piece, so both are reported
clean and the reader rejoins the halves reading one message and then the next.

Five of the six already redact the whole buffer before splitting, and that closes a cut
that lands mid-line: the credential is one marker before any boundary can reach it. It
does not close a cut at a line boundary. Sealing a chunk trims the whitespace that
ended it, and the next chunk starts at the first character after that whitespace, so the
two halves end up flush against each other on screen while the whole text still holds the
break between them. That form is invisible to a scan of the text as written and to a scan
of either piece.

Why this issue matters to the user

The reader sees the key and nothing reports it. Because each piece scans clean, no
redaction notice is emitted and the delivery is recorded as a clean send: the operator has
no signal at all. This is the audit half of the problem, not only the disclosure half.

How our fix solves it

The boundary is where the defect lives, so the fix goes into the two shared splitters
rather than into six renderers. split_markdown_safe and chunk_utf8_bytes take an
optional redactor and, when given one, reduce the text before any boundary is chosen:

  1. the text is redacted against the rendered form first, via the existing
    redact_for_display, which closes a cut landing mid-line and the markup-hidden variant;
  2. the boundaries it then chooses are graded on the RENDERED SEQUENCE. A platform drops
    the whitespace at a message's edges, so the last visible character of one message sits
    against the first visible character of the next and a trailing newline separates
    nothing. Stripping every chunk's edges before the grade is what makes the predicate see
    what a reader sees, and it is what carries the guarantee to the byte splitter, which
    stores the break rather than trimming it.

The whole sequence, not each neighbouring pair, because a key needs no more than a narrow
budget to span three chunks: split a twenty-character key over four and every pair holds a
fragment matching nothing while the screen holds the key whole. The same gap swallows a
chunk that renders to nothing at all, which the lossless byte splitter can place between
the halves. A fragment is only ever part of a key, so no pair of neighbours can be asked
about it. Both readings joins_to_a_credential names are kept, and each is scanned once
over the joined text rather than per boundary, which is what keeps the search affordable --
measured at 10.5 ms against 160 ms on a 74 KB reply, so the ordinary path is 15 times
cheaper than a per-boundary grade.

When a boundary does rejoin a key the cut is MOVED before any text is given up. Candidate
budgets step back one at a time for the first 128 and exponentially after that; the dense
prefix is what stops a budget clean at 6997 being stepped over by a walk that jumps 4, 8,
16, and the exponential tail keeps the reach without a probe per byte. Worst case 1.49 s on
a 74 KB reply, below the 2.2 s a purely exponential walk cost with the old grade.

A STREAMING caller cannot use that search at all, and this is the sharpest thing the change
had to get right. Such a caller re-splits its growing body every frame and treats all but
the last chunk as delivered, which whatsapp/turn_renderer.py states as its own
requirement: chunk i never changes once chunk i+1 exists. A search that reads the whole
body breaks it -- appending ONE character moved a boundary under an already-sent message in
a measured case, and the final pass slices the new list from the delivered count, so the
span is duplicated or dropped with no way back. That leg therefore takes a prefix-stable
split: the text is redacted, and every boundary stays where the caller's own budget puts
it. The same search space that produced a revision produces none under it.

Prefix stability says nothing about whether a BOUNDARY is safe, so the streaming renderer
grades each one against everything that follows before counting the chunk final, using
joins_to_a_credential, which main already has. A chunk that does not pass stays in the
live bubble, where a later frame may still revise it; at finalization every chunk must go,
so the still-unsealed tail is repaired through repaired_for_delivery rather than held.

Only when no budget at or below the caller's cuts safely is text given up, and then only
the credential's own span. There is no wider fallback that strips a whole message: when no
span names the key, the splitter DECLINES TO CUT and returns the text whole. A boundary is
the only thing that rejoins a key across messages, so creating none is fail-closed, and it
costs the caller a chunk over its limit instead of costing the reader a reply stripped of
its whitespace and markup. A caller that bounds that chunk again has
repaired_for_delivery to grade what it produced. The span is found by SHRINKING -- a span known to collapse into
a key is trimmed from each end by half its width, the trim kept while what remains still
collapses into one -- so a message carrying two keys keeps the paragraphs between them. The
whitespace inside that span is closed up, which makes the key contiguous for the ordinary
redaction, and the loop returns only once the form with EVERY run removed reads clean. That
last condition is the promise to a caller that re-cuts these chunks under its own limit, and
it is why one grade at the end of such a caller is enough. For a key only the rendering
assembles, which no span of the literal text names, the answer is the canonical form -- the
one-directional trade redact_for_display already makes, giving up markup and keeping every
space and every break.

Grading chosen boundaries rather than every candidate is what keeps ordinary wrapped content
intact -- two lines that read as one key when glued are never joined by a cut, so they are
left exactly as written, and a fixture pins that.

The parameter is optional because a caller whose chunks land inside one message severs
nothing a reader can rejoin across messages. It is not optional for the six paths that do
turn one chunk into one message: those are enumerated in the tests, and any splitter call
there that omits the redactor fails. The check walks the AST and counts both shapes,
including the four sites that hand the splitter to asyncio.to_thread as a reference --
a check reading direct calls only would see three of the seven sites and silently pass the
rest.

Per path, all seven call sites:

path call before now
slack/renderer.py:875 split_markdown_safe, offloaded no whole-buffer redaction at the cut passes _redact_all
webex/renderer.py:396 chunk_utf8_bytes display-safe via webex_display_safe line-boundary seam also closed
whatsapp/renderer.py:302 split_markdown_safe display-safe before the split line-boundary seam also closed
teams/renderer.py:383 split_markdown_safe, offloaded display-safe via _display_text line-boundary seam also closed
teams/renderer.py:743 split_markdown_safe, offloaded display-safe before the split line-boundary seam also closed
wecom/renderer.py:306 split_markdown_safe, offloaded display-safe before the split line-boundary seam also closed
dashboard/chat_mirror.py:588 split_markdown_safe display-safe before the split line-boundary seam also closed

WeCom's streaming push already picks a credential-safe offset for the frame it is about to
send, and that path is untouched.

Two legs needed more than the redactor argument, both found by review and both reproduced
before they were fixed.

Slack bounds the splitter's output AFTER it has been graded. A logical line placed whole
carries its fence scaffolding on top, so a chunk can exceed the limit, and chunk_text then
blind-slices it and each slice is posted as its own message -- an ungraded boundary at the
very last step. _split_for_slack now grades that final sequence through the new
repaired_for_delivery and repairs it when it rejoins a key. One grade suffices because the
repair is only returned once its fully-collapsed form reads clean, which the tests check by
re-cutting the repaired text at five different caps.

The dashboard mirror's backfill composed its units inline on the loop thread. An imported
history row carries no size cap, the grade redacts and rescans each candidate boundary, and
the liveness watchdog exits the process after seconds of loop silence -- so one large row
could terminate the gateway. The units are now composed inside asyncio.to_thread, the same
offload the Slack twin already uses and this handler already uses for its selection read.

What tests we did

test/test_split_credential_boundary.py, 67 cases, every run scoped with an explicit -n0:

  • the seam, measured rather than assumed: the fixture's cut is shown to fall between the
    halves of a key, the two pieces are shown to scan clean individually, and the joined
    sequence is shown to hold the key;
  • a key spanning three and four chunks, where every neighbouring pair reads clean, on both
    splitters and across five narrow budgets;
  • a chunk that renders to nothing placed between the halves by the lossless splitter;
  • a key inside a link, which the canonicalised join loses to the label and only the
    per-side reading sees;
  • the dense probe: a budget off the doubling ladder is reached, asserted on the probe order;
  • the terminal, on text no budget can cut safely: the prose around the span survives byte
    for byte, every break and delimiter is kept, two keys keep the paragraph between them,
    the fully-collapsed form of the result reads clean, and the wider flush is shown to keep
    neither -- plus the end-to-end case through the byte splitter, where all seven breaks
    survive;
  • the post-bounding grade: a blind slice is shown to reopen the seam, the repair fires, a
    clean sequence needs none, and the repair stays safe when re-cut at five caps;
  • structural checks that the Slack path runs that grade and that the mirror composes its
    units in a thread;
  • prefix stability, which is the streamed-reply case: the searching path is shown to revise
    an already-sealed chunk after a single appended character, the stable path is shown not to
    across seven append lengths, and the stable path is shown to still redact;
  • structural checks that the streaming renderer asks for the stable split, grades its seam
    and repairs its tail, and that no global whitespace flush remains in the module;
  • one channel end to end, through the function WhatsApp's client sends from, asserting on
    the frames it would deliver;
  • backward compatibility: prose and a table row are returned byte for byte with a redactor
    passed, so existing callers are unaffected.

Mutation proof, seven ways, each against a pristine copy kept outside the repo and each
verified by hash to have applied and been restored. Three cover the streaming and terminal
work: stopping the renderer from asking for the stable split fails 1, making the stable mode
fall back to the search fails 2, and sealing without grading the seam fails 1. Four cover the
grade and the repair. Dropping the redactor from one of the
seven call sites fails the enumeration test. Replacing the dense probe with a doubling walk
fails the two probe-order cases. Sending the terminal straight to the wider flush fails the
end-to-end case, where the breaks drop from seven to zero. Widening the repair's span to the
whole text fails four cases, including the two-key one. A fifth mutation, dropping one of the
grade's two readings, initially failed NOTHING -- that gap is what the link case was added
for, and it now fails.

Regression, each file scoped with -n0: test_messaging_split.py 138 passed,
test_channel_table_rendering.py 82 passed (the reassembly invariant the byte splitter
documents), test_chat_mirror.py 82 passed, test_display_split_safety.py 50 passed,
test_whatsapp_renderer.py 46 passed, test_whatsapp_turn_renderer.py 39 passed,
test_security_posture.py 53 passed, test_slack_renderer.py 73 passed. Gates: black, isort, flake8, mypy on the changed files,
and the comment-history gate, all clean.

messaging/split.py is listed in NON_EGRESS_REDACTION_MODULES with the reason the
display-safety module gives: it applies a redactor its caller injects, owns no output, and
the modules calling it are the registered sinks.

The fixture uses the AWS-documented example key the repo's own display-safety tests
already use, so no new credential shape is introduced.

Any other suggestions on the work

This closes the issue for the six delivery paths it names: every boundary those paths
choose is now graded, and the enumeration test fails if any of them stops passing a
redactor. What it does NOT add is predecessor bookkeeping at each point a message stops
being editable -- a streaming leg that has already delivered a message cannot re-cut it, so
that piece has to be graded against what is already on screen. The channel-neutral
primitives for that are in #13494 and are not on main yet, so this change reuses only what
main already has and touches none of the files that PR owns. That bookkeeping belongs to a
follow-up once #13494 lands, not to the six paths this issue is about.

Two things found while measuring, worth recording. The splitter has callers beyond the six
paths named in the issue: discord/renderer.py (five calls), telegram/renderer.py,
feishu/client.py, messaging/renderer.py and teams/session_resume.py. Discord and
Telegram seal splitter chunks as separate messages and carry the same open seam, and both
files belong to #13494, which is rewriting them with the predecessor primitives -- so they
are stage-two scope here by construction, not an oversight, and this PR touches neither.
Feishu, the shared renderer and the Teams resume path are unchanged, and none of them
belongs to #13494. Their own code answers whether their chunks become separate messages
rather than leaving it open: feishu/client.py sends every chunk as its own reply to the
same inbound anchor, and chunk_for_transport hands its parts to callers that send them
one message at a time. Neither passes a redactor, so the seam is open on those legs too.
They sit outside this stage by scope, not by another PR's ownership. And the issue's per-file grade was measured by grepping for the new primitives'
names, which cannot see that five of the six paths already close the mid-line cut by
redacting the whole buffer first; the line-boundary seam is what was actually open at all
of them.

Pattern harvest

Rule candidate: enumeration test, added in this PR as
test_split_credential_boundary.py::TestEveryDeliveryPathIsEnumerated.

Pattern: a text is cut on a length budget and then scanned one piece at a time, so the scan
runs after the boundary is chosen and cannot see what the cut separated.

The shape generalises past credentials: any check that reads one piece of a text the caller
will deliver in several is blind to whatever the boundary split. It resists a purely
syntactic rule, because "these chunks each become their own message" is not visible at the
call site -- which is why the enforceable half is an enumeration: the delivery paths are
listed, and every splitter call in them must pass a redactor. The list is checked in both
directions, so a path that stops reaching a splitter fails rather than passing by having
nothing left to check, and the AST pass counts the offloaded asyncio.to_thread shape as
well as the direct call.

Closes #13743

Six delivery paths cut model text on a length budget and scan each piece
on its own. A key the cut severs matches nothing in either piece, so both
are reported clean, and the reader rejoins the halves reading one message
and then the next. The per-piece scan emits no notice, so the operator
sees a clean send.

Five of those paths already redact the whole buffer before splitting,
which closes a mid-line hard cut. It cannot close a cut at a line
boundary: sealing a chunk trims the whitespace that ended it, so the two
halves sit flush against each other on screen while the whole text still
holds the break between them, invisible to a scan of the text as written
and to a scan of either piece.

The shared splitters now take the redactor themselves. split_markdown_safe
and chunk_utf8_bytes reduce the text before any boundary is chosen: the
form the platform renders, and the form the seal's trim produces once
every break is collapsed. A credential visible in either is a marker
before a boundary can land inside it. The parameter stays optional, so a
caller whose chunks stay inside one message is unaffected, and an
enumeration test over the six delivery paths fails when any splitter call
there omits it.

Refs #13743
Grade the boundaries the ladder chooses, one at a time, rather than every
break at once. A scan of all of them together answers a wider question than
any cut asks: two lines that read as one key when glued would cost the message
every break and its markup, though no cut ever joins them. Wrapped content in a
fence is that shape.

The grade reads the RENDERED pair. A platform drops the whitespace at a
message's edges, so the last visible character of one message sits against the
first visible character of the next: neither a trailing newline nor a trailing
space separates anything. That is also what carries the guarantee to the byte
splitter, which stores the whitespace rather than trimming it -- lossless where
it is kept, invisible where it is shown.

The repair moves the CUT before it gives up any text. Budgets step back
exponentially and every candidate is verified, so a key straddling a boundary
ends up whole inside one chunk with every character and every break intact,
where the space between its halves is on screen and the scanner's own reading
of such text stands. Only when no budget at or below the caller's cuts safely
is the whitespace flushed and the text redacted -- every run, because the
whitespace a cut consumes can be a single space -- and that result is graded as
well, since a repair returned without a grade is a repair nobody checked.
Flushing every run is deliberately wider than one cut produces: that width is
what lets a caller bound the chunks again under its own platform limit without
a grade of its own.

The splitter applies a caller's redactor, so it is classified in
security_posture's NON_EGRESS_REDACTION_MODULES. It owns no output; the modules
that call it are the registered sinks. Same reason display_safety.py sits
there, and the posture drift guard fails without the entry.

Refs #13743
@github-actions

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — 🟡 CONCERNS

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

Design-Verdict: CONCERNS

Spec still promises a pure, prefix-stable, lossless splitter the new modes break, and three named delivery paths keep the seam open, unowned.

Watch

  • docs/system-specs/modules/messaging.md §Fence-safe splitting states "stdlib-only and pure — no config objects, no modes," unconditional prefix stability ("every cut depends only on the text BEFORE it"), and that chunk_utf8_bytes concatenation "always equals its input." The diff adds redactor/stable modes, an import of display_safety, a budget search that reads the whole body (the exact boundary-moving behavior the PR measured corrupting a delivered message), and conditional losslessness — with zero doc changes, despite AGENTS.md's same-commit rule. A future streaming caller reading the spec takes the unsafe default.
    Clears when: messaging.md's split.py contract is updated in this PR to state the redactor modes, the stable-only streaming guarantee, and conditional losslessness.
  • The description names feishu/client.py, messaging/renderer.py::chunk_for_transport, and teams/session_resume.py as carrying the same open seam "outside this stage by scope, not by another PR's ownership" — so the disclosure persists on those legs with no tracked owner, unlike Discord/Telegram (fix(channels): grade the rotation boundary the splitter cannot see #13494).
    Clears when: a follow-up issue covers those three call sites, or they pass a redactor here.

Suggestions

  • Invert the enumeration test: require every splitter call repo-wide to either pass a redactor or sit on an explicit "chunks land in one message" allowlist, so a new channel fails closed instead of shipping the seam.

[DESIGN-REVIEWED] 4847a18

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Superseded by #13839, which carries the same two commits plus the fixes Opus raised on this head: the Webex final answer now offloads its credential grade instead of running it on the event loop, and the span repair is bounded by a constant. Reshaping the commits to take them cannot be published by a fast-forward push, so the replacement is a fresh branch. No review had been left here.

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

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — 🟡 CONCERNS

Premise-level review of 4847a1851bd278e051b480ae98878802601d8203 — 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

The seam this fixes stays open on Discord, Telegram, Feishu, Weixin and chunk_for_transport — six guarded paths are six of roughly eleven, while the test claims completeness.

Not justified as shipped

  • Item 1 — point patch: the description's "Six channel delivery paths cut model text on a length budget" is six of the paths that do; grepping split_markdown_safe|chunk_utf8_bytes|chunk_for_transport finds the same one-chunk-one-message seam unguarded at discord/renderer.py:941,962,966,1219,1244 (streaming rotate, same shape as the WhatsApp leg fixed here), telegram/renderer.py:400, feishu/client.py:213, weixin/renderer.py:106 (its own _hard_split blind slice — the exact shape repaired_for_delivery was built to grade), and messaging/renderer.py:140's chunk_for_transport with 4 delivery consumers (chat_runner.py:4117, slack/gateway.py:3931, handlers/messaging.py:2182,2474). The new test's docstring says DELIVERY_PATHS is "Every path that delivers one splitter chunk as one message"; it is not.
    Clears when: those paths pass the redactor the shared splitters now take, or the deferred remainder is named on the PR.
  • Item 4 — one consumer, generalized: stable= on split_markdown_safe is passed by exactly one caller (whatsapp/turn_renderer.py:288 via render_chunks_off_loop), and its branch is one pre-redact-then-plain-split line.
    Subtraction: fold the stable branch into whatsapp/renderer.render_chunks and delete the kwarg from messaging/split.py.
    Clears when: a second streaming consumer exists (Discord's rotate, once guarded) or the kwarg is folded away.
  • Item 8 — rides along: the dashboard-mirror backfill composition moved off the loop thread; derived from the grade's added cost (liveness watchdog), not visible in the (truncated) description.

What this change ships

Inventory (10 items) — 7 justified

Intent: FIX — stop a credential severed at a chunk boundary from reading whole across adjacent channel messages while every scan reports a clean send.

  1. A key cut at a line/space boundary no longer rejoins across messages on six paths — point patch: siblings counted above
  2. When no budget cuts safely, only the key's span is redacted, else the text ships whole over the limit — justified
  3. Both shared splitters take an optional redactor (7 call sites pass one) — justified
  4. stable= flag on the shared splitter for streaming callers — one consumer, generalized
  5. New repaired_for_delivery regrades chunks a caller re-bounds (Slack, WhatsApp flush; 2 consumers) — justified
  6. WhatsApp streaming holds a chunk with an unsafe boundary in the live bubble instead of sealing it — justified
  7. Slack's post-split byte-bounding is graded once at the end — justified
  8. Dashboard-mirror backfill units composed on a worker thread — rides along
  9. messaging/split.py registered in the security-posture non-egress redaction list — justified
  10. AST test forces every splitter call in the six paths to pass a redactor, offloaded calls included — justified

[FIRST-PRINCIPLES-REVIEWED] 4847a18

@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 4847a1851bd278e051b480ae98878802601d8203. 1 of 1 blocking finding(s) are security-class and were withheld from adjudication, so the blocking verdict stands.

This comment is updated in place on each push.

BLOCKING -- src/kiro_crew/whatsapp/turn_renderer.py:248 -- streaming grade preserves message-edge whitespace
if joins_to_a_credential(chunks[index], "".join(chunks[index + 1 :]), _redact_all):
Key halves separated by a chunk-leading newline -> grade passes -> WhatsApp removes the newline and displays the credential.
Anchor: backend-security-controls
Fix: grade the whole remaining sequence after stripping each chunk’s rendered edges.

FINDING -- src/kiro_crew/whatsapp/turn_renderer.py:532 -- repaired_for_delivery(pending, _redact_all) adds placeholders absent from the later chunks tally, so repaired credentials emit no redaction notice -> Fix: tally the actual delivered sequence, including repaired pending chunks.

[BLOCK-MERGE] 4847a18
[GPT-REVIEWED] 4847a18

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

Harm rung: UNBOUNDED (credential rendered whole to a chat reader).
Conditions confirmed: the stable split path does no boundary search of its own (src/kiro_crew/messaging/split.py:490-503), so the only seam gate before an irrevocable seal is joins_to_a_credential at src/kiro_crew/whatsapp/turn_renderer.py:248, which grades the raw strings (src/kiro_crew/messaging/display_safety.py:163-169) while this PR's own sequence grader strips every chunk's edges precisely because "a platform drops the whitespace at a message's edges" (src/kiro_crew/messaging/split.py:206-215, 239); recovery path: none — on_done repairs only chunks[start:] (src/kiro_crew/whatsapp/turn_renderer.py:524-532), and an already-sealed bubble is never revisited (turn_renderer.py:243).
Real fix cost: local — strip the same edges in the one grade call, the shape _rejoins_a_key already uses; no new state, no cross-module contract, so no rarity argument can carry a FLAG here.

[ADJUDICATION] 4847a1851bd278e051b480ae98878802601d8203 total=0 uphold=0 downgrade=0
[GPT-ADJUDICATED] 4847a1851bd278e051b480ae98878802601d8203

[ADJUDICATION-FENCED] 4847a1851bd278e051b480ae98878802601d8203 fenced=1 flagged=0
UPHOLD-FENCED F1 src/kiro_crew/whatsapp/turn_renderer.py:248 -- The streaming seam is graded on raw chunk text while this same PR's sequence grader strips message edges for exactly this hazard, the seal is irreversible and `on_done`'s repair never reaches an already-sealed chunk, so the condition combination is ordinary rather than extreme.
[GPT-ADJUDICATED-FENCED] 4847a1851bd278e051b480ae98878802601d8203

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

@github-actions

Copy link
Copy Markdown
Contributor

Opus 5 Review — 🔴 changes requested (blocking)

Reviewed 4847a1851bd278e051b480ae98878802601d8203 — this comment is updated in place on each push.

The WhatsApp seal loop grades a boundary with the one predicate in this PR that does not strip message-edge whitespace, so it can send an irreversible message whose successor's leading whitespace joins a severed key on screen.

BLOCKING — src/kiro_crew/whatsapp/turn_renderer.py:248

if joins_to_a_credential(chunks[index], "".join(chunks[index + 1 :]), _redact_all):

joins_to_a_credential never strips edge whitespace, while _rejoins_a_key — the grade every other delivery path in this diff uses — does (rendered = [chunk.strip() for chunk in chunks], split.py:239); with stable=True the seal loop is the only grade on this path, so text like …AKIAIOSFO\n DNN7EXAMPLE… (chunk sealed by _seal's body.rstrip(), successor keeping its indent) reads clean here, _seal_chunk posts it, and the same chunk list is then graded dirty by repaired_for_delivery at on_done (turn_renderer.py:532) — after the message is unrecallable and outside the pending slice it can repair.
Fix: strip the two sides as the new test's own _rejoins helper does — joins_to_a_credential(chunks[index].rstrip(), "".join(chunks[index + 1 :]).lstrip(), _redact_all).

FINDING — src/kiro_crew/messaging/split.py:353 — the fallback return redact_for_display(canonicalize_display(joined), redactor)[0] is reached exactly when _redact_only_the_rejoined_span rejected joined because _WHITESPACE_RUN.sub("", canonicalize_display(...)) read as a key, and it canonicalizes without collapsing whitespace, so it hands back text that still collapses to one — breaking the docstring's own promise that "no re-cut can uncover a key" for both callers, which re-cut blind (chunk_text(repaired, …) at slack/renderer.py:890, and split_markdown_safe, repaired, … with no redactor= at whatsapp/turn_renderer.py:537) → Fix: apply the same redactor(collapsed) == collapsed test to the fallback result and collapse the offending run when it fails, and pass redactor=_redact_all at turn_renderer.py:537.

FINDING — src/kiro_crew/webex/renderer.py:396 — chunk_utf8_bytes(content, WEBEX_MAX_TEXT, redactor=_redact_all) runs the new search (a redact_for_display pass plus up to _DENSE_PROBES+ full cuts, each with two canonicalize_display and two redactor passes over the whole answer) synchronously inside on_done, and repaired_for_delivery(pending, _redact_all) at whatsapp/turn_renderer.py:532 does the same while the cheaper split_markdown_safe two lines below it is offloaded — the loop-starvation the diff's own _compose_units docstring names → Fix: await asyncio.to_thread(...) at both sites, as the four sibling call sites in this diff do.

FINDING — test/test_split_credential_boundary.py:47 — DELIVERY_PATHS is commented as "Every path that delivers one splitter chunk as one message" but omits discord/renderer.py (941/962/966 → _seal_current + _open_new_message per chunk) and telegram/renderer.py:400, both still calling split_markdown_safe(text, limit) with no redactor, so the seam this change closes stays open on two channels while the gate reads as exhaustive → Fix: either pass redactor= at those sites and add them to the tuple, or say in the comment which paths are deliberately out of scope and why.

FINDING — src/kiro_crew/whatsapp/turn_renderer.py:249 — the bare return on an unclean boundary skips tail = chunks[-1] and await self._show(tail), so nothing reaches the live bubble on this or any later frame while the boundary stays unclean, contradicting the comment directly above it ("A chunk that does not pass stays in the live bubble") and freezing the visible stream until on_done → Fix: break out of the seal loop and show the unsealed remainder ("".join(chunks[self._sealed_count :])) in the live bubble instead of returning.

[BLOCK-MERGE] 4847a18
[OPUS-REVIEWED] 4847a18

Verdict parsed from the review's SHA-scoped output markers for commit 4847a1851bd278e051b480ae98878802601d8203.

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

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.

channels: seven delivery paths cut model text on a budget and redact per piece, so a severed credential reaches two adjacent messages

1 participant