Skip to content

feat(dashboard): one-click send for Dashboard cards, behind an off-by-default preview - #33203

Merged
bolichen97 merged 2 commits into
mainfrom
feat/22367-dashboard-card-send
Nov 9, 2026
Merged

bolichen97 merged 2 commits into
mainfrom
feat/22367-dashboard-card-send

Conversation

@chenmingwei23

@chenmingwei23 chenmingwei23 commented Nov 8, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: A button on a crewmate's Dashboard tab can send its reply into that crewmate's own thread in one click, behind a preview that is off by default - instead of only filling the chat composer.

Today a page posts kirocrew-dashboard:act {text}, the host validates it and puts the text in the composer, and the person must then switch to the chat and press send. For a card that offers a reply ("Approve the plan", "Show me the diff"), that is two steps for a choice the person already made with one click. The page is agent-written HTML, so the host never lets it send on its own - a page that could speak as the person would let a crewmate answer for them.

Why it matters

The built-in cards (a needs-you row with offered answers, a review row with two buttons) are the one place the second step adds nothing: the person chose the reply by clicking it, then has to find the chat and press send again. Issue #22367 asks for that click to send. The gap is small per card but constant, and it is exactly the interaction the Dashboard exists to make direct.

Not a goal

  • Not changing default behaviour for anyone: the whole feature is a per-crewmate preview that defaults OFF, so send behaves exactly as today's act until a crewmate is opted in.
  • Not letting a page name a target session - the page names no target; the host sends only into the tab's own crewmate DM thread.
  • Not treating a card turn as a person's turn - no approval authority, no owner directive authority, no auto-approval.
  • Not loosening the sandboxed frame's CSP.
  • Not fully closing the page-self-focus() residual the RFC names; this reduces it with tiedToFrame and leaves the host-confirmation / trusted-click-bridge follow-ups to a later change.

What changed (motivation -> approach -> change)

Goal: let a person's one click on a card send the reply. Approach: add a second page-to-host message rather than widen act, gate the send so only a person's real in-frame click can trigger it, and ship it off by default so it changes nothing until opted in. It follows docs/request-for-change/rfc-dashboard-card-send.md (on main, status: draft), with four deliberate departures noted below.

  • New message kirocrew-dashboard:send {text} (same text rules as act: trimmed, <=600 chars, no control char except newline). The host sends it as a user turn into the Dashboard tab's own crewmate DM thread, nowhere else.
  • The person is the one who sends. The host sends only when the click is tied to the page's own frame - tiedToFrame, the stronger of the gates the PR-link bridge uses: it holds only when focus came into this frame straight from the dashboard and no click or key outside it is still live, so a page script that calls focus() on its own frame after a click elsewhere does not pass.
  • Payload validated at the frame bridge (host) and re-validated at the gateway (dashboard/card_send.py), which refuses what a card may not do: not the owner's own dashboard, not an existing crewmate DM thread, the preview off, the thread busy, an open approval / question / permission prompt, or inside the 3-second rate limit. Every refusal falls back to filling the composer, so a reply is never lost.
  • A card turn is not a person's turn: tagged [Dashboard card], never an approval, no owner directive authority, and no inherited auto-approval - its tool calls reach the approval card even in a trust thread (hook allowlist, trusted patterns, trust-reads, session trust, scoped grant, YOLO and native-crew all skipped and audited). It cannot spawn sub-agents or reach any delegation route.
  • Preview, OFF by default: the per-crewmate dashboard_card_send config field defaults false; a Send replies in one click switch on the Profile tab turns it on. With it off the host offers no send at all (MembersPageSidePanel passes onSend only when the roster row has dashboard_card_send === true), so a page's send fills the composer exactly as act does and nothing reaches the gateway; the gateway's card_send_off check stays the enforcement point. With it on, the Dashboard tab shows a "One-click send on - change on Profile" badge (styled like the layout-lock badge, opens the Profile tab), so the person sees what a card click will do where they click. The sandboxed frame's CSP is unchanged.
  • The built-in cards use it: a finished answer posts send - goal-board's offered options, office's two review-row buttons, and project-report's needs-you choices. A starter the person finishes keeps posting act: goal-board's and the conductor board's Reply ("About ...: ") and project-report's "Write my own". With the switch off (the default), or on any refusal, the host fills the composer exactly as today.
  • No regex in card_send.py: the control-character rule is a per-character ord() test, and the delegation and task-runner-stop routes are sets of path-segment shapes after /api/ (None = any one non-empty segment), matching exactly the routes the earlier patterns matched.
  • A distinct reply is never dropped: inside the send interval, or while a send is in flight, a repeat of the same text is dropped as a double click; a different text fills the composer.

Departures from the RFC: (1) default off, not on (RFC section 3.5) - shipped as a preview so it is not a product-shape change for every crewmate; (2) the send gate is tiedToFrame, not hasGesture alone - RFC section 4.1 accepts the weaker check with the page-self-focus() case as a residual; tiedToFrame (added to the repo after the RFC) does not pass that case; (3) the built-in pages' finished answers post send (the RFC's compatibility section kept them on act), so the cards its own motivation names get the one click; (4) no dashboard_frame constants for act/send (RFC section 3.1): nothing on the server read them, so the literals are pinned between the tab and the built-in pages by a test instead.

Backwards compatibility

Compatible: dashboard_card_send is absent on every existing record and reads as off, and with it off a send from a page fills the composer exactly as act does, so the built-in pages' switch to send changes nothing anyone sees until they turn the preview on. Custom pages that post act are untouched. The host and gateway ship in one build. No field is rejected, renamed or narrowed.

Removes nothing: the diff deletes no public name and moves no helper. The crew-steer split this PR once carried is now on main (#33545), and this PR keeps the layout from main.

Tests

New and updated tests, each of which fails with the fix removed (mutation-verified): the accepted send and every refusal (test_dashboard_card_send.py); the untrusted-turn gate across every auto-approve tier (test_card_turn_untrusted.py - forcing the card flag off fails 7); no sub-agent / no delegation (test_card_turn_subagent_policy.py); the preview defaults off, round-trips, non-bool reads as off (test_crew_card_send_setting.py); preview off = fill the composer (today's behaviour, pinned) and a send only on a frame-tied click, a page script cannot send (website/src/test/CrewDynamicDashboard.test.tsx - removing the gate fails the "a script cannot send" cases); the Profile switch default-off and write (CrewProfileSettings.test.tsx); the wire carries origin: dashboard_card and nothing a typed send does not (sendCardReply.test.ts, crewDashboardAct.test.ts). Each built-in page pins which buttons post send and which stay act, and fails if a finished answer goes back to act (test_dashboard_template_goal-board.py, test_dashboard_template_office.py, test_dashboard_template_project-report.py); the switch-off fallback to the composer is pinned in CrewDynamicDashboard.test.tsx ("fills the composer without an error when the person turned one-click sends off"). The route shapes are pinned one case per route, with trailing-slash, empty-id, extra-segment and lookalike-prefix cases (test_card_turn_subagent_policy.py), and a distinct reply inside the send interval fills the composer (CrewDynamicDashboard.test.tsx).

Proof: PROVEN - backend: forcing _card_turn=False fails 7 untrusted-gate tests; frontend: removing the frame-tie gate fails the "a script cannot send" / "click elsewhere" cases (head 729ed00).

Local gates green on the changed surface: pytest -n 0 (card-send + contract + steer suites), vitest (frontend) + i18n catalog parity, tsc, eslint, isort, flake8, mypy, black, check_file_line_cap.py (0 failures), config-baseline.json regenerated. CI runs the full cross-surface suite.

Manual verification

Real-browser run of the real components (website/scripts/capture-22367-card-send-live.mjs over website/capture/dashboard-card-send-live.html, Vite dev server, network stubbed in the page, no gateway). For each Dashboard state the script clicks the page's own button inside the sandboxed frame, so the host's real gates (hasGesture + tiedToFrame) decide, then asserts the branch before the shot:

  • switch off: no badge, the click fills the chat box, nothing is sent, no notice;
  • one-click send: the badge is shown, the thread gets the [Dashboard card] row, no notice, the chat box stays empty;
  • refused: the send-failed notice with its dismiss control (clear of the floating Download button), the reply in the chat box;
  • unknown (dropped connection / late answer): the notice quotes the reply ("... may not have been sent. Check the thread before sending it again."), the chat box left empty;
  • Profile switch write answering 500: the notice under the switch names the state it stayed in ("It's still on" / "It's still off").

The wiring with the switch OFF is pinned in MembersPage.sidePanel.test.tsx on the real side panel: a page's send fills the composer and api.sendChat is never called (fails if the dashboard_card_send gate is removed).

Screenshots / video

Every shot mounts the real CrewDynamicDashboard or CrewProfileSettings. The "Thread" and "Chat box" strip under the frame is the fixture's stand-in for the Members page's transcript and composer: it shows what onSend sent and where onAct filled the reply. Committed under temp-screenshots/22367/ (the review lanes read committed media there):

4. Switch off (the default): no badge, and the card click only fills the chat box; nothing is sent (dark)
5. Switch on, before the click: the "One-click send on - change on Profile" badge says what a click will do (dark)
6. One-click send: the [Dashboard card] row is in the thread, the chat box stays empty (dark)
7. Send refused: the notice over the page with its dismiss button, the reply in the chat box (dark)
8. Delivery unknown: the notice quotes the reply and says to check the thread before sending it again; the chat box is left empty (dark)
9. Profile: turning one-click send off failed, and the notice says it is still on (dark)
10. Send refused, light theme

Related Issues

Fixes #22367

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (feature map, iframe-hosts, dashboard skill, injected-messages, security spec)
  • No secrets, credentials, or internal references in the diff

@chenmingwei23
chenmingwei23 requested review from a team and KiroCrewCaptain as code owners November 8, 2026 13:55
@chenmingwei23
chenmingwei23 requested a review from Zedmor November 8, 2026 13:55
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from 7e7417e to 729ed00 Compare November 8, 2026 13:55
@github-actions

github-actions Bot commented Nov 8, 2026 •

Copy link
Copy Markdown
Contributor

GPT 6.1 Review — ✅ no blocking findings

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

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 7525727

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

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

github-actions Bot commented Nov 8, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Opus 5.5) — ✅ PASS

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

UX-Verdict: PASS

Nothing blocks. The blind reader read every primary control correctly: the "Approve the plan" card button, the "Send replies in one click" switch and the Profile badge. Each new state and notice appears in shots 01–07.

Notes

  • Shot 04: after a send, the built-in card still says "waiting on your answer" and the "Approve the plan" button looks the same as before. The reader said "no, I don't want to send it twice". In the goal-board, office and project-report templates, mark the answered row as sent or disable its button until the agent updates the page.
  • Shot 05: the badge says "Reply buttons send right away" while the error next to it says the reply didn't send. The reader said "the two messages disagree". Put the dashboard_send_failed notice directly under the badge, or reword it to "This reply couldn't be sent right away. It's in the chat box instead."
  • dashboard_send_unsure puts the reply in quote marks inside its own quotes (""About "Ship…": Approve the plan" may not…), and the reader found it hard to read. Use "Your reply may not have been sent…" and put the quoted text on its own line.

[UX-REVIEWED] 7525727

Description read

[DESCRIPTION-READ] d7eab243a020e5ad8de31c904800870a73d3a7d5fb5765d742dea7ba48399d3c

That sha256 names everything this verdict read: the PR description, plus the 10 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 8, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Opus 5.5) — ✅ PASS

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

Design-Verdict: PASS

No design-level blocker: the feature is off by default, the gateway enforces it, the frame-tied click gate holds, and a card turn gets no auto-approval.

Notes

  • _DELEGATION_ROUTES in card_send.py lists the routes a card turn may not call, and that fails open: any new route that starts a session, job or run is reachable from a card turn until someone remembers to add it here. A positive mark on the request that the delegating handlers check would fail closed instead. Do this before the preview goes on by default.
  • The card-turn mark in _running_card_turns lives only in memory. Continue and retry recover it from cardOrigin in the row meta, but any future way to re-run a turn has to know to read that key. Keep the test_card_turn_* tests as the place that pins this rule.

[DESIGN-REVIEWED] 7525727

Description read

[DESCRIPTION-READ] 6b1515628bddd175aff948a84a1161a69b73e1c04804ef848eb4c8311290cebf

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 8, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Opus 5.5) — ✅ PASS

Premise-level review of 75257271bc24babf2b614b5006cb265b671b04f1 — 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 one-click send ships off for every crewmate (dashboard_card_send defaults false), so it is a preview nobody gets without choosing. Each item answers either issue #22367 or the agent-written HTML boundary.

Notes

  • Item 7 — inherited: the 3-second per-thread limit in card_send.py (CARD_MIN_INTERVAL_SECS, _last_send, _MAX_TRACKED_SLOTS) rests on "a repeat of the same text is dropped as a double click". The host already does that drop. The only things that can call origin: dashboard_card are the host's own frame-tied click path and the owner's own dashboard. Subtraction: delete claim_send_slot and the card_send_rate_limited refusal, and keep the host-side repeat drop.

What this change ships

Inventory (9 items) — 8 justified

Intent: let a person's click on a Dashboard card's answer send that reply into the crewmate's own thread, instead of only filling the chat box. This is an ADDITION.

  1. A page can post kirocrew-dashboard:send, and with the preview on it sends into the tab's own DM thread. — justified
  2. A send happens only on a real in-frame click (tiedToFrame). — justified
  3. The gateway refuses the send when the thread is busy, a decision is open, it is not the owner's dashboard, the thread does not exist, or the preview is off; each refusal falls back to filling the composer. — justified
  4. A card-sent turn is tagged [Dashboard card] and gets no auto-approval tier. — justified
  5. A card turn cannot spawn sub-agents or start sessions, crons, workflows or task runs. — justified
  6. A new "Send replies in one click" Profile switch, off by default, and a badge on the Dashboard tab when it is on. — justified
  7. Server-side 3-second send rate limit. — undeclared, inherited
  8. The built-in goal-board, office and project-report finished answers now post send instead of act. — justified
  9. The draft RFC is edited to record four departures. — justified

[FIRST-PRINCIPLES-REVIEWED] 7525727

Description read

[DESCRIPTION-READ] aed7ffd647292787d0183f55797fd939e857a1dc679867ab21d2258f7e7f0baf

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 8, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5.5 Review — ✅ no blocking findings

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

Review details

No findings.

Notes:

  • chat_api/chat_send.py grows from 1,920 to 1,996 lines, which leaves 4 lines before the 2,000-line cap (keep-modules-small, not blocking). The card-turn branches could move into dashboard/card_send.py.

[OPUS-REVIEWED] 7525727

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

False positive or not applicable? A repository writer can comment:
/ai-review override fable 75257271bc24babf2b614b5006cb265b671b04f1 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 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from 729ed00 to c0917d7 Compare November 8, 2026 14:41
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Nov 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from c0917d7 to ef1186e Compare November 8, 2026 14:56
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition on head ef1186e1d0

Both blocking findings are the same real hole and are fixed in code (not overridden): a card send could reach a queue path that stamps owner/human provenance and no cardOrigin marker, so the drained turn would run the page's words with the thread's trust and the person's directive authority.

  • GPT 6.1 (chat_send.py:1045, card send into a paused crew): the card busy-refusal now also refuses when _crew_paused is set, so a Pause all makes the card fall back to the composer instead of queueing.
  • Opus 5.5 (chat_send.py:1295, card send with a deferred conversation discard / edit hold): the card refusal before the hold queue branch now also covers _teardown_hold and _edit_held, the other two states that branch queues on.

Net: a card send is refused (and the host fills the composer) in every state that would otherwise queue it unmarked, so a card reply can never drain as a trusted owner turn.

A new parametrized test pins each of the three states (crew_paused, teardown_hold, edit_hold): the send is refused card_send_slot_busy, nothing is queued, no row, no turn. Each case fails with the fix reverted (verified).

Also fixed the stale loader_pipeline.py comment Opus noted: it now reads "the default (off)".

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from ef1186e to e1036df Compare November 8, 2026 15:26
@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 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from e1036df to 6d9c72d Compare November 8, 2026 15:50
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition on head 6d9c72d970

Both findings are fixed in code (not overridden).

  • F1 (security, admission recovery): a card's accepted-work payload now carries a cardOrigin flag (admit_chat_turn -> _chat_payload), and the crash-recovery row rebuild stamps CARD_ORIGIN_META_KEY back on the restored user row (host_hooks._deliver). So latest_user_row_is_card stays true after a recovery and a later Continue is untrusted, matching the live path. New test test_a_recovered_card_row_keeps_its_card_marker pins it and fails with the stamp removed.
  • F2 (defect, indeterminate delivery): sendCardReply now returns a new 'unknown' outcome for a dropped/offline connection or a late/unreadable answer (response-late/unknown), instead of 'sent'. The caller shows an uncertainty notice ("The reply may not have been sent. Check the thread.") and does NOT fill the composer, since a resend could run the turn twice if it did land. Two existing tests updated to assert 'unknown', and a new CrewDynamicDashboard test asserts the notice shows and the composer is not filled.

Also corrected the loader_pipeline.py default comment to "(off)".

@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from 6d9c72d to b95ed3f Compare November 8, 2026 16:03
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Nov 8, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from eff7076 to c11a106 Compare November 9, 2026 03:55
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Nov 9, 2026
@chenmingwei23
chenmingwei23 force-pushed the feat/22367-dashboard-card-send branch from c11a106 to 7783eff Compare November 9, 2026 04:41
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Nov 9, 2026
@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition on head 70f5b40

First Principles BLOCK (built-in cards still post act): fixed. The built-in pages now post kirocrew-dashboard:send for a finished answer: goal-board's offered options, office's two review-row buttons and project-report's needs-you choices. A starter the person finishes stays act: goal-board's and the conductor board's Reply ("About ...: ") and project-report's "Write my own". With dashboard_card_send off (the default), or on any refusal, the host fills the composer exactly as before, so nothing changes for anyone who has not opted in. Each of the three page test files now pins which buttons post send and fails if a finished answer goes back to act; the switch-off fallback stays pinned in CrewDynamicDashboard.test.tsx. The description lists this as RFC departure (3).

Item 10 (zero consumers): taken. dashboard_frame.ACT_MESSAGE_TYPE and SEND_MESSAGE_TYPE are removed. test_dashboard_frame.py now pins the tab's literals against the built-in pages that post them (RFC departure (4)).

Items 5-7 (card-turn gating called oversized): kept. A card turn carries words a page chose, and the page is not the person: with the gating removed, a page's one click would inherit the thread's trust and YOLO and could start sub-agents and jobs that read that trust. The owner shipped this as an off-by-default preview with those limits on purpose; loosening them is a product decision for a maintainer, not this PR.

GPT (late refusal overwrites a newer reply, head 7783eff): fixed in bb8bfa2. Every composer fill while a send is in flight is tracked, so a late refusal adds its text instead of replacing the newer one; covered for both the send and act paths.

Static Ratchet Gate (test_pid_reader_ratchet, 9 vs 8): fails on main itself, not this PR; the fix is #33695. This PR will rebase once it lands.

@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.

Thanks for replacing the three regexes in dashboard/card_send.py with plain checks. That request is fixed on this head. Two things still block on 7166cc5:

  1. The new UI states have no rendered evidence (website/capture/dashboard-card-send.tsx:40). The UX lane on this head said "cannot evaluate: missing the one-click send on the Dashboard tab". A verdict a lane cannot reach for missing evidence is a block, not a pass. The head still commits only temp-screenshots/22367/1-4, all from a staged fixture. Shot 3 draws the send-failed notice above the Profile switch with no dismiss button and no composer. The real notice renders above the crewmate's page in CrewDynamicDashboard.tsx:1418 with a dismiss control. No image shows crew-dashboard-send-unsure (CrewDynamicDashboard.tsx:1432), the Profile write-failed notice, or a card reply sent on the Dashboard tab. This was item 1 of my earlier review, and it still stands. Smallest fix: add capture states that mount the real CrewDynamicDashboard the way CrewDynamicDashboard.test.tsx does, with onSend resolving refused and then unknown. Add one for CrewProfileSettings with the write rejected. Commit the shots, recaption shot 3 to say what it shows, and re-run the UX lane.

  2. With the preview off, a built-in card click no longer behaves like today's act (website/src/pages/members/MembersPageSidePanel.tsx:571). onSend is passed whenever confirmedSlot is set, and dashboard_card_send is never checked. The goal-board, office and project-report answer buttons now post send, so every default-off click makes a POST /api/chat. Suppose the connection drops, or the answer takes longer than the 10 s abort. sendCardReply then returns 'unknown', and CrewDynamicDashboard.tsx:546 shows "The reply may not have been sent" without filling the composer, though the gateway would have refused with card_send_off. A 401 or 500 shows "Couldn't send the reply" to someone who never turned sending on. This contradicts the PR's own Not a goal ("send behaves exactly as today's act until a crewmate is opted in"). Smallest fix: pass onSend only when the active roster row has dashboard_card_send === true. The gateway's card_send_off check stays the enforcement point. Please add one test: switch off, plus an onSend that would reject, means the composer is filled and no notice shows.

Optional:

  • An admitted card send claims its rate-limit slot and writes an "allowed" audit record before the late busy and pending-decision rechecks in chat_send.py. A late refusal then leaves two records for one send, and the next click within 3 s gets a spurious 429. You could claim and audit only once the send commits.
  • CrewDynamicDashboard.test.tsx:55 mocks tiedToFrame as document.activeElement === frame. hasGesture already checks that, so removing the tiedToFrame gate reds no test. useFrameLinkBridge.test.tsx shows how to drive the real one.
  • The draft RFC and its index row under docs/request-for-change/ still describe default on and act for the built-in pages. Updating them here would let the reader see the design that ships.

The linked issue is still parked, and the RFC is still a draft. So once these are fixed, a maintainer still needs to sign off the design before this can merge.

@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.

Thanks for the update. I reviewed head 3c7a859. Two earlier items still block on this head.

Status of earlier review items:

  • Replace the three regexes in dashboard/card_send.py: fixed. The head has no import re and no compiled pattern.
  • Rendered evidence for the new UI states: still stands. See item 2.
  • With the preview off, a card click should behave like today's act: still stands. See item 1.
  1. With the preview off (the default), a built-in card click still calls the gateway (website/src/pages/members/MembersPageSidePanel.tsx:571). onSend is passed whenever confirmedSlot is set, and nothing on the client reads dashboard_card_send, even though this PR adds that field to the roster row. The goal-board, office and project-report answer buttons now post send, so every default-off click makes a POST /api/chat. Trigger: the connection drops or the answer takes longer than the 10 s abort. Outcome: sendCardReply returns 'unknown', the tab says "The reply may not have been sent", and the composer stays empty. A 401 or 5xx response, or a refusal checked before card_send_off (card_origin_not_allowed, card_target_invalid), shows "Couldn't send the reply" to someone who never turned sending on. This contradicts the PR's own Not a goal ("send behaves exactly as today's act until a crewmate is opted in"). The only test of the off path mocks onSend to resolve 'off', so it never exercises this wiring. Smallest fix: pass onSend only when active.dashboard_card_send === true, and keep the gateway's card_send_off check as the enforcement point. Add one test with the switch off and an onSend that rejects or resolves 'unknown'. It should show that the composer is filled, no notice appears, and api.sendChat is never called.

  2. The new Dashboard-tab states have no rendered evidence (website/capture/dashboard-card-send.tsx:39). On this head the UX lane said "cannot evaluate: missing the Dashboard tab, where the one-click send happens". A lane that cannot reach a verdict because evidence is missing counts as a block. The PR still commits only temp-screenshots/22367/1-4, and all four come from a staged Profile-switch fixture. Shot 3 draws the send-failed notice above the switch, with no dismiss control. The real notice renders over the crewmate's page in CrewDynamicDashboard.tsx and has a dismiss button. No image shows a card reply sent on the Dashboard tab, crew-dashboard-send-unsure, or the Profile write-failed notice. Smallest fix: add capture states that mount the real CrewDynamicDashboard, the way CrewDynamicDashboard.test.tsx does, with onSend resolving refused and then unknown. Add one state for CrewProfileSettings with the write rejected. Commit the shots at the new head, recaption shot 3 to say what it shows, and re-run the UX lane.

Optional:

  • CrewDynamicDashboard.test.tsx:53-56 mocks tiedToFrame as document.activeElement === frame, which hasGesture already checks. Removing || !tiedToFrame(frame) therefore fails no test. useFrameLinkBridge.test.tsx on main shows how to drive the real check.
  • No card-turn test covers the native-crew, own-worker and own-child auto-approve exclusion in tool_approval.py:1114. Deleting not _card_turn and fails no test.
  • The draft RFC under docs/request-for-change/ still describes default on and act for the built-in pages. Updating it here would show readers the design that ships.

Once these are fixed, a maintainer will still sign off the design before merge.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

@KiroCrewCaptain thanks. Point by point on head be8a930:

1. Preview off, a built-in card click still called the gateway (MembersPageSidePanel.tsx): fixed. onSend is now passed only when the active roster row has dashboard_card_send === true (and the thread is confirmed). With the switch off the host offers no send, so a page's send takes the same act path as today: the composer is filled, no notice shows, and nothing reaches the gateway. The gateway's card_send_off check stays the enforcement point. New test on the real side panel, MembersPage.sidePanel.test.tsx "a card reply on the Dashboard tab": with the switch off and api.sendChat set to reject, a card send fills the composer and api.sendChat is never called. I checked it fails with the gate removed. A second case pins the on path: one POST /api/chat into the confirmed slot with origin: dashboard_card, and the composer left empty.

2. No rendered evidence for the Dashboard-tab states: added. website/capture/dashboard-card-send-live.tsx mounts the real CrewDynamicDashboard (as CrewDynamicDashboard.test.tsx does) and the real CrewProfileSettings. Network is stubbed in the page, with no gateway. website/scripts/capture-22367-card-send-live.mjs clicks the page's own button inside the sandboxed frame, so the real hasGesture + tiedToFrame gates decide. It asserts each branch before the shot. New shots under temp-screenshots/22367/: 5 before the click, 6 a successful one-click send (the [Dashboard card] row in the thread, empty chat box), 7 and 10 refused (notice over the page with its dismiss button, reply in the chat box; dark and light), 8 unknown ("may not have been sent", chat box left empty), 9 the Profile setting write rejected. Shot 3 is recaptioned as the staged fixture it is, pointing to shot 7 for the notice in place.

The live shots turned up a real layout bug: the floating Download control sat on top of the send notices' dismiss button. The notices now keep clear of it (mr-12 when the control is shown), and the script asserts the dismiss button is left of the control.

Optional items:

  • ("POST", "/api/crons/tools") is now named in test_every_delegation_route_is_named.
  • tiedToFrame mocked in CrewDynamicDashboard.test.tsx, and the not _card_turn exclusion on the native-crew / own-worker / own-child rung: not in this push, to keep it scoped to the two blockers. The live capture above runs the real tiedToFrame.
  • The draft RFC still says default on and act for built-in pages: the PR description lists all four departures; the RFC text is left to the maintainer sign-off you mention.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition on head 0d8efbb

GPT 6.1 (security-fenced, upheld): stopping a card turn let its in-flight spawn through. Fixed, no override. The card mark is released when the turn stops, but a request the turn sent can still be inside the handler's awaits. That covers the spawn handler's agent warm-up as well as the auth and memory reads.

  • card_send.card_turn_arrival_middleware runs right after the latency layer, before any layer that awaits. It records on the request whether the session named in X-Session-Key ran a card turn when the request arrived. The header can only add a refusal (it names whose mark is read), so trusting it before auth can refuse a caller's own request and never admit one.
  • card_send.card_turn_seen(request, session) is true when the mark is live now, or when the request arrived from that session while it was. Every card refusal reads it:
    • the delegation middleware;
    • api_spawn, which passes _card_turn=True to the spawn gate (gate.py: _card_turn or card_turn_running(...));
    • api_spawn_lost, which drops the lost-submission reconcile for a card turn.
  • Tests in test_card_turn_subagent_policy.py, each checked to fail with its piece removed:
    • the gate refuses on _card_turn=True with no live mark;
    • card_turn_seen reads the snapshot only for the caller's own session;
    • through a real middleware chain, a layer that stops the turn mid-request still gets 403, with a control that passes;
    • api_spawn hands _card_turn to the manager only when the snapshot says so.
  • The middleware-chain and lazy-import pins are updated for the new layer.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Disposition on head ca880c3

UX (BLOCK on 0d8efbb): the send mode was invisible where the person clicks. Fixed. With one-click send on, the Dashboard tab now shows a "One-click send on - change on Profile" badge, styled like the layout-lock badge. It opens the Profile tab where the switch is. It shows only when the host offers a send, which is only when the switch is on, so the badge and the click's behaviour cannot disagree. Shot 4 is the switch off: no badge, and the click fills the chat box. Shots 5-8 and 10 show the badge. CrewDynamicDashboard.test.tsx pins it shown with onSend, absent without, and opening the Profile tab.

Notes, all taken:

  • The Profile failure text now names the state it stayed in. "Couldn't turn on one-click send. It's still off." and the reverse, picked from the attempted value. New _on / _off keys in all locales, and en-XA regenerated with npm run i18n:pseudo. Shot 9.
  • The "may not have been sent" notice now quotes the reply: "<reply>" may not have been sent. Check the thread before sending it again. (cut at 80 characters). Shot 8, pinned in the test.
  • The staged composite (old shots 1-4 and their fixture) is removed. Every shot now comes from the real components.

Also on this head: Backend Lint's black failure in test_card_turn_subagent_policy.py is fixed.

@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.

Thanks for the update. On ca880c3 all three items from my earlier review are fixed. Two new CI reds come from this diff and block the merge.

Status of earlier review items:

  • Replace the three regexes in dashboard/card_send.py: fixed.
  • With the preview off, a card click should behave like today's act: fixed. MembersPageSidePanel.tsx:575 now passes onSend only when active.dashboard_card_send === true.
  • Rendered evidence for the new UI states: fixed. Shots 4 to 10 cover switch off, send, refused, unsure and the Profile write failure, and the UX lane passes on this head.
  1. The spawn signature pin was not updated (test/test_subagent_parts_composition_contract.py:969). The PR adds _card_turn: bool = False to spawn in src/kiro_crew/subagent_parts/admission_surface.py:314. The pinned string still ends at _root_session_key: 'str | None' = None) -> 'SubagentInfo | None'. As a result, test_the_manager_keeps_every_base_member_with_its_kind_and_signature fails with AssertionError: spawn and Backend Tests (3.12, 8) is red. Smallest fix: add , _card_turn: 'bool' = False after _root_session_key: 'str | None' = None in that string, then run python -m pytest -n0 test/test_subagent_parts_composition_contract.py.

  2. Two new locale strings fail the fr and ko style tests (website/src/i18n/locales/fr.json:22109, website/src/i18n/locales/ko.json:21045). In dashboard_card_send_badge_label, the fr value has a plain space before : ("activé : un"), but frStyle.test.ts requires U+202F there. In dashboard_send_unsure, the ko value quotes {{reply}} with ASCII double quotes, but koStyle.test.ts requires ‘ ’. Frontend Tests (1) and (2) each fail one test, and Coverage Gate then fails closed. Smallest fix: put U+202F before the : in the fr value and check the other new fr keys for ;:?!. Change the ko value to ‘{{reply}}’. Then run cd website && npx vitest run src/i18n/style.

Optional:

  • CrewDynamicDashboard.test.tsx:55 still mocks tiedToFrame as the same focus check hasGesture makes. So deleting || !tiedToFrame(frame) at CrewDynamicDashboard.tsx:517 fails no test. A controllable mock plus one case with activation on, the frame focused and tiedToFrame false would pin it.
  • The "Dashboard card forged send" row in docs/system-specs/modules/security.md:1024 describes only the hasGesture gate and calls the self-focus case open. dashboard-iframe-hosts.md and the PR body say tiedToFrame narrows it. Making them agree would help security readers.
  • The draft RFC under docs/request-for-change/ still describes default on, act for the built-in pages, and dropping a second reply in the window. A dated amendment listing the departures would match what ships.

Once these are fixed, a maintainer still needs to record the design decision before this can merge.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Pushed a412c3311b.

Both earlier blockers are addressed on the current head, and three CI reds that were red on the prior head are fixed:

  • Client wiring (preview off behaves like act). onSend is passed only when active.dashboard_card_send === true, so with the switch off a built-in card click fills the composer and makes no POST /api/chat; the gateway's card_send_off stays the enforcement point. Covered by the side-panel test that switches off, gives onSend a rejecting stub, and asserts the composer is filled, no notice shows, and the chat API is never called.

  • Rendered evidence for the new states. The capture harness mounts the real CrewDynamicDashboard (states resolving refused then unknown, plus a one-click send and the off path) and the real CrewProfileSettings with the setting write refused. The committed shots under temp-screenshots/22367/ are rendered from that harness, and shot 3 was recaptioned to say what it shows.

  • Backend signature pin. spawn gained a _card_turn parameter; the subagent-policy base-class contract test was updated to match.

  • French spacing. The one-click badge label now uses a narrow no-break space (U+202F) before its colon.

  • Korean quoting. The indeterminate-send notice now quotes the interpolated reply with the Korean single quotation marks instead of ASCII double quotes.

Touched backend contract tests, the three touched frontend component test files, and all locale style/consistency gates pass locally. The code-scanning lane's earlier failure was an installation API rate-limit during result upload, not a finding in this diff.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

This branch is owned by local session chat-3354-1794188640 under lead chat-3338; other agents please do not push here. Held head: a412c33.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Ownership update: rebased onto main 44085fc after #33702 (conflict only in the lazy-import contract pin, now 144). Held head is now c616448, replacing 2739e86 (same tree as a412c33 plus the rebase). Two commits. Please do not push over it without asking.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

@raymondchen625 You force-pushed c616448 here, so this branch is yours now. There is a newer review on that head (a change request from the automated reviewer at 14:57Z). Do you want us to address those findings on top of c616448, or will you take them? We will not push to this branch unless you say yes.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Ownership correction: the 16:09Z note above is wrong. c616448 and the new head 0daac97 were both pushed by the owning worker session (lead chat-3338); the Raymond Chen committer name comes from the shared clone git identity, not a takeover. @raymondchen625 no action needed from you. Held head is now 0daac97; please do not push to this branch.

UX BLOCK on c616448 fixed in 0daac97: the visible badge now states the outcome, "Reply buttons send right away - change on Profile", in all 13 locales (en-XA regenerated); the aria-label already said the same. Evidence shots 5-8 and 10 re-captured with the new text. Notes not taken here: the [Dashboard card] tag is the protocol marker named in the RFC and the injected-message spec, so renaming it is a separate change; the quoted reply in dashboard_send_unsure was asked for by the previous UX round.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

GPT finding on 525f260 (card_send.py:127, cron reads and stops refused) fixed in c9ebde4. POST /api/crons/tools is no longer matched by path. Its handler now checks the validated tool name for a card turn: cron_list, cron_pause, cron_remove and cron_remove_all pass; every other cron tool (add, update, resume, trigger, secret_request, and any added later) gets the same 403 as other delegation routes. Tests: a per-tool table in test_card_turn_subagent_policy.py and a wiring test through the real handler in test_cron_tools_forwards_session_token.py. RFC route list updated. Held head is now c9ebde4.

@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.

Thanks. Almost everything from my earlier review is in place on this head. One test problem still blocks.

  1. The send-interval tests depend on the real clock. website/src/test/CrewDynamicDashboard.test.tsx:314 and :331 assert toHaveBeenCalledTimes(1) after a third post. Once release('sent') clears the in-flight flag, the only thing that holds back that third post is the interval check in website/src/pages/members/CrewDynamicDashboard.tsx:523-524, which reads an unpinned Date.now() against SEND_MIN_INTERVAL_MS (3000). The waitFor at :312 and :329 passes on its first check, because the count is already 1, so it does not wait for anything. Trigger: a loaded coverage runner spends more than 3 s between the first post and the third. Outcome: the component correctly sends again, onSend is called twice, and both tests fail even though the product works. Smallest fix: in both tests, add vi.spyOn(Date, 'now').mockReturnValue(T) with a fixed, nonzero T (the existing afterEach vi.restoreAllMocks() undoes it). Then wait on the outcome itself, not on a count that is already 1. Could you also add one healthy-side case? After a 'sent', move the stub to T + SEND_MIN_INTERVAL_MS and assert that the next post calls onSend again. Today no test goes red if the interval never expires.

Follow-up on my earlier review:

  • Rendered evidence for the new states: fixed. Shots 5 to 10 now come from the real CrewDynamicDashboard and CrewProfileSettings, and shot 3 is gone.
  • Preview off still called the gateway: fixed. onSend is passed only when dashboard_card_send === true, and a side-panel test pins it.
  • POST /api/crons/tools: fixed. It is now named in the route test, and the handler gates it per tool, with a wiring test.
  • tiedToFrame mocked to the same focus check that hasGesture makes: still open. See the optional notes.

Optional:

  • CrewDynamicDashboard.test.tsx:53-56 still mocks tiedToFrame as document.activeElement === frame, so deleting || !tiedToFrame(frame) at CrewDynamicDashboard.tsx:517 turns no test red. A mock with its own flag, plus one case where hasGesture is true and tiedToFrame is false, would pin it. The Proof line also still names an older head.
  • docs/request-for-change/rfc-dashboard-card-send.md still says the switch is on by default (line 168), that built-in pages keep posting act (line 398), that hasGesture alone is the gate, and that #22379 is the implementation. Bringing it in line with the four departures in the description would make it accurate for whoever accepts it.
  • CrewDynamicDashboard.tsx grows from 1,534 to 1,713 lines. Moving the send state into a sibling hook would keep the file under 1,600 lines and give the interval tests one place to inject a clock.

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

GPT finding on c9ebde4 (CrewDynamicDashboard.test.tsx:314 and :331, send-interval tests read the real clock) fixed in 70b45ac: both tests now stub Date.now() to a fixed instant, restored by the describe block afterEach (vi.restoreAllMocks). Test-only change. Held head is now 70b45ac.

chenmingwei23 and others added 2 commits November 9, 2026 18:35
…-default preview

A button on a crewmate's Dashboard tab can send its reply into that
crewmate's own thread in one click (kirocrew-dashboard:send), instead of
only filling the chat box. It is a per-crewmate preview, off by default:
until a crewmate opts in on its Profile tab, send behaves exactly as act.

The send crosses a trust boundary, so the person must be the one who
sends: the host sends only when the click is tied to the page's own frame
(tiedToFrame, which a page's self-focus() cannot pass), and the gateway
re-checks the payload and refuses what a card may not do (busy thread,
open approval or question, rate limit). A card turn is tagged
[Dashboard card], never counts as an approval, carries no owner directive
authority, and inherits no auto-approval even in a trust thread. The
sandboxed frame's CSP is unchanged.

Fixes #22367
Per review: the repo takes no new regex in product code. _CONTROL_CHARS
becomes a per-character ord() test. _DELEGATION_ROUTES and
_TASKRUNNER_STOPS become sets of segment shapes after /api/, where None
is any one non-empty segment and one trailing slash is dropped. Segments
come from yarl.URL.build(path=..., encoded=True).parts (no decoding, empty
segments kept). Same accept/refuse result as the old patterns on every
route; tests pin trailing-slash, empty-segment and extra-segment cases and
more control characters.

Also: a different reply posted inside the send interval (or while a send
is in flight) now fills the composer instead of being dropped; only a
repeat of the same text is dropped as a double click.

A send refused after a newer reply was filled while it was in flight is
added to the composer (onActKeep -> mergePaneDraft), so it cannot swap
out that newer reply.
@KiroCrewCaptain

Copy link
Copy Markdown
Collaborator

Thanks for the steady follow-through on this PR. I reviewed head 7525727 and found no blocking defect.

This changes behaviour users already rely on, so it needs a design sign-off from a maintainer before it can merge. A maintainer will post the decision here.

To propose a design, follow the request-for-change process in CONTRIBUTING.md (docs/request-for-change/). The draft RFC for this feature already exists, so acceptance would be recorded in that RFC.

Status of my earlier review items:

  • Replace the three regexes in dashboard/card_send.py with plain checks: fixed. A maintainer also asked for this, and it is fixed on this head too.
  • With the preview off, a card click behaves like today's act: fixed. onSend is passed only when dashboard_card_send === true, and a side-panel test pins it.
  • Rendered evidence for the new Dashboard and Profile states: fixed.
  • spawn signature pin and the fr and ko locale strings: fixed.
  • POST /api/crons/tools named in the route test: fixed.
  • Send-interval tests read the real clock: fixed. Both tests now stub Date.now (CrewDynamicDashboard.test.tsx:304 and :322). The healthy-side case, where a send goes through again after SEND_MIN_INTERVAL_MS, was not added and is still worth adding.

What this review checked on this head:

  • The card gate runs before slot creation.
  • The busy, Pause-all and pending-decision rechecks run again after the awaits.
  • The card mark carries through Continue, Regenerate, recovery and crash reconcile.
  • Every auto-approve rung in tool_approval.py is skipped for a card turn, and a hook DENY still applies.
  • The spawn and delegation fences refuse a card turn.
  • Sending stays off unless the setting is a real true.

Optional:

  • CrewDynamicDashboard.test.tsx:53-56 mocks tiedToFrame with the same focus check that hasGesture already makes. So deleting || !tiedToFrame(frame) at CrewDynamicDashboard.tsx:517 fails no test, and the Proof line names an older head. One way to pin it: a mock with its own flag, plus one case where hasGesture holds but tiedToFrame is false.
  • No test covers keeping a card turn out of the native-crew, own-worker and own-child auto-approve. Deleting not _card_turn and at tool_approval.py:1114 fails no test. A _card_origin = True case on the existing _decide() harness would cover it.
  • docs/request-for-change/rfc-dashboard-card-send.md still describes the earlier design: default on (line 168), built-in pages posting act (line 398), hasGesture alone as the gate, and feat(dashboard): a Dashboard card can send its reply in one click #22379 as the implementation. Its index row says the same. Updating them to the four departures in the description would let whoever accepts the RFC read the design that ships.

@bolichen97 bolichen97 left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Approved at 7525727. The direction is signed by the maintainer: an ordinary feature behind a per-crewmate preview, off by default, where off behaves exactly like main.

Our earlier point is fixed. card_send.py no longer uses re at all, and a search of the added product lines found no new regex in Python or the frontend. The control-character check in CrewDynamicDashboard.tsx is the existing actText pattern moved unchanged into replyText.

What I checked:

  • The gate: card_send_refusal runs before the slot is created. It admits only the owner's dashboard (no app token), and only an existing crewmate DM whose binding matches. The crewmate's dashboard_card_send must be a real True. The text is checked (trimmed, at most 600 chars, no control characters), the thread must be idle, nothing may be open (no approval, permission or question), and there is a 3 s per-thread limit. Every decision is written to the SEL.
  • After admission: the body is reduced to the text and the thread. The turn carries the [Dashboard card] prefix and no directive or owner authority. Every auto-approve rung is skipped for it (hook list, native crew, trusted patterns, trust-reads, trust and YOLO), while a hook deny still denies.
  • Delegation from a card turn: delegation routes, the non-read cron tools and sub-agent spawns are refused, using the arrival-time mark so stopping the turn mid-request can't unmark it.
  • Re-runs: continue, regenerate, recovery requeue, queue drain and the shared-crew restart note all carry the card mark, so a re-run stays a card turn.
  • Non-card sends: every new branch is behind card_origin or card_turn_seen, so typed sends behave as before.
  • Host: the host sends only on a click tied to the frame, to the tab's own confirmed slot. Any refusal fills the composer, and an indeterminate result shows a notice instead of resending.

CI: all 100 checks are green on this head. Sensitive Change Review's earlier rate-limit red passed on rerun.

One doc fix, please: line 174 of docs/request-for-change/rfc-dashboard-card-send.md says default on, but the code ships off and off is what is signed. Please correct it, and record the maintainer's acceptance in that RFC (status and section 7).

@chenmingwei23

Copy link
Copy Markdown
Contributor Author

Demo video: a button on a Bot's Dashboard page sends its message to the Bot, and the Bot answers in its chat. Recorded on main 01fcf6d.

pr33203.mp4

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.

Dashboard card button can send a reply into the crewmate's thread, not only fill the composer

4 participants