Rich session activity in the messaging apps, Slack first (CHOO-2621)

[simonflk-sb]

Purpose

Someone watching an agent work from Slack cannot tell what it is doing, and
cannot answer it when it asks for something — the only signal today is a
plain-text "working…" indicator. This builds the layer between the session
interaction contract and the messaging platforms that turns a session's
requests and turn activity into a real, answerable presence in a channel,
Slack first.

Key Changes

• A platform-neutral session projection. The contract is mirrored into
  Python (a byte-identical lift of session-v1 from the upstream SDK branch)
  and held as a per-session replica: coalescing, dedup by (itemId, revision)
  / (requestId, revision), and deciding channel root versus a secondary
  surface.
• Request cards on Slack. An approval or a set of questions renders as
  buttons plus a text fallback that is answerable by typing (R1 2), backed
  by a handle reserved per request so an answer always resolves to the right
  card and revision.
• Turn activity as one message per turn, edited in place rather than
  reposted, ending on the turn's own state — streamed into a thread as a
  plan block where Slack allows it, posted and rewritten at the channel
  root otherwise.
• A verified inbound path. A press or a typed answer becomes a Command
  from a verified Switch identity, never from the payload; a refusal (stale
  card, unresolvable actor) is told back to the person, threaded under the
  card, on every collaboration platform — not just Slack.
• post_rich / update_rich on the adapter port, so which renderer draws
  a turn or a card is each adapter's own choice. The base falls back to a
  short neutral turn summary for a platform with no renderer of its own yet;
  a request card has no neutral form yet and is stubbed pending the first
  off-Slack renderer.
• !session-demo, behind a feature flag, replays a recorded fixture
  through the whole path into a real bridged channel — the way this has been
  verified against actual Slack behaviour with no backend in place yet.

Design Decisions

• The existing runtime-state indicator is untouched and stays as the fallback
  for connectors that cannot speak the contract.
• Room interaction (posting, inviting, attachments) stays on the MCP server,
  out of the session replica — session activity and room interaction are
  different things.
• Out of scope here: the server half (routes, storage, leases, reservations —
  PR CHOO-2667 — the server side of the session interaction contract #411). This branch is driven from fixtures until that lands, so nothing
  yet consumes the Commands it builds.

Testing

Full test suite passes locally (2,900+ tests, including the Postgres-backed
ones), with no change to Slack's rendered output guarded by the existing
Slack-specific suite passing unmodified throughout. Manually exercised
against a real Slack workspace via !session-demo.

Not for merge yet. Targets a temporary base branch so only this branch's
code is under review; lands once the upstream contract is accepted and the
server half (#411) is in place.

[github-actions]

All contributors have signed the CLA. ✅
_{Posted by the CLA Assistant Lite bot.}

[simonflk-sb]

I have read the CLA Document and I hereby sign the CLA

[simonflk-sb]

json.dumps defaults to ensure_ascii=True, so an emoji counts as 12 bytes here and 4 on the host

[simonflk-sb]

Sent by 🤖 @simonflk.remote-coder from Switch:

Good catch, and worse than it looks: it is not only a mismatch, it is a mismatch in the rejecting direction. An event the host sent well inside 64 KiB gets refused on arrival here, and the less ASCII it contains the sooner. A message that is mostly emoji or CJK hits the cap at roughly a third of the size the host allows.

Fixed in 870990c — ensure_ascii=False, so what is counted is UTF-8 of the same string JSON.stringify produces, which is what TextEncoder().encode(...).byteLength counts in validation.ts.

The test has no TypeScript counterpart, because the divergence is in Python's defaults rather than in the contract: it asserts event_bytes({"a": "😀"}) == len('{"a":"😀"}'.encode()) and that a notice of 10,000 emoji parses instead of raising PAYLOAD_TOO_LARGE. Both fail before the change.