Skip to content

fix(slack): deliver a single-session dm reply when the edit is refused - #39257

Merged
KiroCrewCaptain merged 1 commit into
mainfrom
fix/36269-slack-flat-dm-renderer
Nov 19, 2026
Merged

KiroCrewCaptain merged 1 commit into
mainfrom
fix/36269-slack-flat-dm-renderer

Conversation

@bolichen97

@bolichen97 bolichen97 commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A top-level message in a single-session Slack DM gets its whole answer at the DM root, with no "transport path" error.

With slack.dm_single_session: true on the default messaging transport, the reporter's top-level DM turn ended with 🔧 Something went wrong (transport path). Please try again., the failure reaction, and no answer. Links that did show came out as raw <url|label> markup. The same request answered in a thread worked.

Why it matters

slack.dm_single_session is the only way to get replies at the DM root instead of in a thread. While a turn there can lose its whole answer, the setting cannot be used, and every one-line command reply in a DM needs its own thread.

Not a goal

  • Streaming, task cards or collapsible thinking at the DM root. Slack's chat.startStream streams only into a thread, so the root reply still shows a placeholder and is sealed at the end of the turn.
  • How thinking is shown in threads.
  • The native (non-transport) Slack path (messaging.use_transport=false, review-mode channels).

What changed (motivation → approach → change)

Symptom → cause. A flat DM's top-level reply has no thread, so SlackRenderer falls back to posting a _Thinking…_ placeholder and sealing the answer into it with one chat.update (_render_fallback). That edit carried the whole answer and was allowed to raise, so any edit Slack refuses reached the except in handle_message_transport. That handler posted _TRANSPORT_ERROR_TEXT and flipped the reaction to failure. Slack documents many such refusals: edit_window_closed under an org's edit-window setting, cant_update_message, ratelimited. A threaded reply streams and reaches that edit only when Slack refuses its stream, which is why the flat DM, which never streams, was the one hit. Fault injection over every Slack call of the flat turn confirms this: the final chat.update is the only call whose failure produces the transport error.

The links: the fallback sent the model's Markdown as a mrkdwn text field, and chat.update's parse defaults to client (unlike chat.postMessage). The stream sends the same text as markdown_text, which renders it.

Change. A new module slack/no_stream_reply.py (renderer.py is at the line cap) holds the no-stream delivery:

  • seal_placeholder edits the placeholder. If Slack refuses the edit (a 429, or an ok: false answer such as edit_window_closed), it posts the reply as its own message in the same place (DM root, or the thread). It reads a refusal with the rule the dashboard's proactive Slack sends already use (_slack_rejected_outright, plus _slack_rate_limited for the 429), so both paths agree on which answers may have landed. If that post fails too, the turn fails as before, so a reader who got nothing is still booked as a failure. After a timeout, a 5xx, or an internal_error / fatal_error answer, the edit may have landed, so the error propagates as before and nothing is posted. The rescue that runs when a turn fails (release_held_text) only edits the placeholder, so it never posts a second copy of an answer the turn's own post may have delivered.
  • The placeholder, the sealed reply, its overflow parts, the direct post (when no placeholder exists) and the held text a dying turn releases all go out as one Block Kit markdown block, with the same text in text for notifications. That is the grammar the stream's markdown_text renders, so links and emphasis render as they do in a threaded reply.

The owning spec lines are updated in messaging.md (→ SlackRenderer) and slack-gateway.md (Streaming UX).

Backwards compatibility

Compatible: no setting, signature or accepted input changes. SlackClientOps.update_message already took blocks, and post_blocks already existed. A threaded reply that streams is untouched. A threaded reply that falls back to the placeholder (Slack refused its stream, or refused every append) takes the same no-stream path: markdown block, and a post when Slack refuses the edit, where it used to fail the turn.

Removes nothing: the change adds a post when an edit is refused and changes the block shape of the no-stream reply. No path, key, record or public function is hidden or removed.

Tests

  • test/test_slack_transport_dispatch_flat_dm.py::TestFlatDmReplyDelivery::test_a_refused_edit_still_delivers_the_whole_answer_at_the_dm_root (new). It drives handle_message_transport for a top-level D… message with dm_single_session and show_thinking on, through a turn with reasoning, narration, a tool call and a final answer with links, against a Slack that refuses every chat.update with edit_window_closed. It asserts that no transport error is posted, that the whole answer is posted exactly once at the DM root (thread_ts None), and that every edit and post carrying it is a markdown block.
  • test_an_edit_that_may_have_landed_is_not_posted_again (new, same class): an edit that fails with internal_error, fatal_error, an HTTP 503 or a timeout raises, and nothing is posted.
  • test_a_post_that_may_have_landed_is_not_repeated_by_the_rescue (new, same class): every edit is refused and the answer's post times out. The answer is sent once, counting every post method, and the turn still ends with the transport error.
  • The shared fake test/conftest_slack.py MockSlackClient.update_message takes blocks, as SlackClientOps.update_message does.
  • Updated tests that pinned the old call shape (placeholder or answer via post_message): test_slack_renderer.py, test_slack_backports.py, test_channel_control_tag_strip.py and test_slack_status_reaction.py. Each keeps what it checks; test_slack_status_reaction.py refuses the block post too, so "nothing delivered → failure" is still what it proves. test_slack_post_message_call_sites.py lowers slack/renderer.py's direct-post_message row from 5 to 2. The fake in test_slack_thinking_order.py records a markdown-block post as a message rather than as the timing footer, so its no-stream cases still find the answer.

Proof: PROVEN test/test_channel_control_tag_strip.py::TestSlackRenderer::test_no_stream_final_text_is_stripped, test/test_slack_post_message_call_sites.py::test_no_new_direct_post_message_call_sites, test/test_slack_renderer.py::TestStreamMachinery::test_no_stream_falls_back_to_chat_update, test/test_slack_renderer.py::TestRendererPresentationGuards::test_raising_start_stream_and_placeholder_still_delivers, test/test_slack_transport_dispatch_flat_dm.py::TestFlatDmReplyDelivery::test_a_refused_edit_still_delivers_the_whole_answer_at_the_dm_root (head e33c52d3b76a)

Determinism of the three new tests (no sleeps, no wall clock, no network, every await bounded by the scripted turn or an AsyncMock), on the head's tree (37f90949; the proof host applied this commit with git am, hence its own head id):

run 1..5: 6 passed            (5 consecutive runs of the 6 new ids, -n0)
reversed order: 31 passed     (whole file, collection order reversed; pytest-randomly is not installed on the host)
prove.py: PROVEN             (production hunks reverted: the new tests and the updated ones fail)

Gates on that tree: all 66 entries of the project profile's gate list (black, isort, flake8, mypy src/kiro_crew, the scoped backend and frontend test runners, the frontend build, tsc, eslint, jscpd, test:electron and the other checks) exit 0, plus scripts/local-gate.py (backend related: 18,155 passed; frontend related: 14,526 + 6,902 passed), semgrep on the diff (0 findings), the flake-pattern ratchet (75 passed) and the changed and neighbouring Slack test files (466 passed). This diff touches no website/ file.

Manual verification

How it was verified, on Ubuntu 24.04 (Linux). Real Slack is not reachable from the host. The product's own path was driven instead: handle_message_transport, the real SlackRenderer, TurnDriver and RealSlackClient. Underneath sat a fake AsyncWebClient that refuses what Slack's API reference documents: chat.startStream without thread_ts → invalid_thread_ts, chat.appendStream on a non-stream message → message_not_in_streaming_state, assistant.threads.setStatus without a thread refused, and chat.update needing a real ts and non-empty text. Runs were made with and without a chat.update refusal (edit_window_closed).

Before, with the edit refused (flat DM, top-level):

chat.postMessage: {"text": "*Thinking*\nLet me look at the tracking files first."}
chat.postMessage: {"text": "_Thinking…_"}
chat.update: "REFUSED edit_window_closed"
chat.postMessage: {"text": "Error: Something went wrong (transport path). Please try again."}
  File ".../slack/renderer.py", in on_done
    await self._render_fallback(clean_text or "")
  File ".../slack/renderer.py", in _render_fallback
    await self.slack.update_message(self.channel, self._stream_ts, first or _NO_RESPONSE)
slack_sdk.errors.SlackApiError: chat.update: edit_window_closed

After, same script:

chat.postMessage: {"text": "*Thinking*\nLet me look at the tracking files first."}
chat.postMessage: {"blocks": [{"type": "markdown", "text": "_Thinking…_"}], ...}
chat.update: "REFUSED edit_window_closed"
chat.postMessage: {"blocks": [{"type": "markdown", "text": "I'll read the tracker first.\n\nNow the second file.\n\nHere is what I found:\n- <https://example.com/a|Open> the first\n- <https://example.com/b|Open> the second"}], ...}
-> transport error posted: False

When Slack accepts the edit, the placeholder is sealed with the answer as a markdown block, with no extra post. When the edit times out or Slack answers internal_error, the turn ends with the error text as before and the answer is not posted a second time. When the edit is refused and the answer's post then times out, the answer is posted once and the turn ends with the error text; the rescue after it does not post the answer again. A flat turn with no tool call and no thinking behaves the same in both cases. The threaded control's Slack calls are identical before and after, apart from the elapsed time in the footer.

Two known edges. After a refused edit the _Thinking…_ placeholder stays above the posted reply. No delete is tried, since an org that refuses edits may refuse deletes too. And in a workspace that refuses edits, a turn that fails before its reply is sealed does not show its held text, as on main: the rescue only edits the placeholder and never posts a second copy. The answer can still show twice when the turn's final send may have landed and the rescue's later edit or stream appends then go through. On main that send is a timed-out edit. Here it can also be the post after a refused edit, for example after a 429.

Which refusal the reporter's workspace returned is not known: with chat.update accepted, about 15 turn shapes on the fake all delivered, so the reproduction models one documented refusal (edit_window_closed) and the fix makes delivery survive any refused edit rather than one error code. Still worth a live check on a real workspace: that a markdown-block placeholder seals in place (the same markdown → markdown edit the native path's _give_back makes on stream messages), and that a Slack-style <url|label> link renders inside a markdown block.

Related Issues

Closes #36269

Sibling sweep

Swept: git grep -nE "update_message(|post_message(" -- src/kiro_crew/slack/renderer.py src/kiro_crew/slack/handler_runtime/
Sibling: src/kiro_crew/slack/renderer.py -- changed here
Sibling: src/kiro_crew/slack/handler_runtime/stream.py -- not affected -- native path, converts with render_one_for_slack and is outside this PR's goal
Swept: git grep -nE "update_message(|post_message(" -- src/kiro_crew/slack/renderer_thinking.py
Sibling: src/kiro_crew/slack/renderer_thinking.py -- not affected -- the Thinking reply carries no answer and is best-effort; a refused edit there leaves what it already shows
Swept: git grep -nE "except SlackApiError" -- src/kiro_crew/slack/
Sibling: src/kiro_crew/slack/interactions_approvals.py -- not affected -- restores a review draft for a person to press again; nothing is re-sent automatically

Pattern harvest

Rule candidate: review-prompt
Pattern: an answer-carrying Slack send that has a single fallible form (one edit) and no second delivery, so a documented API refusal drops the whole answer.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@bolichen97
bolichen97 requested review from a team and KiroCrewCaptain as code owners November 18, 2026 20:47
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Nov 18, 2026
@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ⏭️ skipped

Revision bfde1f310830c19e859954305ebddb2ebdff292f touches no user-facing surface (no changes under website/ or committed screenshots), so the UX review was skipped. Does not block merge.

@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

Design-level review of bfde1f310830c19e859954305ebddb2ebdff292f — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS does not.

Design-Verdict: PASS

Nothing blocks. The fix targets the real cause: an edit Slack refused was failing the whole turn. It reuses the proactive-send rule for deciding whether a failed call may still have landed, so it does not post twice.

Notes

  • no_stream_reply.py imports the private helpers _slack_rejected_outright and _slack_rate_limited from kiro_crew.dashboard.handlers.messaging, so the Slack transport now depends on a dashboard handler module. Moving the two helpers into slack/ and having proactive_send.py import them from there gives the rule one owner and points the dependency the right way.
  • No real Slack workspace was reached. This is the first markdown block the repo sends, and it now carries every no-stream placeholder, reply, overflow part and direct post. If Slack refused the block shape on chat.update or chat.postMessage, every flat-DM reply would fail. One live round-trip of both calls would confirm the block is accepted.

[DESIGN-REVIEWED] bfde1f3

Description read

[DESCRIPTION-READ] 5ac0e8f4e8cbc8cde702058aeab40fe534c1f45e955819796de5b784461c3b51

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 .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of bfde1f310830c19e859954305ebddb2ebdff292f — 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 does not.

First-Principles-Verdict: PASS

Nothing blocks. The fix is at the right level: the answer-carrying chat.update was allowed to fail the turn. It reuses the existing proactive-send refusal rule (_slack_rejected_outright / _slack_rate_limited) instead of adding a second one.

What this change ships

Inventory (8 items) — 8 justified

Intent: a person using slack.dm_single_session gets the whole answer at the DM root instead of a "transport path" error. FIX.

  1. When Slack refuses the edit that seals the answer, the answer is posted as its own message instead of failing the turn — justified
  2. The no-stream placeholder, the reply, its overflow parts and the direct post render as a Block Kit markdown block, so links are no longer raw — justified
  3. A threaded reply whose stream Slack refused also posts the answer when the edit is refused — justified
  4. The text a dying turn releases into the placeholder renders as a markdown block — justified
  5. A timeout, a 5xx, internal_error or fatal_error still fails the turn, with no second post — justified
  6. New module slack/no_stream_reply.py with markdown_blocks, post_markdown and seal_placeholder — justified
  7. The SlackRenderer text in messaging.md and the Streaming UX text in slack-gateway.md describe the new delivery — justified
  8. Test fakes accept blocks, and renderer.py's direct-post_message baseline drops from 5 to 2 — justified

[FIRST-PRINCIPLES-REVIEWED] bfde1f3

Description read

[DESCRIPTION-READ] ef72d7e0084ec098a94bdebb7b8f79e499884fe49da8263225891c23ff193c7d

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

[OPUS-REVIEWED] bfde1f3

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

False positive or not applicable? A repository writer can comment:
/ai-review override fable bfde1f310830c19e859954305ebddb2ebdff292f false-positive: <reason, 20 to 500 characters>

@github-actions

github-actions Bot commented Nov 18, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

GPT 6.1 completed its review of bfde1f310830c19e859954305ebddb2ebdff292f and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] bfde1f3

False positive or not applicable? A repository writer can comment:
/ai-review override gpt bfde1f310830c19e859954305ebddb2ebdff292f false-positive: <reason, 20 to 500 characters>

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Nov 18, 2026
@bolichen97
bolichen97 force-pushed the fix/36269-slack-flat-dm-renderer branch from 17566a1 to e465366 Compare November 19, 2026 13:12
@bolichen97

bolichen97 commented Nov 19, 2026 •

Copy link
Copy Markdown
Contributor Author

self-added: yes
mechanism: a refusal set and predicate of its own in no_stream_reply.py
resolution: removed

  • span=ea0e75166d50 The may-have-landed rule is written twice — duplicate

fixed in e465366: no_stream_reply.py keeps no refusal set or predicate of its own. seal_placeholder calls the existing refused-outright rule and its 429 companion from dashboard/messaging_api/proactive_send.py (imported through the messaging handlers module, their documented import path), so one set decides which answers may have landed.
Behaviour is unchanged: a 429, or an HTTP 200 ok: false answer other than internal_error / fatal_error, is a refusal and posts the reply once; anything else re-raises. The renderer spec names the shared rule in both places.
[operator: bolichen97]

@bolichen97

bolichen97 commented Nov 19, 2026 •

Copy link
Copy Markdown
Contributor Author
  • span=ae212204a867 Rescue duplicates a fallback reply after its post times out

Rebutted (disproportional, not a lost answer): a second copy needs three failures on one message at once: the chat API refuses the reply edit, the post that follows lands but its response raises, and the API then accepts the rescue's edit of the placeholder it just refused.
With any one missing, the rescue's edit fails and release_held_text logs it, and nothing else is shown. When all three line up, the user sees the same answer twice; nothing is lost and nothing persists.
main carries the same residual after a timed-out edit that landed, and the PR body states it under Manual verification. Closing it needs an "outcome unknown" state carried through seal_placeholder, release_held_text and the rescue for that triple failure, which is beyond the goal.
[operator: bolichen97]

@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in the renderer module (renderer.py), its test file and the two spec files this PR edits since this head was tested (6bd6d5b -> 89438fd); CI re-running.

The shard-8 backend red on the old head (test_bare_session_handle_guard.py::test_no_test_builds_a_bare_session_handle_directly, flagging test_kas_token_refresh_recovery.py) was main's, and its fix (#39262) is in the new base.
[operator: bolichen97]

A top-level message in a single-session DM has no thread to stream
into, so its reply is sealed into a placeholder with one chat.update.
That edit carried the whole answer and was allowed to raise: any edit
Slack refuses (edit_window_closed, cant_update_message, ratelimited,
...) reached the transport catch-all, which posted the "transport
path" error and dropped the answer. A threaded reply streams and
reaches that edit only when Slack refuses its stream, which is why the
flat DM, which never streams, was the one hit.

An edit Slack refuses (a 429, or an ok:false answer other than
internal_error and fatal_error) now posts the reply as its own
message. A failed post, or an edit that fails any other way (a
timeout, a 5xx, or one of those two errors, after which the edit may
have landed), still fails the turn, and the turn's rescue only edits
the placeholder, so it never posts a second copy. The placeholder and
every reply part are sent as one Block Kit markdown block, so the
reply renders the way the stream's markdown_text does; as a mrkdwn
text field, which chat.update reads under parse=client, the model's
links showed raw.

Closes #36269

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@bolichen97
bolichen97 force-pushed the fix/36269-slack-flat-dm-renderer branch from e465366 to bfde1f3 Compare November 19, 2026 17:08
@bolichen97

Copy link
Copy Markdown
Contributor Author

Rebased: main moved in the two spec files this PR edits, its call-site baseline test and the module directory of the new delivery code since this head was tested (89438fd -> dc531c1); CI re-running.

The backend red on the old head (test_process_cache_floor_ratchet.py::test_every_new_module_level_cache_has_a_per_test_reset, flagging subagent_persistence.py::_NOT_DUE_MEMO) was main's, and its fix (#39479) is in the new base. The other Linux backend red on that run was the runner failing to install lsof from apt, not this change.
[operator: bolichen97]

@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: passed Eligible automated validation passed for the current revision and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Nov 19, 2026
@KiroCrewCaptain

KiroCrewCaptain commented Nov 19, 2026 •

Copy link
Copy Markdown
Collaborator

Code change approver recommendation: Approve

Why: the decider estimates a 12% chance that this change introduces a defect, within the 12% limit for approving on its own, and every check passes.

The fix is at the right place: on the no-stream path, the chat.update that seals the placeholder with the whole answer could fail the turn when Slack refused the edit. seal_placeholder now posts the reply only after a refusal, judged by the same rule the dashboard's proactive Slack sends already use (an ok:false answer other than internal_error/fatal_error, or a 429). Timeouts, 5xx and internal_error/fatal_error still propagate, with no second post. release_held_text only edits the placeholder, so it can't post a duplicate. Both edits of the placeholder (_render_fallback and release_held_text) send the markdown block, so no edit with plain text only can leave the old block on screen. The native path already edits markdown blocks on stream messages, so the block shape has precedent. The client checks (remote-media refusal, channel policy, mute, no unfurl) still apply. The new tests would fail without the change, the updated tests keep what they checked, the spec text is updated, and CI is green.

Tier: 1, every tier gate passed.

An automated recommendation, not a review: a maintainer still decides. It approves on its own only when the estimated chance of a defect is at most 12% and the change has at most 400 changed lines. Decider v3c (217fe607) · commit bfde1f3108 · 299 changed lines. If this recommendation is wrong, reply here: replies are how the approver is evaluated.

@KiroCrewCaptain
KiroCrewCaptain enabled auto-merge (squash) November 19, 2026 18:48

@KiroCrewCaptain KiroCrewCaptain left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

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

Approved automatically by the code change approver, not by a person. The decider estimates a 12% chance that this change introduces a defect, within the 12% limit for approving on its own, and the change has at most 400 changed lines.

The fix is at the right place: on the no-stream path, the chat.update that seals the placeholder with the whole answer could fail the turn when Slack refused the edit. seal_placeholder now posts the reply only after a refusal, judged by the same rule the dashboard's proactive Slack sends already use (an ok:false answer other than internal_error/fatal_error, or a 429). Timeouts, 5xx and internal_error/fatal_error still propagate, with no second post. release_held_text only edits the placeholder, so it can't post a duplicate. Both edits of the placeholder (_render_fallback and release_held_text) send the markdown block, so no edit with plain text only can leave the old block on screen. The native path already edits markdown blocks on stream messages, so the block shape has precedent. The client checks (remote-media refusal, channel policy, mute, no unfurl) still apply. The new tests would fail without the change, the updated tests keep what they checked, the spec text is updated, and CI is green.

Tier: 1, every tier gate passed.
Criteria: no merge conflict, no owner block, no change request, the default branch, no security-sensitive path, no design document to agree on, the readiness status, the review lanes, the P0 history, the linked issues' tier, the review lessons, no concern label, the file count, a safe change category, not its own change, the decider, the security checklist, the change matches its title, no competing change.
Design documents ride along with the code (docs/system-specs/modules/messaging.md, docs/system-specs/modules/slack-gateway.md): they were not reviewed as a design, and a person who changes what they decide should ask for that review.

Decider v3c (217fe607). To overrule it, request changes or dismiss this review.

@KiroCrewCaptain
KiroCrewCaptain merged commit 775dd6d into main Nov 19, 2026
99 checks passed
@KiroCrewCaptain
KiroCrewCaptain deleted the fix/36269-slack-flat-dm-renderer branch November 19, 2026 18:48
@github-actions github-actions Bot removed the readiness: passed Eligible automated validation passed for the current revision label Nov 19, 2026
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.

Slack: dm_single_session replies break (raw thinking, no tool steps, raw links, "transport path" error)

2 participants