From c2633823fb5bfe39d9bb2d284d8bec6c111b9a06 Mon Sep 17 00:00:00 2001
From: Adam Malczewski <github@tradam.dev>
Date: Mon, 29 Jun 2026 12:12:18 +0900
Subject: feat(chat): cancel a queued steering message from the UI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements the frontend for the cancel-queued-message backend feature
(transport-contract 0.23.0 → 0.24.0, ADDITIVE). While a turn is generating
and a user message is queued (awaiting steering delivery), the user can now
cancel a single queued message by id so it never runs.

- Consume the contract: regenerate the .dispatch/transport-contract.reference.md
  mirror to 0.24.0; add chat.queue.cancel to the exhaustive WsClientMessage
  guard (core/wire/conformance.ts) + its test.
- ChatTransport port accepts ChatQueueCancelMessage; cancelQueuedMessage(id)
  on the chat store + app store sends chat.queue.cancel { conversationId,
  messageId } (fire-and-forget, idempotent — the server no-ops an already-
  drained/unknown id).
- UI: a × cancel affordance per queued row in MessageQueueList.svelte,
  threaded through SurfaceView's onCancelQueuedMessage (dispatched on
  rendererId, never the surface id) and wired to store.cancelQueuedMessage.
  Optimistic removal (pure selectVisibleMessages/reconcileCancelledIds in
  logic/message-queue.ts) hides the row on click and reconciles from the
  message-queue surface's post-cancel snapshot. No new event handling — the
  existing surface subscription reflects the result.

Tests: +12 (chat store cancel op ×3, optimistic-removal logic ×11 already
existed pattern, MessageQueueList component cancel behavior ×9).

Repo fix: package.json + bun.lock were still pinning file:../dispatch-backend/...
(stale from the dispatch-backend → backend rename) — corrected to
file:../backend/packages/...; bun install now resolves natively with no
worktree symlink hack.

typecheck 0/0, 1140 tests green (run twice), biome clean, build OK.
---
 .../surface-host/logic/message-queue.test.ts       | 59 +++++++++++++++++++++-
 1 file changed, 58 insertions(+), 1 deletion(-)

(limited to 'src/features/surface-host/logic/message-queue.test.ts')

diff --git a/src/features/surface-host/logic/message-queue.test.ts b/src/features/surface-host/logic/message-queue.test.ts
index 8d55eb7..ae91c8f 100644
--- a/src/features/surface-host/logic/message-queue.test.ts
+++ b/src/features/surface-host/logic/message-queue.test.ts
@@ -1,6 +1,10 @@
 import type { QueuedMessage } from "@dispatch/wire";
 import { describe, expect, it } from "vitest";
-import { parseMessageQueuePayload } from "./message-queue";
+import {
+  parseMessageQueuePayload,
+  reconcileCancelledIds,
+  selectVisibleMessages,
+} from "./message-queue";
 
 const msg = (id: string, text: string, queuedAt = 1_700_000_000_000): QueuedMessage => ({
   id,
@@ -46,3 +50,56 @@ describe("parseMessageQueuePayload", () => {
     expect(parseMessageQueuePayload(payload)).toBeNull();
   });
 });
+
+describe("selectVisibleMessages", () => {
+  it("returns the snapshot unchanged when nothing is cancelled", () => {
+    const messages = [msg("m1", "a"), msg("m2", "b")];
+    expect(selectVisibleMessages(messages, new Set())).toBe(messages);
+  });
+
+  it("hides the optimistically-cancelled row", () => {
+    const messages = [msg("m1", "a"), msg("m2", "b"), msg("m3", "c")];
+    expect(selectVisibleMessages(messages, new Set(["m2"])).map((m) => m.id)).toEqual(["m1", "m3"]);
+  });
+
+  it("hides multiple cancelled rows", () => {
+    const messages = [msg("m1", "a"), msg("m2", "b"), msg("m3", "c")];
+    expect(selectVisibleMessages(messages, new Set(["m1", "m3"])).map((m) => m.id)).toEqual(["m2"]);
+  });
+
+  it("tolerates a cancelled id not present in the snapshot (no-op)", () => {
+    const messages = [msg("m1", "a")];
+    expect(selectVisibleMessages(messages, new Set(["ghost"])).map((m) => m.id)).toEqual(["m1"]);
+  });
+});
+
+describe("reconcileCancelledIds", () => {
+  it("returns an empty set when nothing was cancelled", () => {
+    const result = reconcileCancelledIds([msg("m1", "a")], new Set());
+    expect(result.size).toBe(0);
+  });
+
+  it("drops ids the surface confirmed gone (no longer queued)", () => {
+    // m1 still queued (cancel pending), m2 confirmed gone (left the snapshot).
+    const messages = [msg("m1", "a")];
+    const result = reconcileCancelledIds(messages, new Set(["m1", "m2"]));
+    expect([...result]).toEqual(["m1"]);
+  });
+
+  it("returns the SAME set identity when nothing changed (no spurious cycle)", () => {
+    const messages = [msg("m1", "a"), msg("m2", "b")];
+    const cancelled = new Set(["m1", "m2"]);
+    expect(reconcileCancelledIds(messages, cancelled)).toBe(cancelled);
+  });
+
+  it("returns an empty set when all cancels were confirmed", () => {
+    const messages = [msg("m1", "a")];
+    expect(reconcileCancelledIds(messages, new Set(["m2", "m3"])).size).toBe(0);
+  });
+
+  it("keeps a still-queued cancelled id (cancel still pending)", () => {
+    const messages = [msg("m1", "a"), msg("m2", "b")];
+    const result = reconcileCancelledIds(messages, new Set(["m2"]));
+    expect([...result]).toEqual(["m2"]);
+  });
+});
-- 
cgit v1.2.3